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

CONTENTS

#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