This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Upgrade bignum from version 0.40 to 0.41
[perl5.git] / cpan / bignum / lib / bigint.pm
1 package bigint;
2 use 5.006;
3
4 $VERSION = '0.41';
5 use Exporter;
6 @ISA            = qw( Exporter );
7 @EXPORT_OK      = qw( PI e bpi bexp hex oct );
8 @EXPORT         = qw( inf NaN );
9
10 use strict;
11 use overload;
12
13 ##############################################################################
14
15 # These are all alike, and thus faked by AUTOLOAD
16
17 my @faked = qw/round_mode accuracy precision div_scale/;
18 use vars qw/$VERSION $AUTOLOAD $_lite/;         # _lite for testsuite
19
20 sub AUTOLOAD {
21     my $name = $AUTOLOAD;
22
23     $name =~ s/.*:://;          # split package
24     no strict 'refs';
25     foreach my $n (@faked) {
26         if ($n eq $name) {
27             *{"bigint::$name"} =
28               sub {
29                   my $self = shift;
30                   no strict 'refs';
31                   if (defined $_[0]) {
32                       return Math::BigInt->$name($_[0]);
33                   }
34                   return Math::BigInt->$name();
35               };
36             return &$name;
37         }
38     }
39
40     # delayed load of Carp and avoid recursion
41     require Carp;
42     Carp::croak ("Can't call bigint\-\>$name, not a valid method");
43 }
44
45 sub upgrade {
46     $Math::BigInt::upgrade;
47 }
48
49 sub _binary_constant {
50     # this takes a binary/hexadecimal/octal constant string and returns it
51     # as string suitable for new. Basically it converts octal to decimal, and
52     # passes every thing else unmodified back.
53     my $string = shift;
54
55     return Math::BigInt->new($string) if $string =~ /^0[bx]/;
56
57     # so it must be an octal constant
58     Math::BigInt->from_oct($string);
59 }
60
61 sub _float_constant {
62     # this takes a floating point constant string and returns it truncated to
63     # integer. For instance, '4.5' => '4', '1.234e2' => '123' etc
64     my $float = shift;
65
66     # some simple cases first
67     return $float if ($float =~ /^[+-]?[0-9]+$/);       # '+123','-1','0' etc
68     return $float
69       if ($float =~ /^[+-]?[0-9]+\.?[eE]\+?[0-9]+$/);   # 123e2, 123.e+2
70     return '0' if ($float =~ /^[+-]?[0]*\.[0-9]+$/);    # .2, 0.2, -.1
71     if ($float =~ /^[+-]?[0-9]+\.[0-9]*$/) {            # 1., 1.23, -1.2 etc
72         $float =~ s/\..*//;
73         return $float;
74     }
75     my ($mis, $miv, $mfv, $es, $ev) = Math::BigInt::_split($float);
76     return $float if !defined $mis;       # doesn't look like a number to me
77     my $ec = int($$ev);
78     my $sign = $$mis;
79     $sign = '' if $sign eq '+';
80     if ($$es eq '-') {
81         # ignore fraction part entirely
82         if ($ec >= length($$miv)) {                     # 123.23E-4
83             return '0';
84         }
85         return $sign . substr($$miv, 0, length($$miv) - $ec); # 1234.45E-2 = 12
86     }
87     # xE+y
88     if ($ec >= length($$mfv)) {
89         $ec -= length($$mfv);
90         return $sign.$$miv.$$mfv if $ec == 0;           # 123.45E+2 => 12345
91         return $sign.$$miv.$$mfv.'E'.$ec;               # 123.45e+3 => 12345e1
92     }
93     $mfv = substr($$mfv, 0, $ec);
94     $sign.$$miv.$mfv;                                   # 123.45e+1 => 1234
95 }
96
97 sub unimport {
98     $^H{bigint} = undef;                                # no longer in effect
99     overload::remove_constant('binary', '', 'float', '', 'integer');
100 }
101
102 sub in_effect {
103     my $level = shift || 0;
104     my $hinthash = (caller($level))[10];
105     $hinthash->{bigint};
106 }
107
108 #############################################################################
109 # the following two routines are for "use bigint qw/hex oct/;":
110
111 use constant LEXICAL => $] > 5.009004;
112
113 # Internal function with the same semantics as CORE::hex(). This function is
114 # not used directly, but rather by other front-end functions.
115
116 sub _hex_core {
117     my $str = shift;
118
119     # Strip off, clean, and parse as much as we can from the beginning.
120
121     my $x;
122     if ($str =~ s/ ^ (0?[xX])? ( [0-9a-fA-F]* ( _ [0-9a-fA-F]+ )* ) //x) {
123         my $chrs = $2;
124         $chrs =~ tr/_//d;
125         $chrs = '0' unless CORE::length $chrs;
126         $x = Math::BigInt -> from_hex($chrs);
127     } else {
128         $x = Math::BigInt -> bzero();
129     }
130
131     # Warn about trailing garbage.
132
133     if (CORE::length($str)) {
134         require Carp;
135         Carp::carp(sprintf("Illegal hexadecimal digit '%s' ignored",
136                            substr($str, 0, 1)));
137     }
138
139     return $x;
140 }
141
142 # Internal function with the same semantics as CORE::oct(). This function is
143 # not used directly, but rather by other front-end functions.
144
145 sub _oct_core {
146     my $str = shift;
147
148     $str =~ s/^\s*//;
149
150     # Hexadecimal input.
151
152     return _hex_core($str) if $str =~ /^0?[xX]/;
153
154     my $x;
155
156     # Binary input.
157
158     if ($str =~ /^0?[bB]/) {
159
160         # Strip off, clean, and parse as much as we can from the beginning.
161
162         if ($str =~ s/ ^ (0?[bB])? ( [01]* ( _ [01]+ )* ) //x) {
163             my $chrs = $2;
164             $chrs =~ tr/_//d;
165             $chrs = '0' unless CORE::length $chrs;
166             $x = Math::BigInt -> from_bin($chrs);
167         }
168
169         # Warn about trailing garbage.
170
171         if (CORE::length($str)) {
172             require Carp;
173             Carp::carp(sprintf("Illegal binary digit '%s' ignored",
174                                substr($str, 0, 1)));
175         }
176
177         return $x;
178     }
179
180     # Octal input. Strip off, clean, and parse as much as we can from the
181     # beginning.
182
183     if ($str =~ s/ ^ ( [0-7]* ( _ [0-7]+ )* ) //x) {
184         my $chrs = $1;
185         $chrs =~ tr/_//d;
186         $chrs = '0' unless CORE::length $chrs;
187         $x = Math::BigInt -> from_oct($chrs);
188     }
189
190     # Warn about trailing garbage. CORE::oct() only warns about 8 and 9.
191
192     if (CORE::length($str)) {
193         my $chr = substr($str, 0, 1);
194         if ($chr eq '8' || $chr eq '9') {
195             require Carp;
196             Carp::carp(sprintf("Illegal octal digit '%s' ignored", $chr));
197         }
198     }
199
200     return $x;
201 }
202
203 {
204     my $proto = LEXICAL ? '_' : ';$';
205     eval '
206 sub hex(' . $proto . ') {' . <<'.';
207     my $str = @_ ? $_[0] : $_;
208     _hex_core($str);
209 }
210 .
211
212     eval '
213 sub oct(' . $proto . ') {' . <<'.';
214     my $str = @_ ? $_[0] : $_;
215     _oct_core($str);
216 }
217 .
218 }
219
220 #############################################################################
221 # the following two routines are for Perl 5.9.4 or later and are lexical
222
223 my ($prev_oct, $prev_hex, $overridden);
224
225 if (LEXICAL) { eval <<'.' }
226 sub _hex(_) {
227     my $hh = (caller 0)[10];
228     return $prev_hex ? &$prev_hex($_[0]) : CORE::hex($_[0])
229       unless $$hh{bigint}||$$hh{bignum}||$$hh{bigrat};
230     _hex_core($_[0]);
231 }
232
233 sub _oct(_) {
234     my $hh = (caller 0)[10];
235     return $prev_oct ? &$prev_oct($_[0]) : CORE::oct($_[0])
236       unless $$hh{bigint}||$$hh{bignum}||$$hh{bigrat};
237     _oct_core($_[0]);
238 }
239 .
240
241 sub _override {
242     return if $overridden;
243     $prev_oct = *CORE::GLOBAL::oct{CODE};
244     $prev_hex = *CORE::GLOBAL::hex{CODE};
245     no warnings 'redefine';
246     *CORE::GLOBAL::oct = \&_oct;
247     *CORE::GLOBAL::hex = \&_hex;
248     $overridden++;
249 }
250
251 sub import {
252     my $self = shift;
253
254     $^H{bigint} = 1;                            # we are in effect
255
256     # for newer Perls always override hex() and oct() with a lexical version:
257     if (LEXICAL) {
258         _override();
259     }
260     # some defaults
261     my $lib = '';
262     my $lib_kind = 'try';
263
264     my @import = (':constant');                 # drive it w/ constant
265     my @a = @_;
266     my $l = scalar @_;
267     my $j = 0;
268     my ($ver, $trace);                          # version? trace?
269     my ($a, $p);                                # accuracy, precision
270     for (my $i = 0; $i < $l; $i++, $j++) {
271         if ($_[$i] =~ /^(l|lib|try|only)$/) {
272             # this causes a different low lib to take care...
273             $lib_kind = $1;
274             $lib_kind = 'lib' if $lib_kind eq 'l';
275             $lib = $_[$i + 1] || '';
276             my $s = 2;
277             $s = 1 if @a - $j < 2;  # avoid "can not modify non-existent..."
278             splice @a, $j, $s;
279             $j -= $s;
280             $i++;
281         } elsif ($_[$i] =~ /^(a|accuracy)$/) {
282             $a = $_[$i + 1];
283             my $s = 2;
284             $s = 1 if @a - $j < 2;  # avoid "can not modify non-existent..."
285             splice @a, $j, $s;
286             $j -= $s;
287             $i++;
288         } elsif ($_[$i] =~ /^(p|precision)$/) {
289             $p = $_[$i + 1];
290             my $s = 2;
291             $s = 1 if @a - $j < 2;  # avoid "can not modify non-existent..."
292             splice @a, $j, $s;
293             $j -= $s;
294             $i++;
295         } elsif ($_[$i] =~ /^(v|version)$/) {
296             $ver = 1;
297             splice @a, $j, 1;
298             $j--;
299         } elsif ($_[$i] =~ /^(t|trace)$/) {
300             $trace = 1;
301             splice @a, $j, 1;
302             $j--;
303         } elsif ($_[$i] !~ /^(PI|e|bpi|bexp|hex|oct)\z/) {
304             die ("unknown option $_[$i]");
305         }
306     }
307     my $class;
308     $_lite = 0;                                 # using M::BI::L ?
309     if ($trace) {
310         require Math::BigInt::Trace;
311         $class = 'Math::BigInt::Trace';
312     } else {
313         # see if we can find Math::BigInt::Lite
314         if (!defined $a && !defined $p) {       # rounding won't work to well
315             if (eval { require Math::BigInt::Lite; 1 }) {
316                 @import = ();                   # :constant in Lite, not MBI
317                 Math::BigInt::Lite->import(':constant');
318                 $_lite = 1;                     # signal okay
319             }
320         }
321         require Math::BigInt if $_lite == 0;    # not already loaded?
322         $class = 'Math::BigInt';                # regardless of MBIL or not
323     }
324     push @import, $lib_kind => $lib if $lib ne '';
325     # Math::BigInt::Trace or plain Math::BigInt
326     $class->import(@import);
327
328     bigint->accuracy($a)  if defined $a;
329     bigint->precision($p) if defined $p;
330     if ($ver) {
331         print "bigint\t\t\t v$VERSION\n";
332         print "Math::BigInt::Lite\t v$Math::BigInt::Lite::VERSION\n" if $_lite;
333         print "Math::BigInt\t\t v$Math::BigInt::VERSION";
334         my $config = Math::BigInt->config();
335         print " lib => $config->{lib} v$config->{lib_version}\n";
336         exit;
337     }
338     # we take care of floating point constants, since BigFloat isn't available
339     # and BigInt doesn't like them:
340     overload::constant float =>
341         sub {
342             Math::BigInt->new(_float_constant(shift));
343         };
344     # Take care of octal/hexadecimal constants
345     overload::constant binary =>
346         sub {
347             _binary_constant(shift);
348         };
349
350     # if another big* was already loaded:
351     my ($package) = caller();
352
353     no strict 'refs';
354     if (!defined *{"${package}::inf"}) {
355         $self->export_to_level(1, $self, @a);   # export inf and NaN, e and PI
356     }
357 }
358
359 sub inf () { Math::BigInt::binf(); }
360 sub NaN () { Math::BigInt::bnan(); }
361
362 sub PI () { Math::BigInt->new(3); }
363 sub e () { Math::BigInt->new(2); }
364 sub bpi ($) { Math::BigInt->new(3); }
365 sub bexp ($$) {
366     my $x = Math::BigInt->new($_[0]);
367     $x->bexp($_[1]);
368 }
369
370 1;
371
372 __END__
373
374 =head1 NAME
375
376 bigint - Transparent BigInteger support for Perl
377
378 =head1 SYNOPSIS
379
380   use bigint;
381
382   $x = 2 + 4.5,"\n";                    # BigInt 6
383   print 2 ** 512,"\n";                  # really is what you think it is
384   print inf + 42,"\n";                  # inf
385   print NaN * 7,"\n";                   # NaN
386   print hex("0x1234567890123490"),"\n"; # Perl v5.10.0 or later
387
388   {
389     no bigint;
390     print 2 ** 256,"\n";                # a normal Perl scalar now
391   }
392
393   # Import into current package:
394   use bigint qw/hex oct/;
395   print hex("0x1234567890123490"),"\n";
396   print oct("01234567890123490"),"\n";
397
398 =head1 DESCRIPTION
399
400 All operators (including basic math operations) except the range operator C<..>
401 are overloaded. Integer constants are created as proper BigInts.
402
403 Floating point constants are truncated to integer. All parts and results of
404 expressions are also truncated.
405
406 Unlike L<integer>, this pragma creates integer constants that are only
407 limited in their size by the available memory and CPU time.
408
409 =head2 use integer vs. use bigint
410
411 There is one small difference between C<use integer> and C<use bigint>: the
412 former will not affect assignments to variables and the return value of
413 some functions. C<bigint> truncates these results to integer too:
414
415         # perl -Minteger -wle 'print 3.2'
416         3.2
417         # perl -Minteger -wle 'print 3.2 + 0'
418         3
419         # perl -Mbigint -wle 'print 3.2'
420         3
421         # perl -Mbigint -wle 'print 3.2 + 0'
422         3
423
424         # perl -Mbigint -wle 'print exp(1) + 0'
425         2
426         # perl -Mbigint -wle 'print exp(1)'
427         2
428         # perl -Minteger -wle 'print exp(1)'
429         2.71828182845905
430         # perl -Minteger -wle 'print exp(1) + 0'
431         2
432
433 In practice this makes seldom a difference as B<parts and results> of
434 expressions will be truncated anyway, but this can, for instance, affect the
435 return value of subroutines:
436
437     sub three_integer { use integer; return 3.2; }
438     sub three_bigint { use bigint; return 3.2; }
439
440     print three_integer(), " ", three_bigint(),"\n";    # prints "3.2 3"
441
442 =head2 Options
443
444 bigint recognizes some options that can be passed while loading it via use.
445 The options can (currently) be either a single letter form, or the long form.
446 The following options exist:
447
448 =over 2
449
450 =item a or accuracy
451
452 This sets the accuracy for all math operations. The argument must be greater
453 than or equal to zero. See Math::BigInt's bround() function for details.
454
455         perl -Mbigint=a,2 -le 'print 12345+1'
456
457 Note that setting precision and accuracy at the same time is not possible.
458
459 =item p or precision
460
461 This sets the precision for all math operations. The argument can be any
462 integer. Negative values mean a fixed number of digits after the dot, and
463 are <B>ignored</B> since all operations happen in integer space.
464 A positive value rounds to this digit left from the dot. 0 or 1 mean round to
465 integer and are ignore like negative values.
466
467 See Math::BigInt's bfround() function for details.
468
469         perl -Mbignum=p,5 -le 'print 123456789+123'
470
471 Note that setting precision and accuracy at the same time is not possible.
472
473 =item t or trace
474
475 This enables a trace mode and is primarily for debugging bigint or
476 Math::BigInt.
477
478 =item hex
479
480 Override the built-in hex() method with a version that can handle big
481 integers. This overrides it by exporting it to the current package. Under
482 Perl v5.10.0 and higher, this is not so necessary, as hex() is lexically
483 overridden in the current scope whenever the bigint pragma is active.
484
485 =item oct
486
487 Override the built-in oct() method with a version that can handle big
488 integers. This overrides it by exporting it to the current package. Under
489 Perl v5.10.0 and higher, this is not so necessary, as oct() is lexically
490 overridden in the current scope whenever the bigint pragma is active.
491
492 =item l, lib, try or only
493
494 Load a different math lib, see L<Math Library>.
495
496         perl -Mbigint=lib,GMP -e 'print 2 ** 512'
497         perl -Mbigint=try,GMP -e 'print 2 ** 512'
498         perl -Mbigint=only,GMP -e 'print 2 ** 512'
499
500 Currently there is no way to specify more than one library on the command
501 line. This means the following does not work:
502
503         perl -Mbignum=l,GMP,Pari -e 'print 2 ** 512'
504
505 This will be hopefully fixed soon ;)
506
507 =item v or version
508
509 This prints out the name and version of all modules used and then exits.
510
511         perl -Mbigint=v
512
513 =back
514
515 =head2 Math Library
516
517 Math with the numbers is done (by default) by a module called
518 Math::BigInt::Calc. This is equivalent to saying:
519
520         use bigint lib => 'Calc';
521
522 You can change this by using:
523
524         use bignum lib => 'GMP';
525
526 The following would first try to find Math::BigInt::Foo, then
527 Math::BigInt::Bar, and when this also fails, revert to Math::BigInt::Calc:
528
529         use bigint lib => 'Foo,Math::BigInt::Bar';
530
531 Using C<lib> warns if none of the specified libraries can be found and
532 L<Math::BigInt> did fall back to one of the default libraries.
533 To suppress this warning, use C<try> instead:
534
535         use bignum try => 'GMP';
536
537 If you want the code to die instead of falling back, use C<only> instead:
538
539         use bignum only => 'GMP';
540
541 Please see respective module documentation for further details.
542
543 =head2 Internal Format
544
545 The numbers are stored as objects, and their internals might change at anytime,
546 especially between math operations. The objects also might belong to different
547 classes, like Math::BigInt, or Math::BigInt::Lite. Mixing them together, even
548 with normal scalars is not extraordinary, but normal and expected.
549
550 You should not depend on the internal format, all accesses must go through
551 accessor methods. E.g. looking at $x->{sign} is not a good idea since there
552 is no guaranty that the object in question has such a hash key, nor is a hash
553 underneath at all.
554
555 =head2 Sign
556
557 The sign is either '+', '-', 'NaN', '+inf' or '-inf'.
558 You can access it with the sign() method.
559
560 A sign of 'NaN' is used to represent the result when input arguments are not
561 numbers or as a result of 0/0. '+inf' and '-inf' represent plus respectively
562 minus infinity. You will get '+inf' when dividing a positive number by 0, and
563 '-inf' when dividing any negative number by 0.
564
565 =head2 Method calls
566
567 Since all numbers are now objects, you can use all functions that are part of
568 the BigInt API. You can only use the bxxx() notation, and not the fxxx()
569 notation, though.
570
571 But a warning is in order. When using the following to make a copy of a number,
572 only a shallow copy will be made.
573
574         $x = 9; $y = $x;
575         $x = $y = 7;
576
577 Using the copy or the original with overloaded math is okay, e.g. the
578 following work:
579
580         $x = 9; $y = $x;
581         print $x + 1, " ", $y,"\n";     # prints 10 9
582
583 but calling any method that modifies the number directly will result in
584 B<both> the original and the copy being destroyed:
585
586         $x = 9; $y = $x;
587         print $x->badd(1), " ", $y,"\n";        # prints 10 10
588
589         $x = 9; $y = $x;
590         print $x->binc(1), " ", $y,"\n";        # prints 10 10
591
592         $x = 9; $y = $x;
593         print $x->bmul(2), " ", $y,"\n";        # prints 18 18
594
595 Using methods that do not modify, but test that the contents works:
596
597         $x = 9; $y = $x;
598         $z = 9 if $x->is_zero();                # works fine
599
600 See the documentation about the copy constructor and C<=> in overload, as
601 well as the documentation in BigInt for further details.
602
603 =head2 Methods
604
605 =over 2
606
607 =item inf()
608
609 A shortcut to return Math::BigInt->binf(). Useful because Perl does not always
610 handle bareword C<inf> properly.
611
612 =item NaN()
613
614 A shortcut to return Math::BigInt->bnan(). Useful because Perl does not always
615 handle bareword C<NaN> properly.
616
617 =item e
618
619         # perl -Mbigint=e -wle 'print e'
620
621 Returns Euler's number C<e>, aka exp(1). Note that under bigint, this is
622 truncated to an integer, and hence simple '2'.
623
624 =item PI
625
626         # perl -Mbigint=PI -wle 'print PI'
627
628 Returns PI. Note that under bigint, this is truncated to an integer, and hence
629 simple '3'.
630
631 =item bexp()
632
633         bexp($power,$accuracy);
634
635 Returns Euler's number C<e> raised to the appropriate power, to
636 the wanted accuracy.
637
638 Note that under bigint, the result is truncated to an integer.
639
640 Example:
641
642         # perl -Mbigint=bexp -wle 'print bexp(1,80)'
643
644 =item bpi()
645
646         bpi($accuracy);
647
648 Returns PI to the wanted accuracy. Note that under bigint, this is truncated
649 to an integer, and hence simple '3'.
650
651 Example:
652
653         # perl -Mbigint=bpi -wle 'print bpi(80)'
654
655 =item upgrade()
656
657 Return the class that numbers are upgraded to, is in fact returning
658 C<$Math::BigInt::upgrade>.
659
660 =item in_effect()
661
662         use bigint;
663
664         print "in effect\n" if bigint::in_effect;       # true
665         {
666           no bigint;
667           print "in effect\n" if bigint::in_effect;     # false
668         }
669
670 Returns true or false if C<bigint> is in effect in the current scope.
671
672 This method only works on Perl v5.9.4 or later.
673
674 =back
675
676 =head1 CAVEATS
677
678 =over 2
679
680 =item Operator vs literal overloading
681
682 C<bigint> works by overloading handling of integer and floating point
683 literals, converting them to L<Math::BigInt> objects.
684
685 This means that arithmetic involving only string values or string
686 literals will be performed using Perl's built-in operators.
687
688 For example:
689
690     use bignum;
691     my $x = "900000000000000009";
692     my $y = "900000000000000007";
693     print $x - $y;
694
695 will output C<0> on default 32-bit builds, since C<bigint> never sees
696 the string literals.  To ensure the expression is all treated as
697 C<Math::BigInt> objects, use a literal number in the expression:
698
699     print +(0+$x) - $y;
700
701 =item ranges
702
703 Perl does not allow overloading of ranges, so you can neither safely use
704 ranges with bigint endpoints, nor is the iterator variable a bigint.
705
706         use 5.010;
707         for my $i (12..13) {
708           for my $j (20..21) {
709             say $i ** $j;  # produces a floating-point number,
710                            # not a big integer
711           }
712         }
713
714 =item in_effect()
715
716 This method only works on Perl v5.9.4 or later.
717
718 =item hex()/oct()
719
720 C<bigint> overrides these routines with versions that can also handle
721 big integer values. Under Perl prior to version v5.9.4, however, this
722 will not happen unless you specifically ask for it with the two
723 import tags "hex" and "oct" - and then it will be global and cannot be
724 disabled inside a scope with "no bigint":
725
726         use bigint qw/hex oct/;
727
728         print hex("0x1234567890123456");
729         {
730                 no bigint;
731                 print hex("0x1234567890123456");
732         }
733
734 The second call to hex() will warn about a non-portable constant.
735
736 Compare this to:
737
738         use bigint;
739
740         # will warn only under Perl older than v5.9.4
741         print hex("0x1234567890123456");
742
743 =back
744
745 =head1 MODULES USED
746
747 C<bigint> is just a thin wrapper around various modules of the Math::BigInt
748 family. Think of it as the head of the family, who runs the shop, and orders
749 the others to do the work.
750
751 The following modules are currently used by bigint:
752
753         Math::BigInt::Lite      (for speed, and only if it is loadable)
754         Math::BigInt
755
756 =head1 EXAMPLES
757
758 Some cool command line examples to impress the Python crowd ;) You might want
759 to compare them to the results under -Mbignum or -Mbigrat:
760
761         perl -Mbigint -le 'print sqrt(33)'
762         perl -Mbigint -le 'print 2*255'
763         perl -Mbigint -le 'print 4.5+2*255'
764         perl -Mbigint -le 'print 3/7 + 5/7 + 8/3'
765         perl -Mbigint -le 'print 123->is_odd()'
766         perl -Mbigint -le 'print log(2)'
767         perl -Mbigint -le 'print 2 ** 0.5'
768         perl -Mbigint=a,65 -le 'print 2 ** 0.2'
769         perl -Mbignum=a,65,l,GMP -le 'print 7 ** 7777'
770
771 =head1 LICENSE
772
773 This program is free software; you may redistribute it and/or modify it under
774 the same terms as Perl itself.
775
776 =head1 SEE ALSO
777
778 Especially L<bigrat> as in C<perl -Mbigrat -le 'print 1/3+1/4'> and
779 L<bignum> as in C<perl -Mbignum -le 'print sqrt(2)'>.
780
781 L<Math::BigInt>, L<Math::BigRat> and L<Math::Big> as well
782 as L<Math::BigInt::Pari> and  L<Math::BigInt::GMP>.
783
784 =head1 AUTHORS
785
786 (C) by Tels L<http://bloodgate.com/> in early 2002 - 2007.
787
788 =cut