argra****@users*****
argra****@users*****
2011年 9月 9日 (金) 04:45:54 JST
Index: docs/modules/bignum-0.23/bigint.pod
diff -u /dev/null docs/modules/bignum-0.23/bigint.pod:1.1
--- /dev/null Fri Sep 9 04:45:54 2011
+++ docs/modules/bignum-0.23/bigint.pod Fri Sep 9 04:45:54 2011
@@ -0,0 +1,827 @@
+
+=encoding euc-jp
+
+=head1 NAME
+
+=begin original
+
+bigint - Transparent BigInteger support for Perl
+
+=end original
+
+bigint - Perl 用の透過的な BigInteger 対応
+
+=head1 SYNOPSIS
+
+ use bigint;
+
+ $x = 2 + 4.5,"\n"; # BigInt 6
+ print 2 ** 512,"\n"; # really is what you think it is
+ print inf + 42,"\n"; # inf
+ print NaN * 7,"\n"; # NaN
+ print hex("0x1234567890123490"),"\n"; # Perl v5.9.4 or later
+
+ {
+ no bigint;
+ print 2 ** 256,"\n"; # a normal Perl scalar now
+ }
+
+ # Note that this will be global:
+ use bigint qw/hex oct/;
+ print hex("0x1234567890123490"),"\n";
+ print oct("01234567890123490"),"\n";
+
+=head1 DESCRIPTION
+
+=begin original
+
+All operators (including basic math operations) are overloaded. Integer
+constants are created as proper BigInts.
+
+=end original
+
+(基本算術演算子を含む)全ての演算子がオーバーロードされます。
+整数定数は適切な BigInt として作成されます。
+
+=begin original
+
+Floating point constants are truncated to integer. All parts and results of
+expressions are also truncated.
+
+=end original
+
+浮動小数点数定数は整数に切り詰められます。
+式の全ての部分と結果も切り詰められます。
+
+=begin original
+
+Unlike L<integer>, this pragma creates integer constants that are only
+limited in their size by the available memory and CPU time.
+
+=end original
+
+L<integer> と違って、このプラグマは利用可能なメモリと CPU 時間によってのみ
+制限されるサイズの整数定数を作成します。
+
+=head2 use integer vs. use bigint
+
+=begin original
+
+There is one small difference between C<use integer> and C<use bigint>: the
+former will not affect assignments to variables and the return value of
+some functions. C<bigint> truncates these results to integer too:
+
+=end original
+
+There is one small difference between C<use integer> and C<use bigint>: the
+former will not affect assignments to variables and the return value of
+some functions. C<bigint> truncates these results to integer too:
+(TBT)
+
+ # perl -Minteger -wle 'print 3.2'
+ 3.2
+ # perl -Minteger -wle 'print 3.2 + 0'
+ 3
+ # perl -Mbigint -wle 'print 3.2'
+ 3
+ # perl -Mbigint -wle 'print 3.2 + 0'
+ 3
+
+ # perl -Mbigint -wle 'print exp(1) + 0'
+ 2
+ # perl -Mbigint -wle 'print exp(1)'
+ 2
+ # perl -Minteger -wle 'print exp(1)'
+ 2.71828182845905
+ # perl -Minteger -wle 'print exp(1) + 0'
+ 2
+
+=begin original
+
+In practice this makes seldom a difference as B<parts and results> of
+expressions will be truncated anyway, but this can, for instance, affect the
+return value of subroutines:
+
+=end original
+
+In practice this makes seldom a difference as B<parts and results> of
+expressions will be truncated anyway, but this can, for instance, affect the
+return value of subroutines:
+(TBT)
+
+ sub three_integer { use integer; return 3.2; }
+ sub three_bigint { use bigint; return 3.2; }
+
+ print three_integer(), " ", three_bigint(),"\n"; # prints "3.2 3"
+
+=head2 Options
+
+=begin original
+
+bigint recognizes some options that can be passed while loading it via use.
+The options can (currently) be either a single letter form, or the long form.
+The following options exist:
+
+=end original
+
+bigint recognizes some options that can be passed while loading it via use.
+The options can (currently) be either a single letter form, or the long form.
+The following options exist:
+(TBT)
+
+=over 2
+
+=item a or accuracy
+
+=begin original
+
+This sets the accuracy for all math operations. The argument must be greater
+than or equal to zero. See Math::BigInt's bround() function for details.
+
+=end original
+
+This sets the accuracy for all math operations. The argument must be greater
+than or equal to zero. See Math::BigInt's bround() function for details.
+(TBT)
+
+ perl -Mbigint=a,2 -le 'print 12345+1'
+
+=begin original
+
+Note that setting precision and accurary at the same time is not possible.
+
+=end original
+
+Note that setting precision and accurary at the same time is not possible.
+(TBT)
+
+=item p or precision
+
+=begin original
+
+This sets the precision for all math operations. The argument can be any
+integer. Negative values mean a fixed number of digits after the dot, and
+are <B>ignored</B> since all operations happen in integer space.
+A positive value rounds to this digit left from the dot. 0 or 1 mean round to
+integer and are ignore like negative values.
+
+=end original
+
+This sets the precision for all math operations. The argument can be any
+integer. Negative values mean a fixed number of digits after the dot, and
+are <B>ignored</B> since all operations happen in integer space.
+A positive value rounds to this digit left from the dot. 0 or 1 mean round to
+integer and are ignore like negative values.
+(TBT)
+
+=begin original
+
+See Math::BigInt's bfround() function for details.
+
+=end original
+
+See Math::BigInt's bfround() function for details.
+(TBT)
+
+ perl -Mbignum=p,5 -le 'print 123456789+123'
+
+=begin original
+
+Note that setting precision and accurary at the same time is not possible.
+
+=end original
+
+Note that setting precision and accurary at the same time is not possible.
+(TBT)
+
+=item t or trace
+
+=begin original
+
+This enables a trace mode and is primarily for debugging bigint or
+Math::BigInt.
+
+=end original
+
+This enables a trace mode and is primarily for debugging bigint or
+Math::BigInt.
+(TBT)
+
+=item hex
+
+=begin original
+
+Override the built-in hex() method with a version that can handle big
+integers. Note that under Perl v5.9.4 or ealier, this will be global
+and cannot be disabled with "no bigint;".
+
+=end original
+
+Override the built-in hex() method with a version that can handle big
+integers. Note that under Perl v5.9.4 or ealier, this will be global
+and cannot be disabled with "no bigint;".
+(TBT)
+
+=item oct
+
+=begin original
+
+Override the built-in oct() method with a version that can handle big
+integers. Note that under Perl v5.9.4 or ealier, this will be global
+and cannot be disabled with "no bigint;".
+
+=end original
+
+Override the built-in oct() method with a version that can handle big
+integers. Note that under Perl v5.9.4 or ealier, this will be global
+and cannot be disabled with "no bigint;".
+(TBT)
+
+=item l, lib, try or only
+
+=begin original
+
+Load a different math lib, see L<Math Library>.
+
+=end original
+
+Load a different math lib, see L<Math Library>.
+(TBT)
+
+ perl -Mbigint=lib,GMP -e 'print 2 ** 512'
+ perl -Mbigint=try,GMP -e 'print 2 ** 512'
+ perl -Mbigint=only,GMP -e 'print 2 ** 512'
+
+=begin original
+
+Currently there is no way to specify more than one library on the command
+line. This means the following does not work:
+
+=end original
+
+Currently there is no way to specify more than one library on the command
+line. This means the following does not work:
+(TBT)
+
+ perl -Mbignum=l,GMP,Pari -e 'print 2 ** 512'
+
+=begin original
+
+This will be hopefully fixed soon ;)
+
+=end original
+
+This will be hopefully fixed soon ;)
+(TBT)
+
+=item v or version
+
+=begin original
+
+This prints out the name and version of all modules used and then exits.
+
+=end original
+
+This prints out the name and version of all modules used and then exits.
+(TBT)
+
+ perl -Mbigint=v
+
+=back
+
+=head2 Math Library
+
+=begin original
+
+Math with the numbers is done (by default) by a module called
+Math::BigInt::Calc. This is equivalent to saying:
+
+=end original
+
+Math with the numbers is done (by default) by a module called
+Math::BigInt::Calc. This is equivalent to saying:
+(TBT)
+
+ use bigint lib => 'Calc';
+
+=begin original
+
+You can change this by using:
+
+=end original
+
+You can change this by using:
+(TBT)
+
+ use bignum lib => 'GMP';
+
+=begin original
+
+The following would first try to find Math::BigInt::Foo, then
+Math::BigInt::Bar, and when this also fails, revert to Math::BigInt::Calc:
+
+=end original
+
+The following would first try to find Math::BigInt::Foo, then
+Math::BigInt::Bar, and when this also fails, revert to Math::BigInt::Calc:
+(TBT)
+
+ use bigint lib => 'Foo,Math::BigInt::Bar';
+
+=begin original
+
+Using C<lib> warns if none of the specified libraries can be found and
+L<Math::BigInt> did fall back to one of the default libraries.
+To supress this warning, use C<try> instead:
+
+=end original
+
+Using C<lib> warns if none of the specified libraries can be found and
+L<Math::BigInt> did fall back to one of the default libraries.
+To supress this warning, use C<try> instead:
+(TBT)
+
+ use bignum try => 'GMP';
+
+=begin original
+
+If you want the code to die instead of falling back, use C<only> instead:
+
+=end original
+
+If you want the code to die instead of falling back, use C<only> instead:
+(TBT)
+
+ use bignum only => 'GMP';
+
+=begin original
+
+Please see respective module documentation for further details.
+
+=end original
+
+Please see respective module documentation for further details.
+(TBT)
+
+=head2 Internal Format
+
+=begin original
+
+The numbers are stored as objects, and their internals might change at anytime,
+especially between math operations. The objects also might belong to different
+classes, like Math::BigInt, or Math::BigInt::Lite. Mixing them together, even
+with normal scalars is not extraordinary, but normal and expected.
+
+=end original
+
+The numbers are stored as objects, and their internals might change at anytime,
+especially between math operations. The objects also might belong to different
+classes, like Math::BigInt, or Math::BigInt::Lite. Mixing them together, even
+with normal scalars is not extraordinary, but normal and expected.
+(TBT)
+
+=begin original
+
+You should not depend on the internal format, all accesses must go through
+accessor methods. E.g. looking at $x->{sign} is not a good idea since there
+is no guaranty that the object in question has such a hash key, nor is a hash
+underneath at all.
+
+=end original
+
+You should not depend on the internal format, all accesses must go through
+accessor methods. E.g. looking at $x->{sign} is not a good idea since there
+is no guaranty that the object in question has such a hash key, nor is a hash
+underneath at all.
+(TBT)
+
+=head2 Sign
+
+=begin original
+
+The sign is either '+', '-', 'NaN', '+inf' or '-inf'.
+You can access it with the sign() method.
+
+=end original
+
+The sign is either '+', '-', 'NaN', '+inf' or '-inf'.
+You can access it with the sign() method.
+(TBT)
+
+=begin original
+
+A sign of 'NaN' is used to represent the result when input arguments are not
+numbers or as a result of 0/0. '+inf' and '-inf' represent plus respectively
+minus infinity. You will get '+inf' when dividing a positive number by 0, and
+'-inf' when dividing any negative number by 0.
+
+=end original
+
+A sign of 'NaN' is used to represent the result when input arguments are not
+numbers or as a result of 0/0. '+inf' and '-inf' represent plus respectively
+minus infinity. You will get '+inf' when dividing a positive number by 0, and
+'-inf' when dividing any negative number by 0.
+(TBT)
+
+=head2 Methods
+
+=begin original
+
+Since all numbers are now objects, you can use all functions that are part of
+the BigInt API. You can only use the bxxx() notation, and not the fxxx()
+notation, though.
+
+=end original
+
+Since all numbers are now objects, you can use all functions that are part of
+the BigInt API. You can only use the bxxx() notation, and not the fxxx()
+notation, though.
+(TBT)
+
+=over 2
+
+=item inf()
+
+=begin original
+
+A shortcut to return Math::BigInt->binf(). Useful because Perl does not always
+handle bareword C<inf> properly.
+
+=end original
+
+A shortcut to return Math::BigInt->binf(). Useful because Perl does not always
+handle bareword C<inf> properly.
+(TBT)
+
+=item NaN()
+
+=begin original
+
+A shortcut to return Math::BigInt->bnan(). Useful because Perl does not always
+handle bareword C<NaN> properly.
+
+=end original
+
+A shortcut to return Math::BigInt->bnan(). Useful because Perl does not always
+handle bareword C<NaN> properly.
+(TBT)
+
+=item e
+
+ # perl -Mbigint=e -wle 'print e'
+
+=begin original
+
+Returns Euler's number C<e>, aka exp(1). Note that under bigint, this is
+truncated to an integer, and hence simple '2'.
+
+=end original
+
+Returns Euler's number C<e>, aka exp(1). Note that under bigint, this is
+truncated to an integer, and hence simple '2'.
+(TBT)
+
+=item PI
+
+ # perl -Mbigint=PI -wle 'print PI'
+
+=begin original
+
+Returns PI. Note that under bigint, this is truncated to an integer, and hence
+simple '3'.
+
+=end original
+
+Returns PI. Note that under bigint, this is truncated to an integer, and hence
+simple '3'.
+(TBT)
+
+=item bexp()
+
+ bexp($power,$accuracy);
+
+=begin original
+
+Returns Euler's number C<e> raised to the appropriate power, to
+the wanted accuracy.
+
+=end original
+
+Returns Euler's number C<e> raised to the appropriate power, to
+the wanted accuracy.
+(TBT)
+
+=begin original
+
+Note that under bigint, the result is truncated to an integer.
+
+=end original
+
+Note that under bigint, the result is truncated to an integer.
+(TBT)
+
+=begin original
+
+Example:
+
+=end original
+
+Example:
+(TBT)
+
+ # perl -Mbigint=bexp -wle 'print bexp(1,80)'
+
+=item bpi()
+
+ bpi($accuracy);
+
+=begin original
+
+Returns PI to the wanted accuracy. Note that under bigint, this is truncated
+to an integer, and hence simple '3'.
+
+=end original
+
+Returns PI to the wanted accuracy. Note that under bigint, this is truncated
+to an integer, and hence simple '3'.
+(TBT)
+
+=begin original
+
+Example:
+
+=end original
+
+Example:
+(TBT)
+
+ # perl -Mbigint=bpi -wle 'print bpi(80)'
+
+=item upgrade()
+
+=begin original
+
+Return the class that numbers are upgraded to, is in fact returning
+C<$Math::BigInt::upgrade>.
+
+=end original
+
+Return the class that numbers are upgraded to, is in fact returning
+C<$Math::BigInt::upgrade>.
+(TBT)
+
+=item in_effect()
+
+ use bigint;
+
+ print "in effect\n" if bigint::in_effect; # true
+ {
+ no bigint;
+ print "in effect\n" if bigint::in_effect; # false
+ }
+
+=begin original
+
+Returns true or false if C<bigint> is in effect in the current scope.
+
+=end original
+
+Returns true or false if C<bigint> is in effect in the current scope.
+(TBT)
+
+=begin original
+
+This method only works on Perl v5.9.4 or later.
+
+=end original
+
+This method only works on Perl v5.9.4 or later.
+(TBT)
+
+=back
+
+=head2 MATH LIBRARY
+
+=begin original
+
+Math with the numbers is done (by default) by a module called
+
+=end original
+
+Math with the numbers is done (by default) by a module called
+(TBT)
+
+=head2 Caveat
+
+=begin original
+
+But a warning is in order. When using the following to make a copy of a number,
+only a shallow copy will be made.
+
+=end original
+
+But a warning is in order. When using the following to make a copy of a number,
+only a shallow copy will be made.
+(TBT)
+
+ $x = 9; $y = $x;
+ $x = $y = 7;
+
+=begin original
+
+Using the copy or the original with overloaded math is okay, e.g. the
+following work:
+
+=end original
+
+Using the copy or the original with overloaded math is okay, e.g. the
+following work:
+(TBT)
+
+ $x = 9; $y = $x;
+ print $x + 1, " ", $y,"\n"; # prints 10 9
+
+=begin original
+
+but calling any method that modifies the number directly will result in
+B<both> the original and the copy being destroyed:
+
+ $x = 9; $y = $x;
+ print $x->badd(1), " ", $y,"\n"; # prints 10 10
+
+ $x = 9; $y = $x;
+ print $x->binc(1), " ", $y,"\n"; # prints 10 10
+
+ $x = 9; $y = $x;
+ print $x->bmul(2), " ", $y,"\n"; # prints 18 18
+
+Using methods that do not modify, but testthe contents works:
+
+ $x = 9; $y = $x;
+ $z = 9 if $x->is_zero(); # works fine
+
+=begin original
+
+See the documentation about the copy constructor and C<=> in overload, as
+well as the documentation in BigInt for further details.
+
+=end original
+
+See the documentation about the copy constructor and C<=> in overload, as
+well as the documentation in BigInt for further details.
+(TBT)
+
+=head1 CAVAETS
+
+=over 2
+
+=item in_effect()
+
+=begin original
+
+This method only works on Perl v5.9.4 or later.
+
+=end original
+
+This method only works on Perl v5.9.4 or later.
+(TBT)
+
+=item hex()/oct()
+
+=begin original
+
+C<bigint> overrides these routines with versions that can also handle
+big integer values. Under Perl prior to version v5.9.4, however, this
+will not happen unless you specifically ask for it with the two
+import tags "hex" and "oct" - and then it will be global and cannot be
+disabled inside a scope with "no bigint":
+
+=end original
+
+C<bigint> overrides these routines with versions that can also handle
+big integer values. Under Perl prior to version v5.9.4, however, this
+will not happen unless you specifically ask for it with the two
+import tags "hex" and "oct" - and then it will be global and cannot be
+disabled inside a scope with "no bigint":
+(TBT)
+
+ use bigint qw/hex oct/;
+
+ print hex("0x1234567890123456");
+ {
+ no bigint;
+ print hex("0x1234567890123456");
+ }
+
+=begin original
+
+The second call to hex() will warn about a non-portable constant.
+
+=end original
+
+The second call to hex() will warn about a non-portable constant.
+(TBT)
+
+=begin original
+
+Compare this to:
+
+=end original
+
+Compare this to:
+(TBT)
+
+ use bigint;
+
+ # will warn only under Perl older than v5.9.4
+ print hex("0x1234567890123456");
+
+=back
+
+=head1 MODULES USED
+
+=begin original
+
+C<bigint> is just a thin wrapper around various modules of the Math::BigInt
+family. Think of it as the head of the family, who runs the shop, and orders
+the others to do the work.
+
+=end original
+
+C<bigint> is just a thin wrapper around various modules of the Math::BigInt
+family. Think of it as the head of the family, who runs the shop, and orders
+the others to do the work.
+(TBT)
+
+=begin original
+
+The following modules are currently used by bigint:
+
+=end original
+
+The following modules are currently used by bigint:
+(TBT)
+
+ Math::BigInt::Lite (for speed, and only if it is loadable)
+ Math::BigInt
+
+=head1 EXAMPLES
+
+=begin original
+
+Some cool command line examples to impress the Python crowd ;) You might want
+to compare them to the results under -Mbignum or -Mbigrat:
+
+ perl -Mbigint -le 'print sqrt(33)'
+ perl -Mbigint -le 'print 2*255'
+ perl -Mbigint -le 'print 4.5+2*255'
+ perl -Mbigint -le 'print 3/7 + 5/7 + 8/3'
+ perl -Mbigint -le 'print 123->is_odd()'
+ perl -Mbigint -le 'print log(2)'
+ perl -Mbigint -le 'print 2 ** 0.5'
+ perl -Mbigint=a,65 -le 'print 2 ** 0.2'
+ perl -Mbignum=a,65,l,GMP -le 'print 7 ** 7777'
+
+=head1 LICENSE
+
+=begin original
+
+This program is free software; you may redistribute it and/or modify it under
+the same terms as Perl itself.
+
+=end original
+
+This program is free software; you may redistribute it and/or modify it under
+the same terms as Perl itself.
+(TBT)
+
+=head1 SEE ALSO
+
+=begin original
+
+Especially L<bigrat> as in C<perl -Mbigrat -le 'print 1/3+1/4'> and
+L<bignum> as in C<perl -Mbignum -le 'print sqrt(2)'>.
+
+=end original
+
+Especially L<bigrat> as in C<perl -Mbigrat -le 'print 1/3+1/4'> and
+L<bignum> as in C<perl -Mbignum -le 'print sqrt(2)'>.
+(TBT)
+
+=begin original
+
+L<Math::BigInt>, L<Math::BigRat> and L<Math::Big> as well
+as L<Math::BigInt::BitVect>, L<Math::BigInt::Pari> and L<Math::BigInt::GMP>.
+
+=end original
+
+L<Math::BigInt>, L<Math::BigRat> and L<Math::Big> as well
+as L<Math::BigInt::BitVect>, L<Math::BigInt::Pari> and L<Math::BigInt::GMP>.
+(TBT)
+
+=head1 AUTHORS
+
+(C) by Tels L<http://bloodgate.com/> in early 2002 - 2007.
+
+=cut
+
Index: docs/modules/bignum-0.23/bignum.pod
diff -u /dev/null docs/modules/bignum-0.23/bignum.pod:1.1
--- /dev/null Fri Sep 9 04:45:54 2011
+++ docs/modules/bignum-0.23/bignum.pod Fri Sep 9 04:45:54 2011
@@ -0,0 +1,986 @@
+
+=encoding euc-jp
+
+=head1 NAME
+
+=begin original
+
+bignum - Transparent BigNumber support for Perl
+
+=end original
+
+bignum - Perl 用の透過的な BigNumber 対応
+
+=head1 SYNOPSIS
+
+ use bignum;
+
+ $x = 2 + 4.5,"\n"; # BigFloat 6.5
+ print 2 ** 512 * 0.1,"\n"; # really is what you think it is
+ print inf * inf,"\n"; # prints inf
+ print NaN * 3,"\n"; # prints NaN
+
+ {
+ no bignum;
+ print 2 ** 256,"\n"; # a normal Perl scalar now
+ }
+
+ # for older Perls, note that this will be global:
+ use bignum qw/hex oct/;
+ print hex("0x1234567890123490"),"\n";
+ print oct("01234567890123490"),"\n";
+
+=head1 DESCRIPTION
+
+=begin original
+
+All operators (including basic math operations) are overloaded. Integer and
+floating-point constants are created as proper BigInts or BigFloats,
+respectively.
+
+=end original
+
+(基本算術演算子を含む)全ての演算子がオーバーロードされます。
+整数定数と浮動小数点数定数はそれぞれ適切な BigInt または BigFloat として
+作成されます。
+
+=begin original
+
+If you do
+
+=end original
+
+このように
+
+ use bignum;
+
+=begin original
+
+at the top of your script, Math::BigFloat and Math::BigInt will be loaded
+and any constant number will be converted to an object (Math::BigFloat for
+floats like 3.1415 and Math::BigInt for integers like 1234).
+
+=end original
+
+スクリプトの先頭に書くと、Math::BigFloat と Math::BigInt が読み込まれ、
+全ての定数はオブジェクトに変換されます (3.1415 のようは浮動小数点数は
+Math::BigFloat に、1234 のような整数は Math::BigInt に)。
+
+=begin original
+
+So, the following line:
+
+=end original
+
+それで、以下の行は:
+
+ $x = 1234;
+
+=begin original
+
+creates actually a Math::BigInt and stores a reference to in $x.
+This happens transparently and behind your back, so to speak.
+
+=end original
+
+実際には Math::BigInt を作成して、リファレンスを $x に保管します。
+これは透過的に、いわば背後で行われます。
+
+=begin original
+
+You can see this with the following:
+
+=end original
+
+以下のようにすればこれを見ることができます:
+
+ perl -Mbignum -le 'print ref(1234)'
+
+=begin original
+
+Don't worry if it says Math::BigInt::Lite, bignum and friends will use Lite
+if it is installed since it is faster for some operations. It will be
+automatically upgraded to BigInt whenever necessary:
+
+=end original
+
+Don't worry if it says Math::BigInt::Lite, bignum and friends will use Lite
+if it is installed since it is faster for some operations. It will be
+automatically upgraded to BigInt whenever necessary:
+(TBT)
+
+ perl -Mbignum -le 'print ref(2**255)'
+
+=begin original
+
+This also means it is a bad idea to check for some specific package, since
+the actual contents of $x might be something unexpected. Due to the
+transparent way of bignum C<ref()> should not be necessary, anyway.
+
+=end original
+
+This also means it is a bad idea to check for some specific package, since
+the actual contents of $x might be something unexpected. Due to the
+transparent way of bignum C<ref()> should not be necessary, anyway.
+(TBT)
+
+=begin original
+
+Since Math::BigInt and BigFloat also overload the normal math operations,
+the following line will still work:
+
+=end original
+
+Since Math::BigInt and BigFloat also overload the normal math operations,
+the following line will still work:
+(TBT)
+
+ perl -Mbignum -le 'print ref(1234+1234)'
+
+=begin original
+
+Since numbers are actually objects, you can call all the usual methods from
+BigInt/BigFloat on them. This even works to some extent on expressions:
+
+=end original
+
+Since numbers are actually objects, you can call all the usual methods from
+BigInt/BigFloat on them. This even works to some extent on expressions:
+(TBT)
+
+ perl -Mbignum -le '$x = 1234; print $x->bdec()'
+ perl -Mbignum -le 'print 1234->copy()->binc();'
+ perl -Mbignum -le 'print 1234->copy()->binc->badd(6);'
+ perl -Mbignum -le 'print +(1234)->copy()->binc()'
+
+=begin original
+
+(Note that print doesn't do what you expect if the expression starts with
+'(' hence the C<+>)
+
+=end original
+
+(Note that print doesn't do what you expect if the expression starts with
+'(' hence the C<+>)
+(TBT)
+
+=begin original
+
+You can even chain the operations together as usual:
+
+=end original
+
+You can even chain the operations together as usual:
+(TBT)
+
+ perl -Mbignum -le 'print 1234->copy()->binc->badd(6);'
+ 1241
+
+=begin original
+
+Under bignum (or bigint or bigrat), Perl will "upgrade" the numbers
+appropriately. This means that:
+
+=end original
+
+Under bignum (or bigint or bigrat), Perl will "upgrade" the numbers
+appropriately. This means that:
+(TBT)
+
+ perl -Mbignum -le 'print 1234+4.5'
+ 1238.5
+
+=begin original
+
+will work correctly. These mixed cases don't do always work when using
+Math::BigInt or Math::BigFloat alone, or at least not in the way normal Perl
+scalars work.
+
+=end original
+
+will work correctly. These mixed cases don't do always work when using
+Math::BigInt or Math::BigFloat alone, or at least not in the way normal Perl
+scalars work.
+(TBT)
+
+=begin original
+
+If you do want to work with large integers like under C<use integer;>, try
+C<use bigint;>:
+
+=end original
+
+If you do want to work with large integers like under C<use integer;>, try
+C<use bigint;>:
+(TBT)
+
+ perl -Mbigint -le 'print 1234.5+4.5'
+ 1238
+
+=begin original
+
+There is also C<use bigrat;> which gives you big rationals:
+
+=end original
+
+There is also C<use bigrat;> which gives you big rationals:
+(TBT)
+
+ perl -Mbigrat -le 'print 1234+4.1'
+ 12381/10
+
+=begin original
+
+The entire upgrading/downgrading is still experimental and might not work
+as you expect or may even have bugs. You might get errors like this:
+
+=end original
+
+The entire upgrading/downgrading is still experimental and might not work
+as you expect or may even have bugs. You might get errors like this:
+(TBT)
+
+ Can't use an undefined value as an ARRAY reference at
+ /usr/local/lib/perl5/5.8.0/Math/BigInt/Calc.pm line 864
+
+=begin original
+
+This means somewhere a routine got a BigFloat/Lite but expected a BigInt (or
+vice versa) and the upgrade/downgrad path was missing. This is a bug, please
+report it so that we can fix it.
+
+=end original
+
+This means somewhere a routine got a BigFloat/Lite but expected a BigInt (or
+vice versa) and the upgrade/downgrad path was missing. This is a bug, please
+report it so that we can fix it.
+(TBT)
+
+=begin original
+
+You might consider using just Math::BigInt or Math::BigFloat, since they
+allow you finer control over what get's done in which module/space. For
+instance, simple loop counters will be Math::BigInts under C<use bignum;> and
+this is slower than keeping them as Perl scalars:
+
+=end original
+
+You might consider using just Math::BigInt or Math::BigFloat, since they
+allow you finer control over what get's done in which module/space. For
+instance, simple loop counters will be Math::BigInts under C<use bignum;> and
+this is slower than keeping them as Perl scalars:
+(TBT)
+
+ perl -Mbignum -le 'for ($i = 0; $i < 10; $i++) { print ref($i); }'
+
+=begin original
+
+Please note the following does not work as expected (prints nothing), since
+overloading of '..' is not yet possible in Perl (as of v5.8.0):
+
+=end original
+
+Please note the following does not work as expected (prints nothing), since
+overloading of '..' is not yet possible in Perl (as of v5.8.0):
+(TBT)
+
+ perl -Mbignum -le 'for (1..2) { print ref($_); }'
+
+=head2 Options
+
+=begin original
+
+bignum recognizes some options that can be passed while loading it via use.
+The options can (currently) be either a single letter form, or the long form.
+The following options exist:
+
+=end original
+
+bignum recognizes some options that can be passed while loading it via use.
+The options can (currently) be either a single letter form, or the long form.
+The following options exist:
+(TBT)
+
+=over 2
+
+=item a or accuracy
+
+=begin original
+
+This sets the accuracy for all math operations. The argument must be greater
+than or equal to zero. See Math::BigInt's bround() function for details.
+
+=end original
+
+This sets the accuracy for all math operations. The argument must be greater
+than or equal to zero. See Math::BigInt's bround() function for details.
+(TBT)
+
+ perl -Mbignum=a,50 -le 'print sqrt(20)'
+
+=begin original
+
+Note that setting precision and accurary at the same time is not possible.
+
+=end original
+
+Note that setting precision and accurary at the same time is not possible.
+(TBT)
+
+=item p or precision
+
+=begin original
+
+This sets the precision for all math operations. The argument can be any
+integer. Negative values mean a fixed number of digits after the dot, while
+a positive value rounds to this digit left from the dot. 0 or 1 mean round to
+integer. See Math::BigInt's bfround() function for details.
+
+=end original
+
+This sets the precision for all math operations. The argument can be any
+integer. Negative values mean a fixed number of digits after the dot, while
+a positive value rounds to this digit left from the dot. 0 or 1 mean round to
+integer. See Math::BigInt's bfround() function for details.
+(TBT)
+
+ perl -Mbignum=p,-50 -le 'print sqrt(20)'
+
+=begin original
+
+Note that setting precision and accurary at the same time is not possible.
+
+=end original
+
+Note that setting precision and accurary at the same time is not possible.
+(TBT)
+
+=item t or trace
+
+=begin original
+
+This enables a trace mode and is primarily for debugging bignum or
+Math::BigInt/Math::BigFloat.
+
+=end original
+
+This enables a trace mode and is primarily for debugging bignum or
+Math::BigInt/Math::BigFloat.
+(TBT)
+
+=item l or lib
+
+=begin original
+
+Load a different math lib, see L<MATH LIBRARY>.
+
+=end original
+
+Load a different math lib, see L<MATH LIBRARY>.
+(TBT)
+
+ perl -Mbignum=l,GMP -e 'print 2 ** 512'
+
+=begin original
+
+Currently there is no way to specify more than one library on the command
+line. This means the following does not work:
+
+=end original
+
+Currently there is no way to specify more than one library on the command
+line. This means the following does not work:
+(TBT)
+
+ perl -Mbignum=l,GMP,Pari -e 'print 2 ** 512'
+
+=begin original
+
+This will be hopefully fixed soon ;)
+
+=end original
+
+This will be hopefully fixed soon ;)
+(TBT)
+
+=item hex
+
+=begin original
+
+Override the built-in hex() method with a version that can handle big
+integers. Note that under Perl older than v5.9.4, this will be global
+and cannot be disabled with "no bigint;".
+
+=end original
+
+Override the built-in hex() method with a version that can handle big
+integers. Note that under Perl older than v5.9.4, this will be global
+and cannot be disabled with "no bigint;".
+(TBT)
+
+=item oct
+
+=begin original
+
+Override the built-in oct() method with a version that can handle big
+integers. Note that under Perl older than v5.9.4, this will be global
+and cannot be disabled with "no bigint;".
+
+=end original
+
+Override the built-in oct() method with a version that can handle big
+integers. Note that under Perl older than v5.9.4, this will be global
+and cannot be disabled with "no bigint;".
+(TBT)
+
+=item v or version
+
+=begin original
+
+This prints out the name and version of all modules used and then exits.
+
+=end original
+
+This prints out the name and version of all modules used and then exits.
+(TBT)
+
+ perl -Mbignum=v
+
+=back
+
+=head2 Methods
+
+=begin original
+
+Beside import() and AUTOLOAD() there are only a few other methods.
+
+=end original
+
+Beside import() and AUTOLOAD() there are only a few other methods.
+(TBT)
+
+=begin original
+
+Since all numbers are now objects, you can use all functions that are part of
+the BigInt or BigFloat API. It is wise to use only the bxxx() notation, and not
+the fxxx() notation, though. This makes it possible that the underlying object
+might morph into a different class than BigFloat.
+
+=end original
+
+Since all numbers are now objects, you can use all functions that are part of
+the BigInt or BigFloat API. It is wise to use only the bxxx() notation, and not
+the fxxx() notation, though. This makes it possible that the underlying object
+might morph into a different class than BigFloat.
+(TBT)
+
+=head2 Caveats
+
+=begin original
+
+But a warning is in order. When using the following to make a copy of a number,
+only a shallow copy will be made.
+
+=end original
+
+But a warning is in order. When using the following to make a copy of a number,
+only a shallow copy will be made.
+(TBT)
+
+ $x = 9; $y = $x;
+ $x = $y = 7;
+
+=begin original
+
+If you want to make a real copy, use the following:
+
+=end original
+
+If you want to make a real copy, use the following:
+(TBT)
+
+ $y = $x->copy();
+
+=begin original
+
+Using the copy or the original with overloaded math is okay, e.g. the
+following work:
+
+=end original
+
+Using the copy or the original with overloaded math is okay, e.g. the
+following work:
+(TBT)
+
+ $x = 9; $y = $x;
+ print $x + 1, " ", $y,"\n"; # prints 10 9
+
+=begin original
+
+but calling any method that modifies the number directly will result in
+B<both> the original and the copy being destroyed:
+
+=end original
+
+but calling any method that modifies the number directly will result in
+B<both> the original and the copy being destroyed:
+(TBT)
+
+ $x = 9; $y = $x;
+ print $x->badd(1), " ", $y,"\n"; # prints 10 10
+
+ $x = 9; $y = $x;
+ print $x->binc(1), " ", $y,"\n"; # prints 10 10
+
+ $x = 9; $y = $x;
+ print $x->bmul(2), " ", $y,"\n"; # prints 18 18
+
+=begin original
+
+Using methods that do not modify, but test the contents works:
+
+=end original
+
+Using methods that do not modify, but test the contents works:
+(TBT)
+
+ $x = 9; $y = $x;
+ $z = 9 if $x->is_zero(); # works fine
+
+=begin original
+
+See the documentation about the copy constructor and C<=> in overload, as
+well as the documentation in BigInt for further details.
+
+=end original
+
+See the documentation about the copy constructor and C<=> in overload, as
+well as the documentation in BigInt for further details.
+(TBT)
+
+=over 2
+
+=item inf()
+
+=begin original
+
+A shortcut to return Math::BigInt->binf(). Useful because Perl does not always
+handle bareword C<inf> properly.
+
+=end original
+
+A shortcut to return Math::BigInt->binf(). Useful because Perl does not always
+handle bareword C<inf> properly.
+(TBT)
+
+=item NaN()
+
+=begin original
+
+A shortcut to return Math::BigInt->bnan(). Useful because Perl does not always
+handle bareword C<NaN> properly.
+
+=end original
+
+A shortcut to return Math::BigInt->bnan(). Useful because Perl does not always
+handle bareword C<NaN> properly.
+(TBT)
+
+=item e
+
+ # perl -Mbignum=e -wle 'print e'
+
+=begin original
+
+Returns Euler's number C<e>, aka exp(1).
+
+=end original
+
+Returns Euler's number C<e>, aka exp(1).
+(TBT)
+
+=item PI()
+
+ # perl -Mbignum=PI -wle 'print PI'
+
+=begin original
+
+Returns PI.
+
+=end original
+
+Returns PI.
+(TBT)
+
+=item bexp()
+
+ bexp($power,$accuracy);
+
+=begin original
+
+Returns Euler's number C<e> raised to the appropriate power, to
+the wanted accuracy.
+
+=end original
+
+Returns Euler's number C<e> raised to the appropriate power, to
+the wanted accuracy.
+(TBT)
+
+=begin original
+
+Example:
+
+=end original
+
+Example:
+(TBT)
+
+ # perl -Mbignum=bexp -wle 'print bexp(1,80)'
+
+=item bpi()
+
+ bpi($accuracy);
+
+=begin original
+
+Returns PI to the wanted accuracy.
+
+=end original
+
+Returns PI to the wanted accuracy.
+(TBT)
+
+=begin original
+
+Example:
+
+=end original
+
+Example:
+(TBT)
+
+ # perl -Mbignum=bpi -wle 'print bpi(80)'
+
+=item upgrade()
+
+=begin original
+
+Return the class that numbers are upgraded to, is in fact returning
+C<$Math::BigInt::upgrade>.
+
+=end original
+
+Return the class that numbers are upgraded to, is in fact returning
+C<$Math::BigInt::upgrade>.
+(TBT)
+
+=item in_effect()
+
+ use bignum;
+
+ print "in effect\n" if bignum::in_effect; # true
+ {
+ no bignum;
+ print "in effect\n" if bignum::in_effect; # false
+ }
+
+=begin original
+
+Returns true or false if C<bignum> is in effect in the current scope.
+
+=end original
+
+Returns true or false if C<bignum> is in effect in the current scope.
+(TBT)
+
+=begin original
+
+This method only works on Perl v5.9.4 or later.
+
+=end original
+
+This method only works on Perl v5.9.4 or later.
+(TBT)
+
+=back
+
+=head2 Math Library
+
+=begin original
+
+Math with the numbers is done (by default) by a module called
+Math::BigInt::Calc. This is equivalent to saying:
+
+=end original
+
+Math with the numbers is done (by default) by a module called
+Math::BigInt::Calc. This is equivalent to saying:
+(TBT)
+
+ use bignum lib => 'Calc';
+
+=begin original
+
+You can change this by using:
+
+=end original
+
+You can change this by using:
+(TBT)
+
+ use bignum lib => 'GMP';
+
+=begin original
+
+The following would first try to find Math::BigInt::Foo, then
+Math::BigInt::Bar, and when this also fails, revert to Math::BigInt::Calc:
+
+=end original
+
+The following would first try to find Math::BigInt::Foo, then
+Math::BigInt::Bar, and when this also fails, revert to Math::BigInt::Calc:
+(TBT)
+
+ use bignum lib => 'Foo,Math::BigInt::Bar';
+
+=begin original
+
+Please see respective module documentation for further details.
+
+=end original
+
+Please see respective module documentation for further details.
+(TBT)
+
+=begin original
+
+Using C<lib> warns if none of the specified libraries can be found and
+L<Math::BigInt> did fall back to one of the default libraries.
+To supress this warning, use C<try> instead:
+
+=end original
+
+Using C<lib> warns if none of the specified libraries can be found and
+L<Math::BigInt> did fall back to one of the default libraries.
+To supress this warning, use C<try> instead:
+(TBT)
+
+ use bignum try => 'GMP';
+
+=begin original
+
+If you want the code to die instead of falling back, use C<only> instead:
+
+=end original
+
+If you want the code to die instead of falling back, use C<only> instead:
+(TBT)
+
+ use bignum only => 'GMP';
+
+=head2 INTERNAL FORMAT
+
+=begin original
+
+The numbers are stored as objects, and their internals might change at anytime,
+especially between math operations. The objects also might belong to different
+classes, like Math::BigInt, or Math::BigFLoat. Mixing them together, even
+with normal scalars is not extraordinary, but normal and expected.
+
+=end original
+
+The numbers are stored as objects, and their internals might change at anytime,
+especially between math operations. The objects also might belong to different
+classes, like Math::BigInt, or Math::BigFLoat. Mixing them together, even
+with normal scalars is not extraordinary, but normal and expected.
+(TBT)
+
+=begin original
+
+You should not depend on the internal format, all accesses must go through
+accessor methods. E.g. looking at $x->{sign} is not a bright idea since there
+is no guaranty that the object in question has such a hashkey, nor is a hash
+underneath at all.
+
+=end original
+
+You should not depend on the internal format, all accesses must go through
+accessor methods. E.g. looking at $x->{sign} is not a bright idea since there
+is no guaranty that the object in question has such a hashkey, nor is a hash
+underneath at all.
+(TBT)
+
+=head2 SIGN
+
+=begin original
+
+The sign is either '+', '-', 'NaN', '+inf' or '-inf' and stored seperately.
+You can access it with the sign() method.
+
+=end original
+
+The sign is either '+', '-', 'NaN', '+inf' or '-inf' and stored seperately.
+You can access it with the sign() method.
+(TBT)
+
+=begin original
+
+A sign of 'NaN' is used to represent the result when input arguments are not
+numbers or as a result of 0/0. '+inf' and '-inf' represent plus respectively
+minus infinity. You will get '+inf' when dividing a positive number by 0, and
+'-inf' when dividing any negative number by 0.
+
+=end original
+
+A sign of 'NaN' is used to represent the result when input arguments are not
+numbers or as a result of 0/0. '+inf' and '-inf' represent plus respectively
+minus infinity. You will get '+inf' when dividing a positive number by 0, and
+'-inf' when dividing any negative number by 0.
+(TBT)
+
+=head1 CAVAETS
+
+=over 2
+
+=item in_effect()
+
+=begin original
+
+This method only works on Perl v5.9.4 or later.
+
+=end original
+
+This method only works on Perl v5.9.4 or later.
+(TBT)
+
+=item hex()/oct()
+
+=begin original
+
+C<bigint> overrides these routines with versions that can also handle
+big integer values. Under Perl prior to version v5.9.4, however, this
+will not happen unless you specifically ask for it with the two
+import tags "hex" and "oct" - and then it will be global and cannot be
+disabled inside a scope with "no bigint":
+
+=end original
+
+C<bigint> overrides these routines with versions that can also handle
+big integer values. Under Perl prior to version v5.9.4, however, this
+will not happen unless you specifically ask for it with the two
+import tags "hex" and "oct" - and then it will be global and cannot be
+disabled inside a scope with "no bigint":
+(TBT)
+
+ use bigint qw/hex oct/;
+
+ print hex("0x1234567890123456");
+ {
+ no bigint;
+ print hex("0x1234567890123456");
+ }
+
+=begin original
+
+The second call to hex() will warn about a non-portable constant.
+
+=end original
+
+The second call to hex() will warn about a non-portable constant.
+(TBT)
+
+=begin original
+
+Compare this to:
+
+=end original
+
+Compare this to:
+(TBT)
+
+ use bigint;
+
+ # will warn only under older than v5.9.4
+ print hex("0x1234567890123456");
+
+=back
+
+=head1 MODULES USED
+
+=begin original
+
+C<bignum> is just a thin wrapper around various modules of the Math::BigInt
+family. Think of it as the head of the family, who runs the shop, and orders
+the others to do the work.
+
+=end original
+
+C<bignum> is just a thin wrapper around various modules of the Math::BigInt
+family. Think of it as the head of the family, who runs the shop, and orders
+the others to do the work.
+(TBT)
+
+=begin original
+
+The following modules are currently used by bignum:
+
+=end original
+
+The following modules are currently used by bignum:
+(TBT)
+
+ Math::BigInt::Lite (for speed, and only if it is loadable)
+ Math::BigInt
+ Math::BigFloat
+
+=head1 EXAMPLES
+
+=begin original
+
+Some cool command line examples to impress the Python crowd ;)
+
+ perl -Mbignum -le 'print sqrt(33)'
+ perl -Mbignum -le 'print 2*255'
+ perl -Mbignum -le 'print 4.5+2*255'
+ perl -Mbignum -le 'print 3/7 + 5/7 + 8/3'
+ perl -Mbignum -le 'print 123->is_odd()'
+ perl -Mbignum -le 'print log(2)'
+ perl -Mbignum -le 'print exp(1)'
+ perl -Mbignum -le 'print 2 ** 0.5'
+ perl -Mbignum=a,65 -le 'print 2 ** 0.2'
+ perl -Mbignum=a,65,l,GMP -le 'print 7 ** 7777'
+
+=head1 LICENSE
+
+This program is free software; you may redistribute it and/or modify it under
+the same terms as Perl itself.
+
+=head1 SEE ALSO
+
+=begin original
+
+Especially L<bigrat> as in C<perl -Mbigrat -le 'print 1/3+1/4'>.
+
+=end original
+
+Especially L<bigrat> as in C<perl -Mbigrat -le 'print 1/3+1/4'>.
+(TBT)
+
+=begin original
+
+L<Math::BigFloat>, L<Math::BigInt>, L<Math::BigRat> and L<Math::Big> as well
+as L<Math::BigInt::BitVect>, L<Math::BigInt::Pari> and L<Math::BigInt::GMP>.
+
+=end original
+
+L<Math::BigFloat>, L<Math::BigInt>, L<Math::BigRat> and L<Math::Big> as well
+as L<Math::BigInt::BitVect>, L<Math::BigInt::Pari> and L<Math::BigInt::GMP>.
+(TBT)
+
+=head1 AUTHORS
+
+(C) by Tels L<http://bloodgate.com/> in early 2002 - 2007.
+
+=cut
+
Index: docs/modules/bignum-0.23/bigrat.pod
diff -u /dev/null docs/modules/bignum-0.23/bigrat.pod:1.1
--- /dev/null Fri Sep 9 04:45:54 2011
+++ docs/modules/bignum-0.23/bigrat.pod Fri Sep 9 04:45:54 2011
@@ -0,0 +1,715 @@
+
+=encoding euc-jp
+
+=head1 NAME
+
+=begin original
+
+bigrat - Transparent BigNumber/BigRational support for Perl
+
+=end original
+
+bigrat - Perl 用の透過的な BigNumber/BigRational 対応
+
+=head1 SYNOPSIS
+
+ use bigrat;
+
+ print 2 + 4.5,"\n"; # BigFloat 6.5
+ print 1/3 + 1/4,"\n"; # produces 7/12
+
+ {
+ no bigrat;
+ print 1/3,"\n"; # 0.33333...
+ }
+
+ # Note that this will make hex() and oct() be globally overriden:
+ use bigrat qw/hex oct/;
+ print hex("0x1234567890123490"),"\n";
+ print oct("01234567890123490"),"\n";
+
+=head1 DESCRIPTION
+
+=begin original
+
+All operators (including basic math operations) are overloaded. Integer and
+floating-point constants are created as proper BigInts or BigFloats,
+respectively.
+
+=end original
+
+(基本算術演算子を含む)全ての演算子がオーバーロードされます。
+整数定数と浮動小数点数定数はそれぞれ適切な BigInt または BigFloat として
+作成されます。
+
+=begin original
+
+Other than L<bignum>, this module upgrades to Math::BigRat, meaning that
+instead of 2.5 you will get 2+1/2 as output.
+
+=end original
+
+Other than L<bignum>, this module upgrades to Math::BigRat, meaning that
+instead of 2.5 you will get 2+1/2 as output.
+(TBT)
+
+=head2 Modules Used
+
+=begin original
+
+C<bigrat> is just a thin wrapper around various modules of the Math::BigInt
+family. Think of it as the head of the family, who runs the shop, and orders
+the others to do the work.
+
+=end original
+
+C<bigrat> is just a thin wrapper around various modules of the Math::BigInt
+family. Think of it as the head of the family, who runs the shop, and orders
+the others to do the work.
+(TBT)
+
+=begin original
+
+The following modules are currently used by bignum:
+
+=end original
+
+The following modules are currently used by bignum:
+(TBT)
+
+ Math::BigInt::Lite (for speed, and only if it is loadable)
+ Math::BigInt
+ Math::BigFloat
+ Math::BigRat
+
+=head2 Math Library
+
+=begin original
+
+Math with the numbers is done (by default) by a module called
+Math::BigInt::Calc. This is equivalent to saying:
+
+=end original
+
+Math with the numbers is done (by default) by a module called
+Math::BigInt::Calc. This is equivalent to saying:
+(TBT)
+
+ use bigrat lib => 'Calc';
+
+=begin original
+
+You can change this by using:
+
+=end original
+
+You can change this by using:
+(TBT)
+
+ use bignum lib => 'GMP';
+
+=begin original
+
+The following would first try to find Math::BigInt::Foo, then
+Math::BigInt::Bar, and when this also fails, revert to Math::BigInt::Calc:
+
+=end original
+
+The following would first try to find Math::BigInt::Foo, then
+Math::BigInt::Bar, and when this also fails, revert to Math::BigInt::Calc:
+(TBT)
+
+ use bigrat lib => 'Foo,Math::BigInt::Bar';
+
+=begin original
+
+Using C<lib> warns if none of the specified libraries can be found and
+L<Math::BigInt> did fall back to one of the default libraries.
+To supress this warning, use C<try> instead:
+
+=end original
+
+Using C<lib> warns if none of the specified libraries can be found and
+L<Math::BigInt> did fall back to one of the default libraries.
+To supress this warning, use C<try> instead:
+(TBT)
+
+ use bignum try => 'GMP';
+
+=begin original
+
+If you want the code to die instead of falling back, use C<only> instead:
+
+=end original
+
+If you want the code to die instead of falling back, use C<only> instead:
+(TBT)
+
+ use bignum only => 'GMP';
+
+=begin original
+
+Please see respective module documentation for further details.
+
+=end original
+
+Please see respective module documentation for further details.
+(TBT)
+
+=head2 Sign
+
+=begin original
+
+The sign is either '+', '-', 'NaN', '+inf' or '-inf'.
+
+=end original
+
+The sign is either '+', '-', 'NaN', '+inf' or '-inf'.
+(TBT)
+
+=begin original
+
+A sign of 'NaN' is used to represent the result when input arguments are not
+numbers or as a result of 0/0. '+inf' and '-inf' represent plus respectively
+minus infinity. You will get '+inf' when dividing a positive number by 0, and
+'-inf' when dividing any negative number by 0.
+
+=end original
+
+A sign of 'NaN' is used to represent the result when input arguments are not
+numbers or as a result of 0/0. '+inf' and '-inf' represent plus respectively
+minus infinity. You will get '+inf' when dividing a positive number by 0, and
+'-inf' when dividing any negative number by 0.
+(TBT)
+
+=head2 Methods
+
+=begin original
+
+Since all numbers are not objects, you can use all functions that are part of
+the BigInt or BigFloat API. It is wise to use only the bxxx() notation, and not
+the fxxx() notation, though. This makes you independed on the fact that the
+underlying object might morph into a different class than BigFloat.
+
+=end original
+
+Since all numbers are not objects, you can use all functions that are part of
+the BigInt or BigFloat API. It is wise to use only the bxxx() notation, and not
+the fxxx() notation, though. This makes you independed on the fact that the
+underlying object might morph into a different class than BigFloat.
+(TBT)
+
+=over 2
+
+=item inf()
+
+=begin original
+
+A shortcut to return Math::BigInt->binf(). Useful because Perl does not always
+handle bareword C<inf> properly.
+
+=end original
+
+A shortcut to return Math::BigInt->binf(). Useful because Perl does not always
+handle bareword C<inf> properly.
+(TBT)
+
+=item NaN()
+
+=begin original
+
+A shortcut to return Math::BigInt->bnan(). Useful because Perl does not always
+handle bareword C<NaN> properly.
+
+=end original
+
+A shortcut to return Math::BigInt->bnan(). Useful because Perl does not always
+handle bareword C<NaN> properly.
+(TBT)
+
+=item e
+
+ # perl -Mbigrat=e -wle 'print e'
+
+=begin original
+
+Returns Euler's number C<e>, aka exp(1).
+
+=end original
+
+Returns Euler's number C<e>, aka exp(1).
+(TBT)
+
+=item PI
+
+ # perl -Mbigrat=PI -wle 'print PI'
+
+=begin original
+
+Returns PI.
+
+=end original
+
+Returns PI.
+(TBT)
+
+=item bexp()
+
+ bexp($power,$accuracy);
+
+
+=begin original
+
+Returns Euler's number C<e> raised to the appropriate power, to
+the wanted accuracy.
+
+=end original
+
+Returns Euler's number C<e> raised to the appropriate power, to
+the wanted accuracy.
+(TBT)
+
+=begin original
+
+Example:
+
+=end original
+
+Example:
+(TBT)
+
+ # perl -Mbigrat=bexp -wle 'print bexp(1,80)'
+
+=item bpi()
+
+ bpi($accuracy);
+
+=begin original
+
+Returns PI to the wanted accuracy.
+
+=end original
+
+Returns PI to the wanted accuracy.
+(TBT)
+
+=begin original
+
+Example:
+
+=end original
+
+Example:
+(TBT)
+
+ # perl -Mbigrat=bpi -wle 'print bpi(80)'
+
+=item upgrade()
+
+=begin original
+
+Return the class that numbers are upgraded to, is in fact returning
+C<$Math::BigInt::upgrade>.
+
+=end original
+
+Return the class that numbers are upgraded to, is in fact returning
+C<$Math::BigInt::upgrade>.
+(TBT)
+
+=item in_effect()
+
+ use bigrat;
+
+ print "in effect\n" if bigrat::in_effect; # true
+ {
+ no bigrat;
+ print "in effect\n" if bigrat::in_effect; # false
+ }
+
+=begin original
+
+Returns true or false if C<bigrat> is in effect in the current scope.
+
+=end original
+
+Returns true or false if C<bigrat> is in effect in the current scope.
+(TBT)
+
+=begin original
+
+This method only works on Perl v5.9.4 or later.
+
+=end original
+
+This method only works on Perl v5.9.4 or later.
+(TBT)
+
+=back
+
+=head2 MATH LIBRARY
+
+=begin original
+
+Math with the numbers is done (by default) by a module called
+
+=end original
+
+Math with the numbers is done (by default) by a module called
+(TBT)
+
+=head2 Cavaet
+
+=begin original
+
+But a warning is in order. When using the following to make a copy of a number,
+only a shallow copy will be made.
+
+=end original
+
+But a warning is in order. When using the following to make a copy of a number,
+only a shallow copy will be made.
+(TBT)
+
+ $x = 9; $y = $x;
+ $x = $y = 7;
+
+=begin original
+
+If you want to make a real copy, use the following:
+
+=end original
+
+If you want to make a real copy, use the following:
+(TBT)
+
+ $y = $x->copy();
+
+=begin original
+
+Using the copy or the original with overloaded math is okay, e.g. the
+following work:
+
+=end original
+
+Using the copy or the original with overloaded math is okay, e.g. the
+following work:
+(TBT)
+
+ $x = 9; $y = $x;
+ print $x + 1, " ", $y,"\n"; # prints 10 9
+
+=begin original
+
+but calling any method that modifies the number directly will result in
+B<both> the original and the copy being destroyed:
+
+=end original
+
+but calling any method that modifies the number directly will result in
+B<both> the original and the copy being destroyed:
+(TBT)
+
+ $x = 9; $y = $x;
+ print $x->badd(1), " ", $y,"\n"; # prints 10 10
+
+ $x = 9; $y = $x;
+ print $x->binc(1), " ", $y,"\n"; # prints 10 10
+
+ $x = 9; $y = $x;
+ print $x->bmul(2), " ", $y,"\n"; # prints 18 18
+
+=begin original
+
+Using methods that do not modify, but testthe contents works:
+
+=end original
+
+Using methods that do not modify, but testthe contents works:
+(TBT)
+
+ $x = 9; $y = $x;
+ $z = 9 if $x->is_zero(); # works fine
+
+=begin original
+
+See the documentation about the copy constructor and C<=> in overload, as
+well as the documentation in BigInt for further details.
+
+=end original
+
+See the documentation about the copy constructor and C<=> in overload, as
+well as the documentation in BigInt for further details.
+(TBT)
+
+=head2 Options
+
+=begin original
+
+bignum recognizes some options that can be passed while loading it via use.
+The options can (currently) be either a single letter form, or the long form.
+The following options exist:
+
+=end original
+
+bignum recognizes some options that can be passed while loading it via use.
+The options can (currently) be either a single letter form, or the long form.
+The following options exist:
+(TBT)
+
+=over 2
+
+=item a or accuracy
+
+=begin original
+
+This sets the accuracy for all math operations. The argument must be greater
+than or equal to zero. See Math::BigInt's bround() function for details.
+
+=end original
+
+This sets the accuracy for all math operations. The argument must be greater
+than or equal to zero. See Math::BigInt's bround() function for details.
+(TBT)
+
+ perl -Mbigrat=a,50 -le 'print sqrt(20)'
+
+=begin original
+
+Note that setting precision and accurary at the same time is not possible.
+
+=end original
+
+Note that setting precision and accurary at the same time is not possible.
+(TBT)
+
+=item p or precision
+
+=begin original
+
+This sets the precision for all math operations. The argument can be any
+integer. Negative values mean a fixed number of digits after the dot, while
+a positive value rounds to this digit left from the dot. 0 or 1 mean round to
+integer. See Math::BigInt's bfround() function for details.
+
+=end original
+
+This sets the precision for all math operations. The argument can be any
+integer. Negative values mean a fixed number of digits after the dot, while
+a positive value rounds to this digit left from the dot. 0 or 1 mean round to
+integer. See Math::BigInt's bfround() function for details.
+(TBT)
+
+ perl -Mbigrat=p,-50 -le 'print sqrt(20)'
+
+=begin original
+
+Note that setting precision and accurary at the same time is not possible.
+
+=end original
+
+Note that setting precision and accurary at the same time is not possible.
+(TBT)
+
+=item t or trace
+
+=begin original
+
+This enables a trace mode and is primarily for debugging bignum or
+Math::BigInt/Math::BigFloat.
+
+=end original
+
+This enables a trace mode and is primarily for debugging bignum or
+Math::BigInt/Math::BigFloat.
+(TBT)
+
+=item l or lib
+
+=begin original
+
+Load a different math lib, see L<MATH LIBRARY>.
+
+=end original
+
+Load a different math lib, see L<MATH LIBRARY>.
+(TBT)
+
+ perl -Mbigrat=l,GMP -e 'print 2 ** 512'
+
+=begin original
+
+Currently there is no way to specify more than one library on the command
+line. This means the following does not work:
+
+=end original
+
+Currently there is no way to specify more than one library on the command
+line. This means the following does not work:
+(TBT)
+
+ perl -Mbignum=l,GMP,Pari -e 'print 2 ** 512'
+
+=begin original
+
+This will be hopefully fixed soon ;)
+
+=end original
+
+This will be hopefully fixed soon ;)
+(TBT)
+
+=item hex
+
+=begin original
+
+Override the built-in hex() method with a version that can handle big
+integers. Note that under Perl v5.9.4 or ealier, this will be global
+and cannot be disabled with "no bigint;".
+
+=end original
+
+Override the built-in hex() method with a version that can handle big
+integers. Note that under Perl v5.9.4 or ealier, this will be global
+and cannot be disabled with "no bigint;".
+(TBT)
+
+=item oct
+
+=begin original
+
+Override the built-in oct() method with a version that can handle big
+integers. Note that under Perl v5.9.4 or ealier, this will be global
+and cannot be disabled with "no bigint;".
+
+=end original
+
+Override the built-in oct() method with a version that can handle big
+integers. Note that under Perl v5.9.4 or ealier, this will be global
+and cannot be disabled with "no bigint;".
+(TBT)
+
+=item v or version
+
+=begin original
+
+This prints out the name and version of all modules used and then exits.
+
+=end original
+
+This prints out the name and version of all modules used and then exits.
+(TBT)
+
+ perl -Mbigrat=v
+
+=back
+
+=head1 CAVAETS
+
+=over 2
+
+=item in_effect()
+
+=begin original
+
+This method only works on Perl v5.9.4 or later.
+
+=end original
+
+This method only works on Perl v5.9.4 or later.
+(TBT)
+
+=item hex()/oct()
+
+=begin original
+
+C<bigint> overrides these routines with versions that can also handle
+big integer values. Under Perl prior to version v5.9.4, however, this
+will not happen unless you specifically ask for it with the two
+import tags "hex" and "oct" - and then it will be global and cannot be
+disabled inside a scope with "no bigint":
+
+=end original
+
+C<bigint> overrides these routines with versions that can also handle
+big integer values. Under Perl prior to version v5.9.4, however, this
+will not happen unless you specifically ask for it with the two
+import tags "hex" and "oct" - and then it will be global and cannot be
+disabled inside a scope with "no bigint":
+(TBT)
+
+ use bigint qw/hex oct/;
+
+ print hex("0x1234567890123456");
+ {
+ no bigint;
+ print hex("0x1234567890123456");
+ }
+
+=begin original
+
+The second call to hex() will warn about a non-portable constant.
+
+=end original
+
+The second call to hex() will warn about a non-portable constant.
+(TBT)
+
+=begin original
+
+Compare this to:
+
+=end original
+
+Compare this to:
+(TBT)
+
+ use bigint;
+
+ # will warn only under Perl older than v5.9.4
+ print hex("0x1234567890123456");
+
+=back
+
+=head1 EXAMPLES
+
+ perl -Mbigrat -le 'print sqrt(33)'
+ perl -Mbigrat -le 'print 2*255'
+ perl -Mbigrat -le 'print 4.5+2*255'
+ perl -Mbigrat -le 'print 3/7 + 5/7 + 8/3'
+ perl -Mbigrat -le 'print 12->is_odd()';
+ perl -Mbignum=l,GMP -le 'print 7 ** 7777'
+
+=head1 LICENSE
+
+This program is free software; you may redistribute it and/or modify it under
+the same terms as Perl itself.
+
+=head1 SEE ALSO
+
+=begin original
+
+Especially L<bignum>.
+
+=end original
+
+Especially L<bignum>.
+(TBT)
+
+=begin original
+
+L<Math::BigFloat>, L<Math::BigInt>, L<Math::BigRat> and L<Math::Big> as well
+as L<Math::BigInt::BitVect>, L<Math::BigInt::Pari> and L<Math::BigInt::GMP>.
+
+=end original
+
+L<Math::BigFloat>, L<Math::BigInt>, L<Math::BigRat> and L<Math::Big> as well
+as L<Math::BigInt::BitVect>, L<Math::BigInt::Pari> and L<Math::BigInt::GMP>.
+(TBT)
+
+=head1 AUTHORS
+
+(C) by Tels L<http://bloodgate.com/> in early 2002 - 2007.
+
+=cut
+