Math::BigInt(3p)Perl Programmers Reference Guide Math::BigInt(3p)
Math: . perl v5.8.8 2005-02-05 1 Math::BigInt(3p)Perl Programmers Reference Guide Math::BigInt(3p)  $x->bpow($y); # power of arguments (x ** y) $x->blsft($y); # left shift $x->brsft($y); # right shift $x->blsft($y,$n); # left shift, by base $n (like 10) $x->brsft($y,$n); # right shift, by base $n (like 10) $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-: perl v5.8.8 2005-02-05 2 Math::BigInt(3p)Perl Programmers Reference Guide Math::BigInt(3p) #Ints  (e.g. '3') $x->bsstr(); # norm. string in scientific notation (e.g. '3E0') ->round_mode(); # get/set global round mode, one of # 'even', 'odd', '+inf', '-inf', 'zero' or 'trunc' Math::BigInt->config(); # return hash containing configuration
All operators (inlcuding basic math operations) are over- loaded if you declare your big integers as $i = new Math::BigInt '123_456_789_123_456_789'; Operations with overloaded operators preserve the arguments which is exactly what you expect. Input Input values to these routines may be any string, that looks like a number and results in an integer, including hexadecimal and binary numbers. Scalars holding numbers may also be passed, but note that non-integer numbers may already have lost precision due to the conversation to float. Quote your input if you want perl v5.8.8 2005-02-05 3 Math::BigInt(3p)Perl Programmers Reference Guide Math::BigInt(3p). Output Output values are BigInt objects (normalized), except for the methods which return a string (see SYNOPSIS). Some routines ("is_odd()", "is_even()", "is_zero()", "is_one()", "is_nan()", etc.) return true or false, while others ("bcmp()", "bacmp()") return either undef (if NaN is involved), <0, 0 or >0 and are suited for sort.
Each of the methods below (except config(), accuracy() and precision()) accepts three additional parameters. These arguments $A, $P and $R are "accuracy", "precision" and "round_mode". Please see the section about "ACCURACY and PRECISION" for more information. config use Data::Dumper; print Dumper ( Math::BigInt->config() ); print Math::BigInt->config()->{lib},"\n"; Returns a hash containing the configuration, e.g. the ver- sion number, lib loaded etc. The following hash keys are currently filled in with the appropriate information. perl v5.8.8 2005-02-05 4 Math::BigInt(3p)Perl Programmers Reference Guide Math::BigInt(3p) } ); accuracy $x->accuracy(5); # local for $x CLASS->accuracy(5); # global for all members of CLASS # Note: This also applies to new()! ()! perl v5.8.8 2005-02-05 5 Math::BigInt(3p)Perl Programmers Reference Guide Math::BigInt(3p) Please see the section about "ACCURACY AND PRECISION" for further details. Value must be greater than zero. Pass an undef value to dis- able); # $x. precision $x->precision(-2); # local for $x, round at the second digit right of the dot $x->precision(2); # ditto, round at the second digit left of the dot CLASS->precision(5); # Global for all members of CLASS # This also applies to new()! CLASS->precision(-5); # ditto perl v5.8.8 2005-02-05 6 Math::BigInt(3p)Perl Programmers Reference Guide Math::BigInt(3p) $P = CLASS->precision(); # read out global precision $P = $x->precision(); # read out precision that affects $x Note: You probably want to use accuracy() instead. With accuracy you set the number of digits each result should have, with precision you set the place where to round! "precision()" sets or gets the global or local precision, aka at which digit before or after the dot to round all results. A set global precision also applies to all newly created numbers! In Math::BigInt, passing a negative number precision has no effect since no numbers have digits after the dot. In Math::BigFloat, it will round all results to P digits after the dot. Please see the section about "ACCURACY AND PRECISION" for further details. Pass an undef value to disable it: $x->precision(undef); Math::BigInt->precision(undef); Returns the current precision. For "$x-"precision()> it will return either the local precision of $x, or if not defined, the global. This means the return value represents the prev- ision that will be in effect for $x: $y = Math::BigInt->new(1234567); # unrounded print Math::BigInt->precision(4),"\n"; # set 4, print 4 $x = Math::BigInt->new(123456); # will be automatically rounded print $x; # print "120000"! Note: Works also for subclasses like Math::BigFloat. Each class has its own globals separated from Math::BigInt, but it is possible to subclass Math::BigInt and make the globals of the subclass aliases to the ones from Math::BigInt. brsft $x->brsft($y,$n); Shifts $x right by $y in base $n. Default is base 2, used are usually 10 and 2, but others work, too. Right shifting usually amounts to dividing $x by $n ** $y and truncating the result: perl v5.8.8 2005-02-05 7 Math::BigInt(3p)Perl Programmers Reference Guide Math::BigInt(3p) ). new . bnan $x = Math::BigInt->bnan(); Creates a new BigInt object representing NaN (Not A Number). If used on an object, it will set it to NaN: $x->bnan(); bzero $x = Math::BigInt->bzero(); Creates a new BigInt object representing zero. If used on an object, it will set it to zero: $x->bzero(); binf $x = Math::BigInt->binf($sign); Creates a new BigInt object representing infinity. The optional argument is either '-' or '+', indicating whether you want infinity or minus infinity. If used on an object, it will set it to infinity: $x->binf(); $x->binf('-'); perl v5.8.8 2005-02-05 8 Math::BigInt(3p)Perl Programmers Reference Guide Math::BigInt(3p) bone $x = Math::BigInt->binf($sign); Creates a new BigInt object representing one. The optional argument is either '-' or '+', indicating whether you want one or minus one. If used on an object, it will set it to one: $x->bone(); # +1 $x->bone('-'); # -1 is_one()/is_zero()/is_nan()/is_inf() ) is_pos()/is_neg() $x->is_pos(); # true if > 0 $x->is_neg(); # true if < 0 The methods return true if the argument is positive or nega- tive, respectively. "NaN" is neither positive nor negative, while "+inf" counts as positive, and "-inf" is negative. A "zero" is neither positive nor negative.. is_odd()/is_even()/is_int() $x->is_odd(); # true if odd, false for even $x->is_even(); # true if even, false for odd $x->is_int(); # true if $x is an integer The return true when the argument satisfies the condition. "NaN", "+inf", "-inf" are not integers and are neither odd perl v5.8.8 2005-02-05 9 Math::BigInt(3p)Perl Programmers Reference Guide Math::BigInt(3p) nor even. In BigInt, all numbers except "NaN", "+inf" and "-inf" are integers. bcmp $x->bcmp($y); Compares $x with $y and takes the sign into account. Returns -1, 0, 1 or undef. bacmp $x->bacmp($y); Compares $x with $y while ignoring their. Returns -1, 0, 1 or undef. sign $x->sign(); Return the sign, of $x, meaning either "+", "-", "-inf", "+inf" or NaN. If you want $x to have a certain sign, use one of the fol- lowing methods: $x->babs(); # '+' $x->babs()->bneg(); # '-' $x->bnan(); # 'NaN' $x->binf(); # '+inf' $x->binf('-'); # '-inf' digit $x->digit($n); # return the nth digit, counting from right If $n is negative, returns the digit counting from left. bneg $x->bneg(); Negate the number, e.g. change the sign between '+' and '-', or between '+inf' and '-inf', respectively. Does nothing for NaN or zero. perl v5.8.8 2005-02-05 10 Math::BigInt(3p)Perl Programmers Reference Guide Math::BigInt(3p) babs $x->babs(); Set the number to it's absolute value, e.g. change the sign from '-' to '+' and from '-inf' to '+inf', respectively. Does nothing for NaN or positive numbers. bnorm $x->bnorm(); # normalize (no-op) bnot $x->bnot(); Two's complement (bit wise not). This is equivalent to $x->binc()->bneg(); but faster.div $x->bdiv($y); # divide, set $x to quotient # return (quo,rem) or quo if scalar bmod $x->bmod($y); # modulus (x % y) perl v5.8.8 2005-02-05 11 Math::BigInt(3p)Perl Programmers Reference Guide Math::BigInt(3p) bmodinv num->bmodinv($mod); # modular inverse Returns the inverse of $num in the given modulus $mod. '"NaN"' is returned unless $num is relatively prime to $mod, i.e. unless "bgcd($num, $mod)==1". bmodpow $num->bmodpow($exp,$mod); # modular exponentation # ($num**$exp % $mod) Returns the value of $num taken to the power $exp in the modulus $mod using binary exponentation. ) bpow $x->bpow($y); # power of arguments (x ** y) blsft $x->blsft($y); # left shift $x->blsft($y,$n); # left shift, in base $n (like 10) brsft $x->brsft($y); # right shift $x->brsft($y,$n); # right shift, in base $n (like 10) band $x->band($y); # bitwise and perl v5.8.8 2005-02-05 12 Math::BigInt(3p)Perl Programmers Reference Guide Math::BigInt(3p) bior $x->bior($y); # bitwise inclusive or bxor $x->bxor($y); # bitwise exclusive or bnot $x->bnot(); # bitwise not (two's complement) bsqrt $x->bsqrt(); # calculate square-root bfac $x->bfac(); # factorial of $x (1*2*3*4*..$x) round $x->round($A,$P,$round_mode); Round $x to accuracy $A or precision $P using the round mode $round_mode. bround $x->bround($N); # accuracy: preserve $N digits bfround $x->bfround($N); # round to $Nth digit, no-op for BigInts bfloor $x->bfloor(); Set $x to the integer less or equal than $x. This is a no-op in BigInt, but does change $x in BigFloat. bceil $x->bceil(); Set $x to the integer greater or equal than $x. This is a no-op in BigInt, but does change $x in BigFloat. perl v5.8.8 2005-02-05 13 Math::BigInt(3p)Perl Programmers Reference Guide Math::BigInt(3p) bgcd bgcd(@values); # greatest common divisor (no OO style) blcm. exponent $x->exponent(); Return the exponent of $x as BigInt. mantissa $x->mantissa(); Return the signed mantissa of $x as BigInt. parts $x->parts(); # return (mantissa,exponent) as BigInt copy $x->copy(); # make a true copy of $x (unlike $y = $x;) as_int $x->as_int(); Returns $x as a BigInt (truncated towards zero). In BigInt this is the same as "copy()". "as_number()" is an alias to this method. "as_number" was introduced in v1.22, while "as_int()" was only introduced in v1.68. perl v5.8.8 2005-02-05 14 Math::BigInt(3p)Perl Programmers Reference Guide Math::BigInt(3p) bstr $x->bstr(); Returns a normalized string represantation of $x. bsstr $x->bsstr(); # normalized string in scientific notation as_hex $x->as_hex(); # as signed hexadecimal string with prefixed 0x as_bin $x->as_bin(); # as signed binary string with prefixed 0b
Since version v1.33, Math::BigInt and Math::BigFloat have full support for accuracy and precision based rounding, both automatically after every operation, as well as manually. This section describes the accuracy/precision handling in Math::Big* oth- ers people or documentation). During the rest of this document, the shortcuts A (for accu- racy), P (for precision), F (fallback) and R (rounding mode) will be used. Precision P A fixed number of digits before (positive) or after (nega- tive) preci- sions, because 1200 can have p = 0, 1 or 2 (depending on what the inital value was). It could also have p < 0, when the digits after the decimal point are zero. perl v5.8.8 2005-02-05 15 Math::BigInt(3p)Perl Programmers Reference Guide Math::BigInt(3p) The string output (of floating point numbers) will BigInts, no padding occurs. Accuracy A0000 has 8 and 0.000123 has 3..) 'trunc'. perl v5.8.8 2005-02-05 16 Math::BigInt(3p)Perl Programmers Reference Guide Math::BigInt(3p) All other implemented styles of rounding attempt to round to the "nearest digit." If the digit D immediately to the right of the rounding place (skipping the decimal point) is greater than 5, the number is incremented at the round- ing: 'even' rounds the digit at the rounding place to 0, 2, 4, 6, or 8 if it is not already. E.g., when rounding to the first sigdig, 0.45 becomes 0.4, -0.55 becomes -0.6, but 0.4501 becomes 0.5. 'odd' rounds the digit at the rounding place to 1, 3, 5, 7, or 9 if it is not already. E.g., when rounding to the first sigdig, 0.45 becomes 0.5, -0.55 becomes -0.5, but 0.5501 becomes 0.6. '+inf' round to plus infinity, i.e. always round up. E.g., when rounding to the first sigdig, 0.45 becomes 0.5, -0.55 becomes -0.5, and 0.4501 also becomes 0.5. '-inf' round to minus infinity, i.e. always round down. E.g., when rounding to the first sigdig, 0.45 becomes 0.4, -0.55 becomes -0.6, but 0.4501 becomes 0.5. 'zero' round to zero, i.e. positive numbers down, negative ones up. E.g., when rounding to the first sigdig, 0.45 becomes 0.4, -0.55 becomes -0.5, but 0.4501 becomes 0.5. The handling of A & P in MBI/MBF (the old core code shipped with Perl versions <= 5.7.2) is like this: Precision * ffround($p) is able to round to $p number of digits after the decimal point * otherwise P is unused Accuracy (significant digits) perl v5.8.8 2005-02-05 17 Math::BigInt(3p)Perl Programmers Reference Guide Math::BigInt(3p) * fround($a) rounds to $a significant digits * only fdiv() and fsqrt() take A as (optional) paramater + other operations simply create the same number (fneg etc), or more (fmul) of digits + rounding/truncating is only done when explicitly calling one of fround or ffround, and never for BigInt (not implemented) * fsqrt() simply hands its accuracy argument over to fdiv. * the documentation and the comment in the code indicate two different ways on howior) - length(dividend); So for lx = 3, ly = 9, scale = 10, scale will actually be 16 (10+9-3). Actually, the 'difference' added to the scale is calculated from the number of "significant digits" in dividend and divisor, which is derived by looking at the length of the mantissa. significant digits. The rounding after the division then uses the remainder and $y to determine wether it must round up or down. ? I have no idea which is the right way. That's why I used a slightly more ? simple scheme and tweaked the few failing testcases to match it. This is how it works now: Setting/Accessing perl v5.8.8 2005-02-05 18 Math::BigInt(3p)Perl Programmers Reference Guide Math::BigInt(3p) * You can set the A global via. Creating numbers *<< . Usage perl v5.8.8 2005-02-05 19 Math::BigInt(3p)Perl Programmers Reference Guide Math::BigInt(3p) *'. Precedence * precendence over P (Hint: A comes before P). If neither of them is defined, nothing is used, i.e. the result will have as many digits as it can (with an exception for fdiv/fsqrt) and will not be rounded. * There is another setting for fdiv() (and thus for fsqrt()). If neither of A or P is defined, :-) * fdiv() and fsqrt() as exceptions to guard against overflows. You must explicitely()-. perl v5.8.8 2005-02-05 20 Math::BigInt(3p)Perl Programmers Reference Guide Math::BigInt(3p) ?Maybe an extra option that forbids local A & P settings would be in order, ?so that intermediate rounding does not 'poison' further math? Overriding globals * * fsqrt() will hand its arguments to fdiv(), as it used to, only now for two arguments (A and P) instead of one Local settings *. Rounding * the rounding routines will use the respective global or local settings. fround()/bround() is for accuracy rounding, while ffround()/bfround() is for precision * the two rounding functions take as the second parameter one of the following rounding modes (R): 'even', 'odd', '+inf', '-inf', 'zero', 'trunc' * you can set<< . perl v5.8.8 2005-02-05 21 Math::BigInt(3p)Perl Programmers Reference Guide Math::BigInt(3p) Default values * R: 'even' * F: 40 * A: undef * P: undef Remarks * The defaults are set up so that the new code gives the same results as the old code (except in a few cases on fdiv): + Both A and P are undefined and thus will not be used for rounding after each operation. + round() is thus a no-op, unless given extra parameters A and P
While BigInt has extensive handling of inf and NaN, certain quirks remain. oct()/hex() rou- tines is not possible, this cannot be fixed from BigInt. ==, !=, <, >, <=, >= with NaNs BigInt's bcmp() routine currently returns undef to signal that a NaN was involved in a comparisation. However, the overload code turns that into either 1 or '' and thus operations like "NaN != NaN" might return wrong values. log(-inf) "log(-inf)" is highly weird. Since log(-x)=pi*i+log(x), then log(-inf)=pi*i+inf. However, since the imaginary part is finite, the real infinity "overshadows" it, so the number might as well just be infinity. However, the result is a complex number, and since BigInt/BigFloat can only have real numbers as results, the result is NaN. exp(), cos(), sin(), atan2() These all might have problems handling infinity right. perl v5.8.8 2005-02-05 22 Math::BigInt(3p)Perl Programmers Reference Guide Math::BigInt(3p)
The actual numbers are stored as unsigned big integers (with seperate sign). internally. See the respective math library module documentation for further details. SIGN. perl v5.8.8 2005-02-05 23 Math::BigInt(3p)Perl Programmers Reference Guide Math::BigInt(3p) mantissa(), exponent() and parts()  represen- tation() $x = Math::BigInt->bneg("1234"); # BigInt "-1234" $x = Math::BigInt->babs("-12345"); # BigInt "12345" $x = Math::BigInt->bnorm("-0 00"); # BigInt "0" $x = bint(1) + bint(2); # BigInt "3" $x = bint(1) + "2"; # ditto (auto-BigIntify of "2") $x = bint(1); # BigInt "1" $x = $x + 5 / 2; # BigInt "3" $x = $x ** 3; # BigInt "27" $x *= 2; # BigInt "54" $x = Math::BigInt->new(0); # BigInt "0" $x--; # BigInt "-1" $x = Math::BigInt->badd(4,5) # BigInt "9" print $x->bsstr(); # 9e+0 Examples for rounding: use Math::BigFloat; use Test; $x = Math::BigFloat->new(123.4567); $y = Math::BigFloat->new(123.456789); Math::BigFloat->accuracy(4); # no more A than 4 perl v5.8.8 2005-02-05 24 Math::BigInt(3p)Perl Programmers Reference Guide Math::BigInt(3p) ok ($x->copy()->fround(),123.4); # even rounding print $x->copy()->fround(),"\n"; # 123.4 Math::BigFloat->round_mode('odd'); # round to odd print $x->copy()->fround(),"\n"; # 123.5 Math::BigFloat->accuracy(5); # no more A than 5 Math::BigFloat->round_mode('odd'); # round to odd print $x->copy()->fround(),"\n"; # 123.46 $y = $x->copy()->fround(4),"\n"; # A = 4: 123.4 print "$y, ",$y->accuracy(),"\n"; # 123.4, 4 Math::BigFloat->accuracy(undef); # A not important now Math::BigFloat->precision(2); # P important print $x->copy()->bnorm(),"\n"; # 123.46 print $x->copy()- will be calcu- lated as perl scalar.'; do not work.'); perl v5.8.8 2005-02-05 25 Math::BigInt(3p)Perl Programmers Reference Guide Math::BigInt(3p) Without the quotes Perl would convert the large number to a floating point constant at compile time and then hand the result to BigInt, which results in an truncated result or a NaN. This also applies to integers that look like floating point constants: use Math::BigInt ':constant'; print ref(123e2),"\n"; print ref(123.2e2),"\n"; will print operatons. So Math::BigInt does currently not COW. The rewritten version of this module (vs. v0.01) is slower on certain operations, like "new()", "bstr()" and "num- ify()". The reason are that it does now more work and han- dles. perl v5.8.8 2005-02-05 26 Math::BigInt(3p)Perl Programmers Reference Guide Math::BigInt(3p) Alternative math libraries You can use an alternative library to drive Math::BigInt via: use Math::BigInt lib => 'Module'; See  per- mits it to support different storage methods. will need to provide it's own "new()" and can store additional hash keys in the object. There are also some package globals that must be defined, e.g.: perl v5.8.8 2005-02-05 27 Math::BigInt(3p)Perl Programmers Reference Guide Math::BigInt(3p) # glo- b. perl v5.8.8 2005-02-05 28 Math::BigInt(3p)Perl Programmers Reference Guide Math::BigInt(3p) Auto-upgrade The following methods upgrade themselves unconditionally; that is if upgrade is in effect, they will always hand up their work: bsqrt() div() blog() Beware: This list is not complete. All other methods upgrade themselves only when one (or all) of their arguments are of the class mentioned in $upgrade (This might change in later versions to a more sophisticated scheme):
broot() does not work The broot() function in BigInt may only work for small values. This will be fixed in a later version. Out of Memory! Under Perl prior to 5.6.0 having an "use Math::BigInt ':constant';" and "eval()" in your code will crash with "Out of memory". This is probably an overload/exporter bug. You can workaround by not having "eval()" and ':con- stant' at the same time or upgrade your Perl to a newer version. Fails to load Calc on Perl prior 5.6.0 Since eval(' use ...') can not be used in conjunction with ':constant', BigInt will fall back to eval { require ... } when loading the math lib on Perls prior to 5.6.0. This simple replaces '::' with '/' and thus might fail on filesystems using a different seperator.
Some things might not work as you expect them. Below is documented what is known to be troublesome: bstr(), bsstr() and 'cmp' Both "bstr()" and "bsstr()" as well as automated stringify via overload now drop the leading '+'. The old code would return '+3', the new returns '3'. This is to be consistent with Perl and to make "cmp" (especially with overloading) to work as you expect. It also solves problems with "Test.pm", because it's "ok()" uses 'eq' internally. Mark Biggar said, when asked about to drop the '+' alto- gether, or make only "cmp" work: perl v5.8.8 2005-02-05 29 Math::BigInt(3p)Perl Programmers Reference Guide Math::BigInt(3p) I agree (with the first alternative), don't add the '+' on positive numbers. It's not as important anymore with the new internal form for numbers. It made doing things like abs and neg easier, but those have to be done differently now anyway. So, the following examples will now work all as expected: use Test; BEGIN { plan tests => 1 } use Math::BigInt; my $x = new Math::BigInt 3*3; my $y = new Math::BigInt 3*3; ok ($x,3*3); scien- tific notation aka 1e+2 instead of 100. Be advised that overloaded 'eq' always uses bstr() for comparisation, but Perl will represent some numbers as 100 and others as 1e+308. If in doubt, convert both arguments to Math::BigInt before. See also the section about "Infinity and Not a Number" for problems in comparing NaNs. int() "int()" will return (at least for Perl v5.7.1 and up) perl v5.8.8 2005-02-05 30 Math::BigInt(3p)Perl Programmers Reference Guide Math::BigInt(3p) another BigInt, not a Perl scalar: $x = Math::BigInt->new(123); $y = int($x); # BigInt 123 $x = Math::BigFloat->new(123.45); $y = int($x); # BigInt 123 In all Perl versions you can use "as_number()" or "as_int" for the same effect: $x = Math::BigFloat->new(123.45); $y = $x->as_number(); # BigInt 123 $y = $x->as_int(); # ditto This also works for other subclasses, like Math::String. It is yet unlcear whether overloaded int() should return a scalar or a BigInt. If you want a real Perl scalar, use "numify()": $y = $x->numify(); # 123 as scalar This is seldom necessary, though, because this is done automatically, like when you access an array: $z = $array[$x]; # does work automatically length The following will probably not do what you expect: $c = Math::BigInt->new(123); print $c->length(),"\n"; # prints 30 It prints both the number of digits in the number and in the fraction part since print calls "length()" in list con- text. Use something like: print scalar $c->length(),"\n"; # prints 3 bdiv The following will probably not do what you expect: print $c->bdiv(10000),"\n"; It prints both quotient and remainder since print calls "bdiv()" in list context. Also, "bdiv()" will modify $c, so be carefull. You probably want to use print $c / 10000,"\n"; print scalar $c->bdiv(10000),"\n"; # or if you want to modify $c perl v5.8.8 2005-02-05 31 Math::BigInt(3p)Perl Programmers Reference Guide Math::BigInt(3p) instead. The quotient is always the greatest integer less than or equal to the real-valued quotient of the two operands, and the remainder (when it is nonzero) always has the same sign as the second operand; so, for example, 1 / 4 => ( 0, 1) 1 / -4 => (-1,-3) -3 / 4 => (-1, 1) -3 / -4 => ( 0,-3) -11 / 2 => (-5,1) 11 /-2 => (-5,-1) As a consequence, the behavior of the operator % agrees with the behavior of Perl's built-in % operator (as docu- mented in the perlop manpage), and the equation $x == ($x / $y) * $y + ($x % $y) holds true for any $x and $y, which justifies calling the two return values of bdiv() the quotient and remainder. The only exception to this rule are when $y == 0 and $x is negative, then the remainder will also be negative. See below under "infinity handling" for the reasoning behing this. Perl's 'use integer;' changes the behaviour of % and / for scalars, but will not change BigInt's way to do things. This is because under 'use integer' Perl will do what the underlying C thinks is right and this is different for each system. If you need BigInt's behaving exactly like Perl's 'use integer', bug the author to implement it ;) infinity handling Here are some examples that explain the reasons why certain results occur while handling infinity: The following table shows the result of the division and the remainder, so that the equation above holds true. Some "ordinary" cases are strewn in to show more clearly the reasoning: perl v5.8.8 2005-02-05 32 Math::BigInt(3p)Perl Programmers Reference Guide Math::BigInt(3p) Modifying and = Beware of: : perl v5.8.8 2005-02-05 33 Math::BigInt(3p)Perl Programmers Reference Guide Math::BigInt(3p) $y = $x->copy(); You can also chain the calls like this, this will make first a copy and then multiply it by 2: $y = $x->copy()->bmul(2); See also the documentation for overload.pm regarding "=". bpow "bpow()" (and the rounding functions) now modifies the first argument and returns. Overloading -$x The following: $x = -$x; is slower than $x->bneg(); since overload calls "sub($x,0,1);" instead of "neg($x)". The first variant needs to preserve $x since it does not know that it later will get overwritten. This makes a copy of $x and takes O(N), but $x->bneg() is O(1). Mixing different object types In Perl you will get a floating point value if you do one of the following: $float = 5.0 + 2; $float = 2 + 5.0; $float = 5 / 2; With overloaded math, only the first two variants will result in a BigFloat: use Math::BigInt; use Math::BigFloat; perl v5.8.8 2005-02-05 34 Math::BigInt(3p)Perl Programmers Reference Guide Math::BigInt(3p) $mbf = Math::BigFloat->new(5); $mbi2 = Math::BigInteger->new(5); $mbi = Math::BigInteger->new(2); # what actually gets called: $float = $mbf + $mbi; # $mbf->badd() $float = $mbf / $mbi; # $mbf->bdiv() $integer = $mbi + $mbf; # $mbi->badd() $integer = $mbi2 / $mbi; # $mbi2->bdiv() $integer = $mbi2 / $mbf; # $mbi2->bdiv() This is because math with overloaded operators follows the first (dominating) operand, and the operation of that is called and returns thus the result. So, Math::BigInt::bdiv() will always return a Math::BigInt, regardless whether the result should be a Math::BigFloat or the second operant is one. To get a Math::BigFloat you either need to call the opera- tion manually, make sure the operands are already of the proper type or casted to that type via Math::BigFloat->new(): $float = Math::BigFloat->new($mbi2) / $mbi; # = 2.5 Beware of simple "casting" the entire expression, this would only convert the already computed result: $float = Math::BigFloat->new($mbi2 / $mbi); # = 2.0 thus wrong!; will both result in the proper type due to the way the overloaded math works. This section also applies to other overloaded math pack- ages, like Math::String. One solution to you problem might be autoupgrading|upgrading. See the pragmas bignum, bigint and perl v5.8.8 2005-02-05 35 Math::BigInt(3p)Perl Programmers Reference Guide Math::BigInt(3p) bigrat for an easy way to do this. bsqrt() "bsqrt()" works only good if the result is a big integer, e.g. the square root of 144 is 12, but from 12 the square root is 3, regardless of rounding mode. The reason is that the result is always brsft() For negative numbers in base see also brsft.
This program is free software; you may redistribute it and/or modify it under the same terms as Perl itself.
Math::BigFloat, Math::BigRat and Math::Big as well as Math::BigInt::BitVect, Math::BigInt::Pari and Math::BigInt::GMP. The pragmas bignum, bigint and bigrat also might be of interest because they solve the autoupgrading/downgrading issue, at least partly. The package at <> contains more documentation including a full version his- tory, testcases, empty subclass files and benchmarks.
Original code by Mark Biggar, overloaded interface by Ilya Zakharevich. Completely rewritten by Tels in late 2000, 2001 - 2004 and still at it in 2005. Many people contributed in one or more ways to the final beast, see the file CREDITS for an (uncomplete) list. If you miss your name, please drop me a mail. Thank you! perl v5.8.8 2005-02-05 36.