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 *{"bigrat::$name"} = sub
36 Math::BigInt->$name($_[0]);
37 Math::BigFloat->$name($_[0]);
38 return Math::BigRat->$name($_[0]);
40 return Math::BigInt->$name();
46 # delayed load of Carp and avoid recursion
48 Carp::croak ("Can't call bigrat\-\>$name, not a valid method");
57 # $Math::BigInt::upgrade = $_[0];
58 # $Math::BigFloat::upgrade = $_[0];
60 $Math::BigInt::upgrade;
65 # this takes a binary/hexadecimal/octal constant string and returns it
66 # as string suitable for new. Basically it converts octal to decimal, and
67 # passes every thing else unmodified back.
70 return Math::BigInt->new($string) if $string =~ /^0[bx]/;
72 # so it must be an octal constant
73 Math::BigInt->from_oct($string);
80 # see also bignum->import() for additional comments
83 my $lib = ''; my $upgrade = 'Math::BigFloat';
85 my @import = ( ':constant' ); # drive it w/ constant
86 my @a = @_; my $l = scalar @_; my $j = 0;
88 my ($ver,$trace); # version? trace?
89 for ( my $i = 0; $i < $l ; $i++,$j++ )
91 if ($_[$i] eq 'upgrade')
93 # this causes upgrading
94 $upgrade = $_[$i+1]; # or undef to disable
95 my $s = 2; $s = 1 if @a-$j < 2; # avoid "can not modify non-existant..."
96 splice @a, $j, $s; $j -= $s;
98 elsif ($_[$i] =~ /^(l|lib)$/)
100 # this causes a different low lib to take care...
101 $lib = $_[$i+1] || '';
102 my $s = 2; $s = 1 if @a-$j < 2; # avoid "can not modify non-existant..."
103 splice @a, $j, $s; $j -= $s; $i++;
105 elsif ($_[$i] =~ /^(a|accuracy)$/)
108 my $s = 2; $s = 1 if @a-$j < 2; # avoid "can not modify non-existant..."
109 splice @a, $j, $s; $j -= $s; $i++;
111 elsif ($_[$i] =~ /^(p|precision)$/)
114 my $s = 2; $s = 1 if @a-$j < 2; # avoid "can not modify non-existant..."
115 splice @a, $j, $s; $j -= $s; $i++;
117 elsif ($_[$i] =~ /^(v|version)$/)
120 splice @a, $j, 1; $j --;
122 elsif ($_[$i] =~ /^(t|trace)$/)
125 splice @a, $j, 1; $j --;
129 die ("unknown option $_[$i]");
133 $_lite = 0; # using M::BI::L ?
136 require Math::BigInt::Trace; $class = 'Math::BigInt::Trace';
137 $upgrade = 'Math::BigFloat::Trace';
141 # see if we can find Math::BigInt::Lite
142 if (!defined $a && !defined $p) # rounding won't work to well
144 eval 'require Math::BigInt::Lite;';
147 @import = ( ); # :constant in Lite, not MBI
148 Math::BigInt::Lite->import( ':constant' );
149 $_lite= 1; # signal okay
152 require Math::BigInt if $_lite == 0; # not already loaded?
153 $class = 'Math::BigInt'; # regardless of MBIL or not
155 push @import, 'lib' => $lib if $lib ne '';
156 # Math::BigInt::Trace or plain Math::BigInt
157 $class->import(@import, upgrade => $upgrade);
159 require Math::BigFloat;
160 Math::BigFloat->import( upgrade => 'Math::BigRat', ':constant' );
161 require Math::BigRat;
163 bigrat->accuracy($a) if defined $a;
164 bigrat->precision($p) if defined $p;
167 print "bigrat\t\t\t v$VERSION\n";
168 print "Math::BigInt::Lite\t v$Math::BigInt::Lite::VERSION\n" if $_lite;
169 print "Math::BigInt\t\t v$Math::BigInt::VERSION";
170 my $config = Math::BigInt->config();
171 print " lib => $config->{lib} v$config->{lib_version}\n";
172 print "Math::BigFloat\t\t v$Math::BigFloat::VERSION\n";
173 print "Math::BigRat\t\t v$Math::BigRat::VERSION\n";
177 # Take care of octal/hexadecimal constants
178 overload::constant binary => sub { _binary_constant(shift) };
180 $self->export_to_level(1,$self,@a); # export inf and NaN
183 sub inf () { Math::BigInt->binf(); }
184 sub NaN () { Math::BigInt->bnan(); }
192 bigrat - Transparent BigNumber/BigRational support for Perl
198 $x = 2 + 4.5,"\n"; # BigFloat 6.5
199 print 1/3 + 1/4,"\n"; # produces 7/12
203 All operators (including basic math operations) are overloaded. Integer and
204 floating-point constants are created as proper BigInts or BigFloats,
207 Other than L<bignum>, this module upgrades to Math::BigRat, meaning that
208 instead of 2.5 you will get 2+1/2 as output.
212 C<bigrat> is just a thin wrapper around various modules of the Math::BigInt
213 family. Think of it as the head of the family, who runs the shop, and orders
214 the others to do the work.
216 The following modules are currently used by bignum:
218 Math::BigInt::Lite (for speed, and only if it is loadable)
225 Math with the numbers is done (by default) by a module called
226 Math::BigInt::Calc. This is equivalent to saying:
228 use bigrat lib => 'Calc';
230 You can change this by using:
232 use bigrat lib => 'BitVect';
234 The following would first try to find Math::BigInt::Foo, then
235 Math::BigInt::Bar, and when this also fails, revert to Math::BigInt::Calc:
237 use bigrat lib => 'Foo,Math::BigInt::Bar';
239 Please see respective module documentation for further details.
243 The sign is either '+', '-', 'NaN', '+inf' or '-inf'.
245 A sign of 'NaN' is used to represent the result when input arguments are not
246 numbers or as a result of 0/0. '+inf' and '-inf' represent plus respectively
247 minus infinity. You will get '+inf' when dividing a positive number by 0, and
248 '-inf' when dividing any negative number by 0.
252 Since all numbers are not objects, you can use all functions that are part of
253 the BigInt or BigFloat API. It is wise to use only the bxxx() notation, and not
254 the fxxx() notation, though. This makes you independed on the fact that the
255 underlying object might morph into a different class than BigFloat.
261 A shortcut to return Math::BigInt->binf(). Useful because Perl does not always
262 handle bareword C<inf> properly.
266 A shortcut to return Math::BigInt->bnan(). Useful because Perl does not always
267 handle bareword C<NaN> properly.
271 Return the class that numbers are upgraded to, is in fact returning
272 C<$Math::BigInt::upgrade>.
278 Math with the numbers is done (by default) by a module called
282 But a warning is in order. When using the following to make a copy of a number,
283 only a shallow copy will be made.
288 If you want to make a real copy, use the following:
292 Using the copy or the original with overloaded math is okay, e.g. the
296 print $x + 1, " ", $y,"\n"; # prints 10 9
298 but calling any method that modifies the number directly will result in
299 B<both> the original and the copy being destroyed:
302 print $x->badd(1), " ", $y,"\n"; # prints 10 10
305 print $x->binc(1), " ", $y,"\n"; # prints 10 10
308 print $x->bmul(2), " ", $y,"\n"; # prints 18 18
310 Using methods that do not modify, but testthe contents works:
313 $z = 9 if $x->is_zero(); # works fine
315 See the documentation about the copy constructor and C<=> in overload, as
316 well as the documentation in BigInt for further details.
320 bignum recognizes some options that can be passed while loading it via use.
321 The options can (currently) be either a single letter form, or the long form.
322 The following options exist:
328 This sets the accuracy for all math operations. The argument must be greater
329 than or equal to zero. See Math::BigInt's bround() function for details.
331 perl -Mbigrat=a,50 -le 'print sqrt(20)'
333 Note that setting precision and accurary at the same time is not possible.
337 This sets the precision for all math operations. The argument can be any
338 integer. Negative values mean a fixed number of digits after the dot, while
339 a positive value rounds to this digit left from the dot. 0 or 1 mean round to
340 integer. See Math::BigInt's bfround() function for details.
342 perl -Mbigrat=p,-50 -le 'print sqrt(20)'
344 Note that setting precision and accurary at the same time is not possible.
348 This enables a trace mode and is primarily for debugging bignum or
349 Math::BigInt/Math::BigFloat.
353 Load a different math lib, see L<MATH LIBRARY>.
355 perl -Mbigrat=l,GMP -e 'print 2 ** 512'
357 Currently there is no way to specify more than one library on the command
358 line. This means the following does not work:
360 perl -Mbignum=l,GMP,Pari -e 'print 2 ** 512'
362 This will be hopefully fixed soon ;)
366 This prints out the name and version of all modules used and then exits.
374 perl -Mbigrat -le 'print sqrt(33)'
375 perl -Mbigrat -le 'print 2*255'
376 perl -Mbigrat -le 'print 4.5+2*255'
377 perl -Mbigrat -le 'print 3/7 + 5/7 + 8/3'
378 perl -Mbigrat -le 'print 12->is_odd()';
379 perl -Mbignum=l,GMP -le 'print 7 ** 7777'
383 This program is free software; you may redistribute it and/or modify it under
384 the same terms as Perl itself.
388 Especially L<bignum>.
390 L<Math::BigFloat>, L<Math::BigInt>, L<Math::BigRat> and L<Math::Big> as well
391 as L<Math::BigInt::BitVect>, L<Math::BigInt::Pari> and L<Math::BigInt::GMP>.
395 (C) by Tels L<http://bloodgate.com/> in early 2002 - 2007.