Title:  ArbitraryPrecision Integer and FloatingPoint Mathematics 

Description:  Classes for storing and manipulating arbitraryprecision integer vectors and highprecision floatingpoint vectors. These extend the range and precision of the 'integer' and 'double' data types found in R. This package utilizes the 'Boost.Multiprecision' C++ library. It is specifically designed to work well with the 'tidyverse' collection of R packages. 
Authors:  David Hall [aut, cre, cph] 
Maintainer:  David Hall <[email protected]> 
License:  MIT + file LICENSE 
Version:  0.3.2.9000 
Built:  20240325 06:55:48 UTC 
Source:  https://github.com/davidchall/bignum 
bigfloat()
and as_bigfloat()
construct a vector designed to store numbers
with 50 decimal digits of precision.
is_bigfloat()
checks if an object is of class bignum_bigfloat
.
bigfloat(x = character())
as_bigfloat(x)
is_bigfloat(x)
x 
Object to be coerced or tested. 
An S3 vector of class bignum_bigfloat
.
NA_bigfloat_
to represent missing values.
format()
for pretty printing.
vignette("operations")
for supported operations.
# default options limit displayed precision
bigfloat(1) / 3
# display full precision
format(bigfloat(1) / 3, sigfig = 50, notation = "dec")
biginteger()
and as_biginteger()
construct a vector designed to store
any integer.
is_biginteger()
checks if an object is of class bignum_biginteger
.
biginteger(x = character())
as_biginteger(x)
is_biginteger(x)
x 
Object to be coerced or tested. 
An S3 vector of class bignum_biginteger
.
NA_biginteger_
to represent missing values.
format()
for pretty printing.
vignette("operations")
for supported operations.
# default options limit displayed precision
biginteger(2)^50L
# display full precision
format(biginteger(2)^50L, notation = "dec")
# lossy casts raise a warning
biginteger(c(2, 2.5, 3))
# suppress warnings if they are expected
suppressWarnings(biginteger(c(2, 2.5, 3)))
# unsigned integers can be specified as hexadecimal
biginteger("0xffffffff")
biginteger and bigfloat vectors support the standard arithmetic operations. The base R documentation can be found at Arithmetic.
These arithmetic operations are typestable, which means the output type depends only on the input types (not the input values). A biginteger vector is returned when the result must be an integer (e.g., addition of two integers). Otherwise a bigfloat vector is returned.
The following table summarizes the return type for each combination, where "integerlike" refers to integer and biginteger vectors and "floatlike" refers to double and bigfloat vectors.
Input 1  Operator  Input 2  Result  
Integerlike  +, , *, ^, %%  Integerlike  >  biginteger 
Integerlike  +, , *, ^, %%  Floatlike  >  bigfloat 
Floatlike  +, , *, ^, %%  Integerlike  >  bigfloat 
Floatlike  +, , *, ^, %%  Floatlike  >  bigfloat 
Any  /  Any  >  bigfloat 
Any  %/%  Any  >  biginteger 
Other bignum operations:
bignumcompare
,
bignummath
,
bignumspecial
x < biginteger(5)
y < bigfloat(2)
+x
x
x + y
x  y
x * y
x / y
x^y
x %% y
x %/% y
biginteger and bigfloat vectors support the standard comparison operations. The base R documentation can be found at Comparison.
A logical vector.
Other bignum operations:
bignumarith
,
bignummath
,
bignumspecial
x < biginteger(5)
y < bigfloat(2)
x < y
x > y
x <= y
x >= y
x == y
x != y
NA_biginteger_
and NA_bigfloat_
support missing values.
bigpi
is a higher precision version of pi
.
NA_biginteger_
NA_bigfloat_
bigpi
A biginteger
or bigfloat
vector of length 1.
NA
and pi
are the base constants.
NA_biginteger_
NA_bigfloat_
# default options limit displayed precision
bigpi
# display full precision
format(bigpi, sigfig = 50, notation = "dec")
Customize how a biginteger
or bigfloat
vector is displayed.
The precision can be controlled with a number of significant figures, or with
a maximum or fixed number of digits after the decimal point. You can also
choose between decimal, scientific and hexadecimal notations.
The default formatting applied when printing depends on the type of object:
standalone vector: consults "bignum.sigfig"
and "bignum.max_dec_width"
tibble column: consults "pillar.sigfig"
and "pillar.max_dec_width"
## S3 method for class 'bignum_biginteger'
format(
x,
...,
sigfig = NULL,
digits = NULL,
notation = c("fit", "dec", "sci", "hex")
)
## S3 method for class 'bignum_bigfloat'
format(x, ..., sigfig = NULL, digits = NULL, notation = c("fit", "dec", "sci"))
x 
A 
... 
These dots are for future extensions and must be empty. 
sigfig 
Number of significant figures to show. Must be positive.
Cannot be combined with If both 
digits 
Number of digits to show after the decimal point.
Positive values indicate the exact number of digits to show.
Negative values indicate the maximum number of digits to show (terminal
zeros are hidden if there are no subsequent nonzero digits).
Cannot be combined with 
notation 
How should the vector be displayed? Choices:

