R: Basic Arithmetic Operators for Large Integers ("bigz")

bigz operators {gmp} | R Documentation

## Basic Arithmetic Operators for Large Integers ("bigz")

### Description

Addition, substraction, multiplication, (integer) division, remainder of division, multiplicative inverse, power and logarithm functions.

### Usage

    add.bigz(e1, e2)
    sub.bigz(e1, e2 = NULL)
    mul.bigz(e1, e2)
    div.bigz(e1, e2)
    divq.bigz(e1,e2) ## ==  e1 %/% e2
    mod.bigz(e1, e2) ## ==  e1 %%  e2
    ## S3 method for class 'bigz'
    abs(x)

    inv.bigz(a, b,...)## == (1 / a) (modulo b)

    pow.bigz(e1, e2,...)## == e1 ^ e2

    ## S3 method for class 'bigz'
    log(x, base=exp(1))
    ## S3 method for class 'bigz'
    log2(x)
    ## S3 method for class 'bigz'
    log10(x)

### Arguments

`x` | bigz, integer or string from an integer
`e1, e2, a,b` | bigz, integer or string from an integer
`base` | base of the logarithm; base e as default
`...` | Additional parameters

### Details

Operators can be used directly when objects are of class bigz: a + b, log(a), etc.

For details about the internal modulus state, and the rules applied for arithmetic operations on big integers with a modulus, see the `bigz` help page.

`a / b` = `div(a,b)` returns a rational number unless the operands have a (matching) modulus where `a * b^-1` results.
`a %/% b` (or, equivalently, `divq(a,b)`) returns the quotient of simple integer division (with truncation towards zero), possibly re-adding a modulus at the end (but not using a modulus like in `a / b`).

`r <- inv.bigz(a, m)`, the multiplicative inverse of `a` modulo m, corresponds to `1/a` or `a ^-1` from above when `a` has modulus `m`. Note that a not always has an inverse modulo m, in which case `r` will be `NA` with a warning that can be turned off via

    options("gmp:warnNoInv" = FALSE)

.

### Value

Apart from `/` (or `div`), where rational numbers (`bigq`) may result, these functions return an object of class `"bigz"`, representing the result of the arithmetic operation.

### Author(s)

Immanuel Scholz and Antoine Lucas

### References

The GNU MP Library, see https://gmplib.org

### Examples

    # 1+1=2
    as.bigz(1) + 1
    as.bigz(2)^10
    as.bigz(2)^200

    # if my.large.num.string is set to a number, this returns the least byte
    (my.large.num.string <- paste(sample(0:9, 200, replace=TRUE), collapse=""))
    mod.bigz(as.bigz(my.large.num.string), "0xff")

    # power exponents can be up to MAX_INT in size, or unlimited if a
    # bigz's modulus is set.
    pow.bigz(10,10000)

    ## Modulo 11,   7 and 8 are inverses :
    as.bigz(7, mod = 11) * 8 ## ==>  1  (mod 11)
    inv.bigz(7, 11)## hence, 8
    a <- 1:10
    (i.a <- inv.bigz(a, 11))
    d <- as.bigz(7)
    a %/% d  # = divq(a, d)
    a %%  d  # = mod.bigz (a, d)

    (ii <- inv.bigz(1:10, 16))
    ## with 5 warnings (one for each NA)
    op <- options("gmp:warnNoInv" = FALSE)
    i2 <- inv.bigz(1:10, 16) # no warnings
    (i3 <- 1 / as.bigz(1:10, 16))
    i4 <- as.bigz(1:10, 16) ^ -1
    stopifnot(identical(ii, i2),
    	  identical(as.bigz(i2, 16), i3),
    	  identical(i3, i4))
    options(op)# revert previous options' settings

    stopifnot(inv.bigz(7, 11) == 8,
              all(as.bigz(i.a, 11) * a == 1),
              identical(a %/% d, divq.bigz(1:10, 7)),
              identical(a %%  d, mod.bigz (a, d))
     )

[Package gmp version 0.6-2 Index]