Infix operators

1. normal arithmetic (potentially inefficient because of temporaries)
   • = assignment
   • + the sum
   • - the difference
   • * the product
   • / integer quotient (truncated "towards zero")
   • % remainder (same sign as quotient if non-zero); satisfies a = b*(a/b)+(a%b); see also LeastNNegRemainder and SymmRemainder (below)

NOTE: you cannot use ^ for exponentiation; you must use the function power instead. We decided this because it is too easy to write misleading code: for instance, a*b^2 is interpreted by the compiler as (a*b)^2. There is no way to make the C++ compiler use the expected interpretation.

1. arithmetic and assignment
   • +=, -=, *=, /=, %= -- definitions as expected; if RHS is a BigInt LHS must be BigInt

2. arithmetic ordering
   • ==, !=
   • <, <=, >, >= -- comparison (using the normal arithmetic ordering) -- see also the cmp function below.

3. increment/decrement
   • ++, -- (prefix, e.g. ++a) use these if you can
   • ++, -- (postfix, e.g. a++) avoid these if you can, as they create temporaries

cmp

(three way comparison)

• cmp(a, b) -- returns an int which is < 0, == 0, or > 0 if a < b, a == b, or a > b respectively
• CmpAbs(a,b) -- same as cmp(abs(a),abs(b)) but might be faster.

Sundry standard functions

IMPORTANT NOTES

• several basic number theoretical operations are defined in NumTheory
• for random numbers see random

The arguments of the functions below may be either a machine integer or a BigInt.

• abs(n) -- the absolute value of n
• sign(n) -- returns int with value -1 if n<0, 0 if n==0, and +1 if n>0
• LeastNNegRemainder(x,m) -- least non-negative remainder; throws ERR::DivByZero if m==0; result is long if m is a machine integer
• SymmRemainder(x,m) -- symmetric remainder; throws ERR::DivByZero if m==0; result is long if m is a machine integer
• log(n) -- natural logarithm of n (as a double); error if `` n <= 0``
• LogAbs(n) -- equiv to log(abs(n))
• RoundDiv(n,d)-- rounded division of n by d, (currently halves round away from 0)
• MultiplicityOf2(n) -- return a long being the multiplicity of 2 dividing n; error if n==0.
• FloorSqrt(n) -- the integer part (floor) of the square root of n
• FloorLog2(n) -- same as FloorLogBase(n,2)
• FloorLog10(n) -- same as FloorLogBase(n,10)
• FloorLogBase(n,b)-- (returns long) the integer part (floor) of log(abs(n))/log(b); error if n=0 or b<2
• SmallPower(a, b) -- (returns long) returns a to the power b (error if b<0; no check for overflow)

These functions always return BigInt

• power(a, b) -- returns a to the power b (error if b<0); power(0,0) gives 1
• factorial(n) -- factorial for non-negative n
• primorial(n) -- primorial for non-negative n
• LogFactorial(n) -- approx natural log of factorial(n) (abs.err. < 5*10^(-8))
• RangeFactorial(lo,hi) -- lo*(lo+1)*(lo+2)*...*hi NB both limits are included!
• binomial(n, r) -- binomial coefficient
• fibonacci(n) -- n-th Fibonacci number
• FloorRoot(N,r) -- floor of the r-th root of N (error if N < 0 or if r<2); see also IsExactFloorRoot

Conversion functions

Only for BigInt

• mantissa(N) -- N represented as a floating-point number. If N is zero, produces 0.0. If N>0, produces a value between 0.5 and 0.999...; otherwise (when N<0) a value between -0.5 and -0.999... The bits of the floating point result are the topmost bits of the binary representation of N.
• exponent(N) -- result is a long whose value is the least integer e such that 2^e > abs(n). If N is zero, result is zero.

Miscellany

Only for BigInt

• SizeInBase(N, b) -- (returns long) the number of digits N has when written in base b. Very fast! WARNING the result may sometimes to be too large by 1; use 1+FloorLogBase(N) to get the exact result.

Procedures for arithmetic

These procedures are ugly but may give a slight gain in speed. Use them only if you really must; it is probably better to use GMP directly if speed is so very important.

We expect these procedures (except quorem) to become obsolete when CoCoALib upgrades to the C++11 standard.

Assignment is always to leftmost argument(s) a, a BigInt. Second and/or third argument of type BigInt.

• add(a, b, c) -- a = b+c
• sub(a, b, c) -- a = b-c
• mul(a, b, c) -- a = b*c
• div(a, b, c) -- a = b/c (truncated integer quotient)
• mod(a, b, c) -- a = b%c (remainder s.t. b = quot*c + rem)
• quorem(a, b, c, d) -- same as a = c/d, b = c%d
• divexact(a, b, c) -- a = b/c (fast, but division must be exact)
• power(a, b, c) -- a = b^c, where 0^0 gives 1
• neg(a, b) -- a = -b
• abs(a, b) -- a = abs(b)