Math::BigInt

sticks

  use Math::BigInt;
  # or make it faster with huge numbers: install (optional)
  # Math::BigInt::GMP and always use (it will fall back to
  # pure Perl if the GMP library is not installed):
  # (See also the L<MATH LIBRARY> section!)
  # will warn if Math::BigInt::GMP cannot be found
  use Math::BigInt lib => 'GMP';
  # to suppress the warning use this:
  # use Math::BigInt try => 'GMP';
  # dies if GMP cannot be loaded:
  # use Math::BigInt only => 'GMP';
  my $str = '1234567890';
  my @values = (64,74,18);
  my $n = 1; my $sign = '-';
  # Number creation
  my $x = Math::BigInt->new($str);      # defaults to 0
  my $y = $x->copy();                   # make a true copy
  my $nan  = Math::BigInt->bnan();      # create a NotANumber
  my $zero = Math::BigInt->bzero();     # create a +0
  my $inf = Math::BigInt->binf();       # create a +inf
  my $inf = Math::BigInt->binf('-');    # create a -inf
  my $one = Math::BigInt->bone();       # create a +1
  my $mone = Math::BigInt->bone('-');   # create a -1
  my $pi = Math::BigInt->bpi();         # returns '3'
                                        # see Math::BigFloat::bpi()
  $h = Math::BigInt->new('0x123');      # from hexadecimal
  $b = Math::BigInt->new('0b101');      # from binary
  $o = Math::BigInt->from_oct('0101');  # from octal
  $h = Math::BigInt->from_hex('cafe');  # from hexadecimal
  $b = Math::BigInt->from_bin('0101');  # from binary
  # Testing (don't modify their arguments)
  # (return true if the condition is met, otherwise false)
  $x->is_zero();        # if $x is +0
  $x->is_nan();         # if $x is NaN
  $x->is_one();         # if $x is +1
  $x->is_one('-');      # if $x is -1
  $x->is_odd();         # if $x is odd
  $x->is_even();        # if $x is even
  $x->is_pos();         # if $x > 0
  $x->is_neg();         # if $x < 0
  $x->is_inf($sign);    # if $x is +inf, or -inf (sign is default '+')
  $x->is_int();         # if $x is an integer (not a float)
  # comparing and digit/sign extraction
  $x->bcmp($y);         # compare numbers (undef,<0,=0,>0)
  $x->bacmp($y);        # compare absolutely (undef,<0,=0,>0)
  $x->sign();           # return the sign, either +,- or NaN
  $x->digit($n);        # return the nth digit, counting from right
  $x->digit(-$n);       # return the nth digit, counting from left
  # The following all modify their first argument. If you want to pre-
  # serve $x, use $z = $x->copy()->bXXX($y); See under L<CAVEATS> for
  # why this is necessary when mixing $a = $b assignments with non-over-
  # loaded math.
  $x->bzero();          # set $x to 0
  $x->bnan();           # set $x to NaN
  $x->bone();           # set $x to +1
  $x->bone('-');        # set $x to -1
  $x->binf();           # set $x to inf
  $x->binf('-');        # set $x to -inf
  $x->bneg();           # negation
  $x->babs();           # absolute value
  $x->bsgn();           # sign function (-1, 0, 1, or NaN)
  $x->bnorm();          # normalize (no-op in BigInt)
  $x->bnot();           # two's complement (bit wise not)
  $x->binc();           # increment $x by 1
  $x->bdec();           # decrement $x by 1
  $x->badd($y);         # addition (add $y to $x)
  $x->bsub($y);         # subtraction (subtract $y from $x)
  $x->bmul($y);         # multiplication (multiply $x by $y)
  $x->bdiv($y);         # divide, set $x to quotient
                        # return (quo,rem) or quo if scalar
  $x->bmuladd($y,$z);   # $x = $x * $y + $z
  $x->bmod($y);         # modulus (x % y)
  $x->bmodpow($y,$mod); # modular exponentiation (($x ** $y) % $mod)
  $x->bmodinv($mod);    # modular multiplicative inverse
  $x->bpow($y);         # power of arguments (x ** y)
  $x->blsft($y);        # left shift in base 2
  $x->brsft($y);        # right shift in base 2
                        # returns (quo,rem) or quo if in sca-
                        # lar context
  $x->blsft($y,$n);     # left shift by $y places in base $n
  $x->brsft($y,$n);     # right shift by $y places in base $n
                        # returns (quo,rem) or quo if in sca-
                        # lar context
  $x->band($y);         # bitwise and
  $x->bior($y);         # bitwise inclusive or
  $x->bxor($y);         # bitwise exclusive or
  $x->bnot();           # bitwise not (two's complement)
  $x->bsqrt();          # calculate square-root
  $x->broot($y);        # $y'th root of $x (e.g. $y == 3 => cubic root)
  $x->bfac();           # factorial of $x (1*2*3*4*..$x)
  $x->bnok($y);         # x over y (binomial coefficient n over k)
  $x->blog();           # logarithm of $x to base e (Euler's number)
  $x->blog($base);      # logarithm of $x to base $base (f.i. 2)
  $x->bexp();           # calculate e ** $x where e is Euler's number
  $x->round($A,$P,$mode);  # round to accuracy or precision using
                           # mode $mode
  $x->bround($n);          # accuracy: preserve $n digits
  $x->bfround($n);         # $n > 0: round $nth digits,
                           # $n < 0: round to the $nth digit after the
                           # dot, no-op for BigInts
  # The following do not modify their arguments in BigInt (are no-ops),
  # but do so in BigFloat:
  $x->bfloor();            # round towards minus infinity
  $x->bceil();             # round towards plus infinity
  $x->bint();              # round towards zero
  # The following do not modify their arguments:
  # greatest common divisor (no OO style)
  my $gcd = Math::BigInt::bgcd(@values);
  # lowest common multiple (no OO style)
  my $lcm = Math::BigInt::blcm(@values);
  $x->length();            # return number of digits in number
  ($xl,$f) = $x->length(); # length of number and length of fraction
                           # part, latter is always 0 digits long
                           # for BigInts
  $x->exponent();         # return exponent as BigInt
  $x->mantissa();         # return (signed) mantissa as BigInt
  $x->parts();            # return (mantissa,exponent) as BigInt
  $x->copy();             # make a true copy of $x (unlike $y = $x;)
  $x->as_int();           # return as BigInt (in BigInt: same as copy())
  $x->numify();           # return as scalar (might overflow!)
  # conversion to string (do not modify their argument)
  $x->bstr();         # normalized string (e.g. '3')
  $x->bsstr();        # norm. string in scientific notation (e.g. '3E0')
  $x->as_hex();       # as signed hexadecimal string with prefixed 0x
  $x->as_bin();       # as signed binary string with prefixed 0b
  $x->as_oct();       # as signed octal string with prefixed 0
  # precision and accuracy (see section about rounding for more)
  $x->precision();       # return P of $x (or global, if P of $x undef)
  $x->precision($n);     # set P of $x to $n
  $x->accuracy();        # return A of $x (or global, if A of $x undef)
  $x->accuracy($n);      # set A $x to $n
  # Global methods
  Math::BigInt->precision();   # get/set global P for all BigInt objects
  Math::BigInt->accuracy();    # get/set global A for all BigInt objects
  Math::BigInt->round_mode();  # get/set global round mode, one of
                               # 'even', 'odd', '+inf', '-inf', 'zero',
                               # 'trunc' or 'common'
  Math::BigInt->config();      # return hash containing configuration

Math::BigInt

NAME

SYNOPSIS

DESCRIPTION

Input

Output

METHODS

ACCURACY and PRECISION

Precision P

Accuracy A

Fallback F

Rounding mode R

Infinity and Not a Number

INTERNALS

MATH LIBRARY

What library to use?

SIGN

mantissa(), exponent() and parts()

EXAMPLES

Autocreating constants

PERFORMANCE

Alternative math libraries

SUBCLASSING

Subclassing Math::BigInt

UPGRADING

Auto-upgrade

EXPORTS

CAVEATS

BUGS

SUPPORT

LICENSE

SEE ALSO

AUTHORS