8 @EXPORT = qw( inf NaN );
13 ##############################################################################
15 # These are all alike, and thus faked by AUTOLOAD
17 my @faked = qw/round_mode accuracy precision div_scale/;
18 use vars qw/$VERSION $AUTOLOAD $_lite/; # _lite for testsuite
24 $name =~ s/.*:://; # split package
26 foreach my $n (@faked)
30 *{"bigint::$name"} = sub
36 return Math::BigInt->$name($_[0]);
38 return Math::BigInt->$name();
44 # delayed load of Carp and avoid recursion
46 Carp::croak ("Can't call bigint\-\>$name, not a valid method");
55 # $Math::BigInt::upgrade = $_[0];
57 $Math::BigInt::upgrade;
62 # this takes a binary/hexadecimal/octal constant string and returns it
63 # as string suitable for new. Basically it converts octal to decimal, and
64 # passes every thing else unmodified back.
67 return Math::BigInt->new($string) if $string =~ /^0[bx]/;
69 # so it must be an octal constant
70 Math::BigInt->from_oct($string);
75 # this takes a floating point constant string and returns it truncated to
76 # integer. For instance, '4.5' => '4', '1.234e2' => '123' etc
79 # some simple cases first
80 return $float if ($float =~ /^[+-]?[0-9]+$/); # '+123','-1','0' etc
82 if ($float =~ /^[+-]?[0-9]+\.?[eE]\+?[0-9]+$/); # 123e2, 123.e+2
83 return '0' if ($float =~ /^[+-]?[0]*\.[0-9]+$/); # .2, 0.2, -.1
84 if ($float =~ /^[+-]?[0-9]+\.[0-9]*$/) # 1., 1.23, -1.2 etc
89 my ($mis,$miv,$mfv,$es,$ev) = Math::BigInt::_split($float);
90 return $float if !defined $mis; # doesn't look like a number to me
92 my $sign = $$mis; $sign = '' if $sign eq '+';
95 # ignore fraction part entirely
96 if ($ec >= length($$miv)) # 123.23E-4
100 return $sign . substr ($$miv,0,length($$miv)-$ec); # 1234.45E-2 = 12
103 if ($ec >= length($$mfv))
105 $ec -= length($$mfv);
106 return $sign.$$miv.$$mfv if $ec == 0; # 123.45E+2 => 12345
107 return $sign.$$miv.$$mfv.'E'.$ec; # 123.45e+3 => 12345e1
109 $mfv = substr($$mfv,0,$ec);
110 $sign.$$miv.$mfv; # 123.45e+1 => 1234
120 my @import = ( ':constant' ); # drive it w/ constant
121 my @a = @_; my $l = scalar @_; my $j = 0;
122 my ($ver,$trace); # version? trace?
123 my ($a,$p); # accuracy, precision
124 for ( my $i = 0; $i < $l ; $i++,$j++ )
126 if ($_[$i] =~ /^(l|lib)$/)
128 # this causes a different low lib to take care...
129 $lib = $_[$i+1] || '';
130 my $s = 2; $s = 1 if @a-$j < 2; # avoid "can not modify non-existant..."
131 splice @a, $j, $s; $j -= $s; $i++;
133 elsif ($_[$i] =~ /^(a|accuracy)$/)
136 my $s = 2; $s = 1 if @a-$j < 2; # avoid "can not modify non-existant..."
137 splice @a, $j, $s; $j -= $s; $i++;
139 elsif ($_[$i] =~ /^(p|precision)$/)
142 my $s = 2; $s = 1 if @a-$j < 2; # avoid "can not modify non-existant..."
143 splice @a, $j, $s; $j -= $s; $i++;
145 elsif ($_[$i] =~ /^(v|version)$/)
148 splice @a, $j, 1; $j --;
150 elsif ($_[$i] =~ /^(t|trace)$/)
153 splice @a, $j, 1; $j --;
155 else { die "unknown option $_[$i]"; }
158 $_lite = 0; # using M::BI::L ?
161 require Math::BigInt::Trace; $class = 'Math::BigInt::Trace';
165 # see if we can find Math::BigInt::Lite
166 if (!defined $a && !defined $p) # rounding won't work to well
168 eval 'require Math::BigInt::Lite;';
171 @import = ( ); # :constant in Lite, not MBI
172 Math::BigInt::Lite->import( ':constant' );
173 $_lite= 1; # signal okay
176 require Math::BigInt if $_lite == 0; # not already loaded?
177 $class = 'Math::BigInt'; # regardless of MBIL or not
179 push @import, 'try' => $lib if $lib ne '';
180 # Math::BigInt::Trace or plain Math::BigInt
181 $class->import(@import);
183 bigint->accuracy($a) if defined $a;
184 bigint->precision($p) if defined $p;
187 print "bigint\t\t\t v$VERSION\n";
188 print "Math::BigInt::Lite\t v$Math::BigInt::Lite::VERSION\n" if $_lite;
189 print "Math::BigInt\t\t v$Math::BigInt::VERSION";
190 my $config = Math::BigInt->config();
191 print " lib => $config->{lib} v$config->{lib_version}\n";
194 # we take care of floating point constants, since BigFloat isn't available
195 # and BigInt doesn't like them:
196 overload::constant float => sub { Math::BigInt->new( _float_constant(shift) ); };
197 # Take care of octal/hexadecimal constants
198 overload::constant binary => sub { _binary_constant(shift) };
200 $self->export_to_level(1,$self,@a); # export inf and NaN
203 sub inf () { Math::BigInt->binf(); }
204 sub NaN () { Math::BigInt->bnan(); }
212 bigint - Transparent BigInteger support for Perl
218 $x = 2 + 4.5,"\n"; # BigInt 6
219 print 2 ** 512,"\n"; # really is what you think it is
220 print inf + 42,"\n"; # inf
221 print NaN * 7,"\n"; # NaN
225 All operators (including basic math operations) are overloaded. Integer
226 constants are created as proper BigInts.
228 Floating point constants are truncated to integer. All results are also
233 bigint recognizes some options that can be passed while loading it via use.
234 The options can (currently) be either a single letter form, or the long form.
235 The following options exist:
241 This sets the accuracy for all math operations. The argument must be greater
242 than or equal to zero. See Math::BigInt's bround() function for details.
244 perl -Mbigint=a,2 -le 'print 12345+1'
246 Note that setting precision and accurary at the same time is not possible.
250 This sets the precision for all math operations. The argument can be any
251 integer. Negative values mean a fixed number of digits after the dot, and
252 are <B>ignored</B> since all operations happen in integer space.
253 A positive value rounds to this digit left from the dot. 0 or 1 mean round to
254 integer and are ignore like negative values.
256 See Math::BigInt's bfround() function for details.
258 perl -Mbignum=p,5 -le 'print 123456789+123'
260 Note that setting precision and accurary at the same time is not possible.
264 This enables a trace mode and is primarily for debugging bigint or
269 Load a different math lib, see L<MATH LIBRARY>.
271 perl -Mbigint=l,GMP -e 'print 2 ** 512'
273 Currently there is no way to specify more than one library on the command
274 line. This means the following does not work:
276 perl -Mbignum=l,GMP,Pari -e 'print 2 ** 512'
278 This will be hopefully fixed soon ;)
282 This prints out the name and version of all modules used and then exits.
290 Math with the numbers is done (by default) by a module called
291 Math::BigInt::Calc. This is equivalent to saying:
293 use bigint lib => 'Calc';
295 You can change this by using:
297 use bigint lib => 'BitVect';
299 The following would first try to find Math::BigInt::Foo, then
300 Math::BigInt::Bar, and when this also fails, revert to Math::BigInt::Calc:
302 use bigint lib => 'Foo,Math::BigInt::Bar';
304 Please see respective module documentation for further details.
306 =head2 Internal Format
308 The numbers are stored as objects, and their internals might change at anytime,
309 especially between math operations. The objects also might belong to different
310 classes, like Math::BigInt, or Math::BigInt::Lite. Mixing them together, even
311 with normal scalars is not extraordinary, but normal and expected.
313 You should not depend on the internal format, all accesses must go through
314 accessor methods. E.g. looking at $x->{sign} is not a good idea since there
315 is no guaranty that the object in question has such a hash key, nor is a hash
320 The sign is either '+', '-', 'NaN', '+inf' or '-inf'.
321 You can access it with the sign() method.
323 A sign of 'NaN' is used to represent the result when input arguments are not
324 numbers or as a result of 0/0. '+inf' and '-inf' represent plus respectively
325 minus infinity. You will get '+inf' when dividing a positive number by 0, and
326 '-inf' when dividing any negative number by 0.
330 Since all numbers are now objects, you can use all functions that are part of
331 the BigInt API. You can only use the bxxx() notation, and not the fxxx()
338 A shortcut to return Math::BigInt->binf(). Useful because Perl does not always
339 handle bareword C<inf> properly.
343 A shortcut to return Math::BigInt->bnan(). Useful because Perl does not always
344 handle bareword C<NaN> properly.
348 Return the class that numbers are upgraded to, is in fact returning
349 C<$Math::BigInt::upgrade>.
355 Math with the numbers is done (by default) by a module called
359 But a warning is in order. When using the following to make a copy of a number,
360 only a shallow copy will be made.
365 Using the copy or the original with overloaded math is okay, e.g. the
369 print $x + 1, " ", $y,"\n"; # prints 10 9
371 but calling any method that modifies the number directly will result in
372 B<both> the original and the copy being destroyed:
375 print $x->badd(1), " ", $y,"\n"; # prints 10 10
378 print $x->binc(1), " ", $y,"\n"; # prints 10 10
381 print $x->bmul(2), " ", $y,"\n"; # prints 18 18
383 Using methods that do not modify, but testthe contents works:
386 $z = 9 if $x->is_zero(); # works fine
388 See the documentation about the copy constructor and C<=> in overload, as
389 well as the documentation in BigInt for further details.
393 C<bigint> is just a thin wrapper around various modules of the Math::BigInt
394 family. Think of it as the head of the family, who runs the shop, and orders
395 the others to do the work.
397 The following modules are currently used by bigint:
399 Math::BigInt::Lite (for speed, and only if it is loadable)
404 Some cool command line examples to impress the Python crowd ;) You might want
405 to compare them to the results under -Mbignum or -Mbigrat:
407 perl -Mbigint -le 'print sqrt(33)'
408 perl -Mbigint -le 'print 2*255'
409 perl -Mbigint -le 'print 4.5+2*255'
410 perl -Mbigint -le 'print 3/7 + 5/7 + 8/3'
411 perl -Mbigint -le 'print 123->is_odd()'
412 perl -Mbigint -le 'print log(2)'
413 perl -Mbigint -le 'print 2 ** 0.5'
414 perl -Mbigint=a,65 -le 'print 2 ** 0.2'
415 perl -Mbignum=a,65,l,GMP -le 'print 7 ** 7777'
419 This program is free software; you may redistribute it and/or modify it under
420 the same terms as Perl itself.
424 Especially L<bigrat> as in C<perl -Mbigrat -le 'print 1/3+1/4'> and
425 L<bignum> as in C<perl -Mbignum -le 'print sqrt(2)'>.
427 L<Math::BigInt>, L<Math::BigRat> and L<Math::Big> as well
428 as L<Math::BigInt::BitVect>, L<Math::BigInt::Pari> and L<Math::BigInt::GMP>.
432 (C) by Tels L<http://bloodgate.com/> in early 2002 - 2007.