Character vector
# default uses decimal notation
format(bigfloat(1e12))
# until it becomes too wide, then it uses scientific notation
format(bigfloat(1e13))
# hexadecimal notation is supported for positive integers
format(biginteger(255), notation = "hex")
# significant figures
format(bigfloat(12.5), sigfig = 2)
# fixed digits after decimal point
format(bigfloat(12.5), digits = 2)
# maximum digits after decimal point
format(bigfloat(12.5), digits = 2)
biginteger and bigfloat vectors support many of the standard mathematical
operations. The base R documentation can be found by searching for the
individual functions (e.g. mean()
).
The returned value depends on the individual function. We recommend reading the base R documentation for a specific function to understand the expected result.
Other bignum operations:
bignumarith
,
bignumcompare
,
bignumspecial
# summary
x < bigfloat(1:5)
sum(x)
prod(x)
max(x)
min(x)
range(x)
mean(x)
# cumulative
x < bigfloat(1:5)
cumsum(x)
cumprod(x)
cummax(x)
cummin(x)
# rounding
x < bigfloat(1.5)
floor(x)
ceiling(x)
trunc(x)
# miscellaneous
x < bigfloat(2)
abs(x)
sign(x)
sqrt(x)
# logarithms and exponentials
x < bigfloat(2)
log(x)
log10(x)
log2(x)
log1p(x)
exp(x)
expm1(x)
# trigonometric
x < bigfloat(0.25)
cos(x)
sin(x)
tan(x)
acos(x)
asin(x)
atan(x)
cospi(x)
sinpi(x)
tanpi(x)
# hyperbolic
x < bigfloat(0.25)
cosh(x)
sinh(x)
tanh(x)
acosh(bigfloat(2))
asinh(x)
atanh(x)
# special functions
x < bigfloat(2.5)
gamma(x)
lgamma(x)
digamma(x)
trigamma(x)
factorial(x)
lfactorial(x)
biginteger and bigfloat support missing values (via NA_biginteger_
and
NA_bigfloat_
respectively).
bigfloat additionally supports positive and negative infinity and 'Not a Number' values. Usually these are the result of a calculation, but they can also be created manually by casting from numeric to bigfloat.
These functions check for the presence of these special values. The base R
documentation can be found at is.na()
and is.finite()
.
A logical vector.
Other bignum operations:
bignumarith
,
bignumcompare
,
bignummath
x < bigfloat(c(0, NA, Inf, Inf, NaN))
is.na(x)
is.finite(x)
is.infinite(x)
is.nan(x)
Generate a regular sequence of biginteger
or bigfloat
values.
When calling seq()
, exactly two of the following must be specified:
to
by
Either length.out
or along.with
## S3 method for class 'bignum_vctr'
seq(from, to = NULL, by = NULL, length.out = NULL, along.with = NULL, ...)
from 
Start value of the sequence. Always included in the result. A 
to 
Stop value of the sequence. Only included in the result if

by 
Amount to increment the sequence by.

length.out 
Length of the resulting sequence. 
along.with 
Vector who's length determines the length of the resulting sequence. 
... 
These dots are for future extensions and must be empty. 
A sequence with the type of from
.
seq(biginteger(0), 10, by = 2)
seq(biginteger(0), 10, length.out = 3)
seq(biginteger(0), by = 3, length.out = 3)
seq(bigfloat(0), by = 0.05, length.out = 6)