X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2Fbigint.pm;h=1766e39d288a0ebfadba3e083cbb95b61098f8de;hb=5108dc18037af131227ae095719eaab3a8fd54cb;hp=26b8b2f1a4d5d291ca2f3d5bcdaae1ad55b1b5f0;hpb=1ad2138d16a5e3f58707d9c3b6f980ab17348c88;p=p5sagit%2Fp5-mst-13.2.git diff --git a/lib/bigint.pm b/lib/bigint.pm index 26b8b2f..1766e39 100644 --- a/lib/bigint.pm +++ b/lib/bigint.pm @@ -4,8 +4,8 @@ use 5.006002; $VERSION = '0.22'; use Exporter; @ISA = qw( Exporter ); -@EXPORT_OK = qw( ); -@EXPORT = qw( inf NaN ); +@EXPORT_OK = qw( PI e bpi bexp ); +@EXPORT = qw( inf NaN ); use strict; use overload; @@ -117,12 +117,55 @@ sub in_effect $hinthash->{bigint}; } +############################################################################# +# the following two routines are for "use bigint qw/hex oct/;": + +sub _hex_global + { + my $i = $_[0]; + $i = '0x'.$i unless $i =~ /^0x/; + Math::BigInt->new($i); + } + +sub _oct_global + { + my $i = $_[0]; + return Math::BigInt->from_oct($i) if $i =~ /^0[0-7]/; + Math::BigInt->new($i); + } + +############################################################################# +# the following two routines are for Perl 5.9.4 or later and are lexical + +sub _hex + { + return CORE::hex($_[0]) unless in_effect(1); + my $i = $_[0]; + $i = '0x'.$i unless $i =~ /^0x/; + Math::BigInt->new($i); + } + +sub _oct + { + return CORE::oct($_[0]) unless in_effect(1); + my $i = $_[0]; + return Math::BigInt->from_oct($i) if $i =~ /^0[0-7]/; + Math::BigInt->new($i); + } + sub import { my $self = shift; $^H{bigint} = 1; # we are in effect + my ($hex,$oct); + # for newer Perls always override hex() and oct() with a lexical version: + if ($] > 5.009004) + { + $oct = \&_oct; + $hex = \&_hex; + } # some defaults my $lib = ''; my $lib_kind = 'try'; @@ -162,7 +205,20 @@ sub import $trace = 1; splice @a, $j, 1; $j --; } - else { die "unknown option $_[$i]"; } + elsif ($_[$i] eq 'hex') + { + splice @a, $j, 1; $j --; + $hex = \&_hex_global; + } + elsif ($_[$i] eq 'oct') + { + splice @a, $j, 1; $j --; + $oct = \&_oct_global; + } + elsif ($_[$i] !~ /^(PI|e|bpi|bexp)\z/) + { + die ("unknown option $_[$i]"); + } } my $class; $_lite = 0; # using M::BI::L ? @@ -213,12 +269,22 @@ sub import no strict 'refs'; if (!defined *{"${package}::inf"}) { - $self->export_to_level(1,$self,@a); # export inf and NaN + $self->export_to_level(1,$self,@a); # export inf and NaN, e and PI } + { + no warnings 'redefine'; + *CORE::GLOBAL::oct = $oct if $oct; + *CORE::GLOBAL::hex = $hex if $hex; } + } + +sub inf () { Math::BigInt::binf(); } +sub NaN () { Math::BigInt::bnan(); } -sub inf () { Math::BigInt->binf(); } -sub NaN () { Math::BigInt->bnan(); } +sub PI () { Math::BigInt->new(3); } +sub e () { Math::BigInt->new(2); } +sub bpi ($) { Math::BigInt->new(3); } +sub bexp ($$) { my $x = Math::BigInt->new($_[0]); $x->bexp($_[1]); } 1; @@ -236,12 +302,18 @@ bigint - Transparent BigInteger support for Perl 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 All operators (including basic math operations) are overloaded. Integer @@ -272,9 +344,9 @@ some functions. C truncates these results to integer too: 2 # perl -Mbigint -wle 'print exp(1)' 2 - # perl -Mbigint -wle 'print exp(1)' + # perl -Minteger -wle 'print exp(1)' 2.71828182845905 - # perl -Mbigint -wle 'print exp(1) + 0' + # perl -Minteger -wle 'print exp(1) + 0' 2 In practice this makes seldom a difference as B of @@ -322,6 +394,18 @@ Note that setting precision and accurary at the same time is not possible. This enables a trace mode and is primarily for debugging bigint or Math::BigInt. +=item hex + +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;". + +=item oct + +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;". + =item l, lib, try or only Load a different math lib, see L. @@ -413,6 +497,44 @@ handle bareword C properly. A shortcut to return Math::BigInt->bnan(). Useful because Perl does not always handle bareword C properly. +=item e + + # perl -Mbigint=e -wle 'print e' + +Returns Euler's number C, aka exp(1). Note that under bigint, this is +truncated to an integer, and hence simple '2'. + +=item PI + + # perl -Mbigint=PI -wle 'print PI' + +Returns PI. Note that under bigint, this is truncated to an integer, and hence +simple '3'. + +=item bexp() + + bexp($power,$accuracy); + +Returns Euler's number C raised to the appropriate power, to +the wanted accuracy. + +Note that under bigint, the result is truncated to an integer. + +Example: + + # perl -Mbigint=bexp -wle 'print bexp(1,80)' + +=item bpi() + + bpi($accuracy); + +Returns PI to the wanted accuracy. Note that under bigint, this is truncated +to an integer, and hence simple '3'. + +Example: + + # perl -Mbigint=bpi -wle 'print bpi(80)' + =item upgrade() Return the class that numbers are upgraded to, is in fact returning @@ -472,6 +594,41 @@ Using methods that do not modify, but testthe contents works: See the documentation about the copy constructor and C<=> in overload, as well as the documentation in BigInt for further details. +=head1 CAVAETS + +=over 2 + +=item in_effect() + +This method only works on Perl v5.9.4 or later. + +=item hex()/oct() + +C 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": + + use bigint qw/hex oct/; + + print hex("0x1234567890123456"); + { + no bigint; + print hex("0x1234567890123456"); + } + +The second call to hex() will warn about a non-portable constant. + +Compare this to: + + use bigint; + + # will warn only under Perl older than v5.9.4 + print hex("0x1234567890123456"); + +=back + =head1 MODULES USED C is just a thin wrapper around various modules of the Math::BigInt