diff --git a/BUGS b/BUGS
new file mode 100644
index 0000000..70fe309
--- /dev/null
+++ b/BUGS
@@ -0,0 +1,26 @@
+For an updated list of bugs, see
+
+ https://rt.cpan.org/Public/Dist/Display.html?Name=bignum
+
+The following list is not up to date:
+
+Known bugs:
+
+* print 2 + 4.5,"\n"; # produces "6.5" but should be actually 65/10
+
+* perl -Mbignum=t -le 'print 2.0'
+ Loading Math::BigInt::Trace
+ MBI import Math::BigInt::Trace :constant upgrade Math::BigFloat::Trace lib Calc
+ Loading Math::BigFloat::Trace
+ MBF import Math::BigFloat::Trace :constant downgrade Math::BigInt::Trace
+ MBI new '2' => '2' (Math::BigInt::Trace)
+ MBF new '2.0' => '2' (Math::BigInt::Trace)
+ 2
+
+The order of MBI and MBF is reversed, since the output is done *after* the new,
+but the new of MBF downgrades internally to MBI. No solution yet.
+
+Please send me test-reports, your experiences with this and your ideas - I love
+to hear about my work!
+
+Tels
diff --git a/CHANGES b/CHANGES
new file mode 100644
index 0000000..862c137
--- /dev/null
+++ b/CHANGES
@@ -0,0 +1,373 @@
+2018-02-03 v0.49 pjacklam
+
+ * Improve specification of required modules in Makefile.PL.
+
+ * Fix typo in CHANGES file.
+
+2018-01-31 v0.48 pjacklam
+
+ * According to the CPAN testers reports, Perl v5.10 or later is required, so
+ make Perl v5.10 the minimum required version.
+
+ * Verify that CPAN RT #102006 is fixed.
+
+2016-12-13 v0.47 pjacklam
+
+ * Add more logic to Makefile.PL regarding INSTALLDIRS (CPAN RT #119199
+ and #119225).
+
+2016-12-11 v0.46 pjacklam
+
+ * Fix Makefile.PL so that this module installs over the core version.
+
+2016-12-03 v0.45 pjacklam
+
+ * Use ExtUtils::MakeMaker rather than Module::Install in Makefile.PL
+
+ * Remove INSTALL file. The information is in the README file.
+
+ * Improve documentation in BUGS and SUPPORT sections in POD in bignum.pm,
+ bigint.pm, and bigrat.pm.
+
+ * Remove unused variables in Math/BigInt/Trace.pm and Math/BigFloat/Trace.pm
+
+ * Update README and BUGS files.
+
+ * Remove code that was accidentally left in t/infnan.inc after debugging.
+
+ * Remove author information in LICENSE file.
+
+ * Trim whitespace.
+
+ * CHANGES file now has the same formatting as other Math::BigInt-related
+ distributions.
+
+2016-11-15 v0.44 pjacklam
+
+ * Update bundled Module::Install from version 1.16 to version 1.17.
+
+ * Replace function calls with method calls.
+
+ * Include patch for CPAN RT #116506.
+
+2016-07-09 v0.43 pjacklam
+
+ * Replace function calls with method calls.
+
+2016-01-05 v0.42 pjacklam
+
+ * "use strict" and "use warnings" everywhere.
+
+ * Reformat some if the code according to the "perlstyle" man page. It makes
+ the code easier for read, for me at least.
+
+ * Add descriptions to tests.
+
+ * Reorder CHANGES to chronological order.
+
+ * Use bpi() as a class method, not a function.
+
+ * Replace "use vars ..." with "our ...".
+
+ * More descriptive variable names.
+
+ * Start POD sections with =pod
+
+ * Allow "nan", "inf", and "infinity", and ingore case, since core Perl allows
+ these. We want to be compatible. Add tests to "infnan.inc".
+
+2015-09-25 v0.41 pjacklam
+
+ * hex() and oct() now have the same semantics as the corresponding core
+ functions. E.g., hex("cat") returns 202 and a warning "Illegal hexadecimal
+ digit 't' ignored at ..." rather than NaN.
+
+ * Added test files auth-bigint-hex.t and auth-bigint-oct.t.
+
+ * Minimum required version of the Math-BigInt distro is now 1.992.
+
+2015-09-22 v0.40 pjacklam
+
+ * Sync with blead.
+
+ * Update author information in Makefile.PL.
+
+2015-09-14 v0.39 pjacklam
+
+ * bignum tests: use eval-block instead of eval-string
+
+ * bignum tests: use eval block to load Math::BigInt::Lite
+
+ * Set version number in all .pm files to 0.39.
+
+ * Display information about module versions in 01load.t.
+
+2015-08-28 v0.38 pjacklam
+
+ * Synchronise with blead perl.
+
+ * Minimum required Math-BigInt is v1.88.
+
+ * Update bundled Module::Install from v1.08 to v1.16.
+
+2014-04-03 v0.37 pjacklam
+
+ * Synchronise with blead perl.
+
+ * Added new '00sig.t', '01load.t', '02pod.t', and '03pod_cov.t'.
+
+ * Removed old 'pod.t' and 'podcov.t'
+
+2012-09-11 rafl 0.30 302 tests
+
+ * Synchronise with blead perl.
+
+2011-08-08 rafl 0.29 302 tests
+
+ * Synchronise with blead perl.
+
+2011-07-09 rafl 0.28 302 tests
+
+ * Synchronise with blead perl.
+
+2010-09-15 rafl 0.25 302 tests
+
+ * Synchronise with blead perl
+ Only changes in the tests.
+
+2010-09-04 rafl 0.24 301 tests
+
+ * Apply changes from blead perl
+ Mostly POD fixes and minor test tweaks.
+
+2008-04-05 Tels 0.23 301 tests
+
+ * require Math::BigInt v1.88
+
+ * require Math::BigRat v0.21
+
+ * update bundles Module::Install
+
+ * require Perl 5.006 (vs. 5.006002), should work with that
+
+2007-06-30 Tels 0.22 301 tests
+
+ * make the pragmas lexical, so that "no bigint;" etc. works
+
+ * make "use bigint; use bignum;" not warn about redefining "inf" and "NaN"
+ This also means a "use bigint;" will not override any already existing
+ "inf" or "NaN" routine
+
+ * require Math::BigInt v1.87
+
+ * fix #27059: t/option_l.t fails
+
+ * on Perl 5.9.4 or later: "overload" hex() and oct() with lexical routines
+ that also handle arbitrary big integers
+
+ * for all Perls: make "use bigint qw/hex oct/" export global hex() and oct()
+ routines that work with big integers
+
+ * make bignum.pm and bigrat.pm re-use code from bigint.pm
+
+ * add exportable bpi() and bexp() methods
+
+ * add exportable PI and e constants
+
+2007-04-17 Tels 0.21 205 tests
+
+ * require Math::BigInt v1.83
+
+ * require Math::BigRat v0.19
+
+ * add support for "try" and "only"
+
+ * fix licence field back to "perl"
+
+2007-04-09 Tels 0.20 198 tests
+
+ * require Math::BigInt v1.82
+
+ * require Math::BigRat v0.18
+
+ * add a test for bug #18025:
+ "bignum/bigrat can lead to a number that is both 1 and 0"
+
+ * POD test needs Test::Pod::Coverage 1.08 to work
+
+2007-02-03 Tels 0.19 194 tests
+
+ * require Math::BigInt v1.79
+
+ * require Perl v5.6.2
+
+ * add Build.PL
+
+ * use Module::Install
+
+ * remove PREREQ_FATAL since the toolchain is broken
+
+ * apply spelling fixes to POD
+
+2007-01-27 Tels 0.18 194 tests
+
+ * require Math::BigInt 1.78
+
+ * add support for octal constants
+
+ * use PREREQ_FATAL
+
+ * add POD tests
+
+2005-04-03 Tels 0.17 184 tests
+
+ * remove the default library 'Calc', and let Bigint et. al. decide instead
+ which library to load as default
+
+2005-01-01 Tels 0.16 184 tests
+
+ * option "l", "a", and "p" did not work under -Mbigrat
+
+ * little doc fixes
+
+ * add more tests, convert some testfiles to Test::More
+
+2004-03-12 Tels 0.15 175 tests
+
+ * small nitpick fix for Math::BigInt v1.70
+
+2003-07-04 Tels 0.14 175 tests (released)
+
+ * small nits fixed
+
+ * allow parameters a and p for bigrat
+
+2002-12-12 Tels 0.14a 175 tests (not released)
+
+ * added doc about shallow copies like $x = $y and method calls
+
+ * precision()/accuracy()/round_mode() save now one call and are thus faster
+
+ * bigrat() now calls Math::BigRat->precision|accuracy|round_mode, too
+
+ * distribution is now signed, go to http://bloodgate.com/tels.asc for key
+
+2002-08-24 v0.13 Tels
+
+ * added a LOT to the documentation
+
+ * tests don't go "huh" anymore
+
+ * bninfnan.t has the correct setup for testing in the core
+
+2002-08-13 v0.12 Tels
+
+ * INSTALLDIRS => perl
+
+ * document that use bignum/bigint/bigrat is global, not only in current block
+
+ * added default exported inf() and NaN() routines to fix the second example:
+ perl -Mbignum -e 'print 1 + inf,"\n"'
+ perl -Mbignum -e 'print inf + inf,"\n"'
+
+ * tests for inf()/NaN()
+
+2002-03-25 v0.11 Tels
+
+ * testsuite failed under Lite due to specific tests for MBI
+
+ * removed the printing of "Loading ..." to STDERR (interfered w/ something)
+
+ * more tests for bigrat and bignum
+
+ * trace.t remvoed due to VMS problems
+
+2002-03-17 v0.10 Tels
+
+ * bigint: handle floating point constants like '4.5', '45e-1', '4.56e1' by
+ truncating them to integer, so:
+ perl -Mbigint -le 'print 4.5+4.5'
+ 8
+
+2002-03-12 v0.09 Tels
+
+ * added bigint.pm as a better way of perl -MMath::BigInt=:constant
+
+ * tests for that
+
+ * bigrat: some typos
+
+2002-03-11 v0.08 Tels
+
+ * doc fixes/types and 'l' is equal to 'lib' (thanx to Dan Sullivan)
+
+ * added tests for l, lib, and foo (the latter is expected to die)
+
+ * uses Math::BigInt::Lite when it finds it, otherwise just plain M::BI
+
+ * added tests for loading of Lite
+
+ * version output includes Math::BigInt::Lite when it was used
+
+ * rewritten README and INSTALL document
+
+2002-03-05 v0.07 Tels
+
+ * new options: a (accuracy) and p (precision)
+
+ * doc and tests improved quite a lot
+
+2002-02-26 v0.06 Tels
+
+ * options can now be in short (one letter) or long form
+
+ * new option: t or trace
+
+ * old option: v or version
+
+ * included Math::BigInt::Trace for trace
+
+2002-02-24 v0.05 Tels
+
+ * Comes now in two flavours: Normal (bignum) and Rat-flavoured (bigrat)
+ te@null:~ > perl -Mbignum=v
+ Math::BigInt v1.52 lib => Math::BigInt::Calc v0.23
+ Math::BigFloat v1.29
+ te@null:~ > perl -Mbigrat=v
+ Math::BigInt v1.52 lib => Math::BigInt::Calc v0.23
+ Math::BigFloat v1.29
+ Math::BigRat v0.02
+
+2002-02-21 v0.04 Tels
+
+ * added :constant to Math::BigFloat loading and tests for it
+
+ * added v to import to print version and exit:
+
+ te@null:~ > perl -Mbignum=v
+ Math::BigInt v1.51 lib => Math::BigInt::Calc v0.22
+ Math::BigFloat v1.28
+ Math::BigRat v0.02
+ te@null:~ > perl -Mbignum=v,lib,Pari
+ Math::BigInt v1.51 lib => Math::BigInt::Pari v1.07
+ Math::BigFloat v1.28
+ Math::BigRat v0.02
+
+2002-02-10 v0.03 Tels
+
+ * renamed to bignum
+
+ * added dependency and loading of Math::BigRat
+
+2002-01-29 v0.02 Tels
+
+ * AUTOLOAD, cleaned up a bit
+
+2002-01-29 v0.01 Tels
+
+ * first version
+
+Please send me test-reports, your experiences with this and your ideas - I love
+to hear about my work!
+
+Tels
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..1eedfda
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,2 @@
+This program is free software; you may redistribute it and/or modify it
+under the same terms as Perl itself.
diff --git a/MANIFEST b/MANIFEST
new file mode 100644
index 0000000..41ed4fb
--- /dev/null
+++ b/MANIFEST
@@ -0,0 +1,44 @@
+BUGS
+CHANGES
+lib/bigint.pm
+lib/bignum.pm
+lib/bigrat.pm
+lib/Math/BigFloat/Trace.pm
+lib/Math/BigInt/Trace.pm
+LICENSE
+Makefile.PL
+MANIFEST This list of files
+MANIFEST.SKIP
+README
+t/00sig.t
+t/01load.t
+t/02pod.t
+t/03podcov.t
+t/author-bigint-hex.t
+t/author-bigint-oct.t
+t/big_e_pi.t
+t/bigexp.t
+t/bigint.t
+t/bignum.t
+t/bigrat.t
+t/bii_e_pi.t
+t/biinfnan.t
+t/bir_e_pi.t
+t/bn_lite.t
+t/bninfnan.t
+t/br_lite.t
+t/brinfnan.t
+t/in_effect.t
+t/infnan.inc
+t/option_a.t
+t/option_l.t
+t/option_p.t
+t/overrides.t
+t/ratopt_a.t
+t/scope_f.t
+t/scope_i.t
+t/scope_r.t
+TODO
+META.yml Module YAML meta-data (added by MakeMaker)
+META.json Module JSON meta-data (added by MakeMaker)
+SIGNATURE Public-key signature (added by MakeMaker)
diff --git a/MANIFEST.SKIP b/MANIFEST.SKIP
new file mode 100644
index 0000000..f399291
--- /dev/null
+++ b/MANIFEST.SKIP
@@ -0,0 +1,12 @@
+.*\.tar\.gz
+^blib.*
+^\w+\.(html|txt|png|dot|pl|svg|old|bak|org)
+^Makefile\z
+^Makefile.(old|bak)\z
+^MANIFEST.(old|bak)\z
+^MYMETA\.(yml|json)\z
+\.*tmp
+.*\.patch\z
+pm_to_blib
+\.git.*
+^bignum-[0-9]
diff --git a/META.json b/META.json
new file mode 100644
index 0000000..abd2be8
--- /dev/null
+++ b/META.json
@@ -0,0 +1,49 @@
+{
+ "abstract" : "unknown",
+ "author" : [
+ "Peter John Acklam "
+ ],
+ "dynamic_config" : 1,
+ "generated_by" : "ExtUtils::MakeMaker version 7.3, CPAN::Meta::Converter version 2.150010",
+ "license" : [
+ "perl_5"
+ ],
+ "meta-spec" : {
+ "url" : "http://search.cpan.org/perldoc?CPAN::Meta::Spec",
+ "version" : 2
+ },
+ "name" : "bignum",
+ "no_index" : {
+ "directory" : [
+ "t",
+ "inc"
+ ]
+ },
+ "prereqs" : {
+ "build" : {
+ "requires" : {
+ "ExtUtils::MakeMaker" : "6.64"
+ }
+ },
+ "configure" : {
+ "requires" : {
+ "ExtUtils::MakeMaker" : "6.64"
+ }
+ },
+ "runtime" : {
+ "requires" : {
+ "Math::BigInt" : "1.999718",
+ "Math::BigRat" : "0.12",
+ "perl" : "5.01"
+ }
+ },
+ "test" : {
+ "requires" : {
+ "Test::More" : "0.47"
+ }
+ }
+ },
+ "release_status" : "stable",
+ "version" : "0.49",
+ "x_serialization_backend" : "JSON::PP version 2.97000"
+}
diff --git a/META.yml b/META.yml
new file mode 100644
index 0000000..87057f5
--- /dev/null
+++ b/META.yml
@@ -0,0 +1,26 @@
+---
+abstract: unknown
+author:
+ - 'Peter John Acklam '
+build_requires:
+ ExtUtils::MakeMaker: '6.64'
+ Test::More: '0.47'
+configure_requires:
+ ExtUtils::MakeMaker: '6.64'
+dynamic_config: 1
+generated_by: 'ExtUtils::MakeMaker version 7.3, CPAN::Meta::Converter version 2.150010'
+license: perl
+meta-spec:
+ url: http://module-build.sourceforge.net/META-spec-v1.4.html
+ version: '1.4'
+name: bignum
+no_index:
+ directory:
+ - t
+ - inc
+requires:
+ Math::BigInt: '1.999718'
+ Math::BigRat: '0.12'
+ perl: '5.01'
+version: '0.49'
+x_serialization_backend: 'CPAN::Meta::YAML version 0.018'
diff --git a/Makefile.PL b/Makefile.PL
new file mode 100644
index 0000000..d39d729
--- /dev/null
+++ b/Makefile.PL
@@ -0,0 +1,39 @@
+#!perl
+
+use strict;
+use warnings;
+use ExtUtils::MakeMaker;
+
+my %WriteMakefileArgs =
+ (
+ 'NAME' => 'bignum',
+ 'VERSION_FROM' => 'lib/bignum.pm',
+ 'AUTHOR' => 'Peter John Acklam ',
+ 'MIN_PERL_VERSION' => 5.010,
+ 'CONFIGURE_REQUIRES' => {
+ 'ExtUtils::MakeMaker' => 6.64,
+ },
+ 'BUILD_REQUIRES' => {
+ 'ExtUtils::MakeMaker' => 6.64,
+ },
+ 'PREREQ_PM' => {
+ 'Math::BigInt' => 1.999718,
+ 'Math::BigRat' => 0.12,
+ #'Math::BigInt::Lite' => 0.09, # optional
+ },
+ 'TEST_REQUIRES' => {
+ 'Test::More' => 0.47,
+ },
+ 'LICENSE' => 'perl_5',
+ 'LIBS' => [''], # e.g., '-lm'
+ 'DEFINE' => '', # e.g., '-DHAVE_SOMETHING'
+ 'INC' => '', # e.g., '-I/usr/include/other'
+ 'SIGN' => 1,
+ );
+
+# Install over the core version? (Cf. CPAN RT #119199 and #119225.)
+
+$WriteMakefileArgs{INSTALLDIRS} = 'perl'
+ if $] >= 5.008 && $] < 5.012;
+
+WriteMakefile(%WriteMakefileArgs);
diff --git a/README b/README
new file mode 100644
index 0000000..62b5e6a
--- /dev/null
+++ b/README
@@ -0,0 +1,43 @@
+bignum
+
+bignum - transparent big number support
+
+INSTALLATION
+
+To install this module, unpack the distribution file, and run the following
+commands:
+
+ perl Makefile.PL
+ make
+ make test
+ make install
+
+SUPPORT AND DOCUMENTATION
+
+After installing, you can find documentation for these modules with the
+perldoc command.
+
+ perldoc bignum
+
+You can also look for information at:
+
+ RT, CPAN's request tracker
+ http://rt.cpan.org/NoAuth/Bugs.html?Dist=bignum
+
+ AnnoCPAN, Annotated CPAN documentation
+ http://annocpan.org/dist/bignum
+
+ CPAN Ratings
+ http://cpanratings.perl.org/d/bignum
+
+ Search CPAN
+ http://search.cpan.org/dist/bignum
+
+COPYRIGHT AND LICENCE
+
+Copyright 2002-2007 Tels, L.
+
+Copyright 2014- Peter John Acklam L.
+
+This program is free software; you can redistribute it and/or modify it
+under the same terms as Perl itself.
diff --git a/SIGNATURE b/SIGNATURE
new file mode 100644
index 0000000..a12a26f
--- /dev/null
+++ b/SIGNATURE
@@ -0,0 +1,69 @@
+This file contains message digests of all files listed in MANIFEST,
+signed via the Module::Signature module, version 0.81.
+
+To verify the content in this distribution, first make sure you have
+Module::Signature installed, then type:
+
+ % cpansign -v
+
+It will check each file's integrity, as well as the signature's
+validity. If "==> Signature verified OK! <==" is not displayed,
+the distribution may already have been compromised, and you should
+not run its Makefile.PL or Build.PL.
+
+-----BEGIN PGP SIGNED MESSAGE-----
+Hash: SHA1
+
+SHA1 3ee135c08dc6dda71c7381f1a2495df461458e03 BUGS
+SHA1 3735d390ff81bd72f0ddf3e0e06084b6956189c8 CHANGES
+SHA1 d7c83d8f89b92a3262a01eb2778d39402e77263a LICENSE
+SHA1 53ff562ba2eecd551ef6aee56f6f391031a3c912 MANIFEST
+SHA1 4d036a4cde22d6d80f1e4aa41b6951e81c657325 MANIFEST.SKIP
+SHA1 e521e597387984481c6d4af68c84f39d2d4513a9 META.json
+SHA1 18879630e7a5350647183fa793bde0f1786ac5cf META.yml
+SHA1 dad19971982e551df2316fbebbb880d1bc6e3c3d Makefile.PL
+SHA1 fa6d74767423bf79cfaedb3e461160d1faeab91e README
+SHA1 0070e1ca5b12be8948c08e62e62c98a2df7410d4 TODO
+SHA1 60f923ec155ecde0bececc6c24dbaf81ddc941e8 lib/Math/BigFloat/Trace.pm
+SHA1 7a03dd82a6167cf5c95d99f65409faba5adee302 lib/Math/BigInt/Trace.pm
+SHA1 48b15b4262a9c86ceff7aa2d12a2bcb59bda2bde lib/bigint.pm
+SHA1 fdd77e3d004c5cc40fbc9666458c9b8c3a0ee701 lib/bignum.pm
+SHA1 cc9732a5ecbdc486349e30e8abdf37800c70d540 lib/bigrat.pm
+SHA1 a2d393f9d265801f8ef022725d03f83b616b2fe1 t/00sig.t
+SHA1 4564e2c5605e7568738286358e4a49c8f27c38e6 t/01load.t
+SHA1 237e24044b9cc602f739d4eff3f6f1bd3b51f16e t/02pod.t
+SHA1 51ca22f1945595e0272dbc26bca2c1d4f8231568 t/03podcov.t
+SHA1 af0aa4628e18d980b985a4bd22db6b4f0467125b t/author-bigint-hex.t
+SHA1 c3bc8706bef21cdf96564bae9b7a4a1f1a8b5f2c t/author-bigint-oct.t
+SHA1 ed3e805322e1f1799e2e68b65a1c0c34d5e78b71 t/big_e_pi.t
+SHA1 06ba8137ea1136b3a86862effd90bd23c60360ee t/bigexp.t
+SHA1 6ec6c37fd18ec538940a90c3cb4f7ea438b50817 t/bigint.t
+SHA1 2935aa58821ff53327399329dbcf8194e92e5772 t/bignum.t
+SHA1 799432d401aeba8bf84b4ea93adda6ebcc7ce9ee t/bigrat.t
+SHA1 ac5e242ec0cc96d203760eb54eb5cf3e26cb4bb5 t/bii_e_pi.t
+SHA1 c2eeb2e8a74025f651ae8eeecab41854dd100c7f t/biinfnan.t
+SHA1 a3d5829a255fbb24126be4728efd245356d4d436 t/bir_e_pi.t
+SHA1 e2066465a1aa0369487e45af4fed469b5d7915bc t/bn_lite.t
+SHA1 ed6ff44bd1c726f1c87cb39e200116c5472d2550 t/bninfnan.t
+SHA1 00679525b4719dabd088a7f7c8d8e758cefbc140 t/br_lite.t
+SHA1 6480aa7520b00b34c78c84963ce972348627265c t/brinfnan.t
+SHA1 39c5a2b06ca0299cbc5c846e9347194610e8ec1c t/in_effect.t
+SHA1 65215b3093ffbbbdc432d62abac0e1768eb34969 t/infnan.inc
+SHA1 9995d3788a1561f0a6e30178e9f93a425726ff0d t/option_a.t
+SHA1 602522ad22998581c2b5f5a7e0cfc26343b6e1a0 t/option_l.t
+SHA1 6474ca84364a126496999f2d6c47e6c0e740092b t/option_p.t
+SHA1 bccfe0521ab0c46fb0f175485fa6ea889bc64d82 t/overrides.t
+SHA1 523dddeb99a76738db6b91d2dae8cd5eda365537 t/ratopt_a.t
+SHA1 b1bc1bd4ff2fc69322b132b7154c86b15b1f0f62 t/scope_f.t
+SHA1 6fb36d527514933d0a7457c95c13e863543250ef t/scope_i.t
+SHA1 e0aa84c76b7c2167b53f36147f752adf9d26f1e6 t/scope_r.t
+-----BEGIN PGP SIGNATURE-----
+
+iQEcBAEBAgAGBQJads5cAAoJEGcmPl2fr166qg4IAIU562zug4+fVo5OuoocGLTK
+EEbCiyUSso+xu1dqdS8ztUHQGGOCEVDm/QlJIHexnecB+fBYN0ufix87cBoQvHuk
+u0PiNrkTZKDyIDrmSntb520hHH2cIYz9Tyw9bDIzGKGsZTgGSYlzo233jSnMlYhE
+MogKuArBjmNjsGpFCRAo9DhoTZ6Wa9i9QQnZk5UrKhlFi6Lj09LCc54x5SJAxtDc
+aaxOM9ocR/Em2L+iSRoMG6FWX+d2I4DK7UcluaTfcTO0/41P5SYI0xp77tQkJUUj
+9Q/QRT6ew8urKxz6FuAyRbK+1acv39F0e0dHgjS1J0kvrygrnQCvSOHdmKsXS80=
+=ci/j
+-----END PGP SIGNATURE-----
diff --git a/TODO b/TODO
new file mode 100644
index 0000000..ec02696
--- /dev/null
+++ b/TODO
@@ -0,0 +1,6 @@
+Pretty much done, but there might be new ideas worth adding.
+
+Please send me test-reports, your experiences with this and your ideas - I love
+to hear about my work!
+
+Tels
diff --git a/lib/Math/BigFloat/Trace.pm b/lib/Math/BigFloat/Trace.pm
new file mode 100644
index 0000000..04dec98
--- /dev/null
+++ b/lib/Math/BigFloat/Trace.pm
@@ -0,0 +1,58 @@
+#!perl
+
+package Math::BigFloat::Trace;
+
+require 5.010;
+use strict;
+use warnings;
+
+use Exporter;
+use Math::BigFloat;
+
+our ($accuracy, $precision, $round_mode, $div_scale);
+
+our @ISA = qw(Exporter Math::BigFloat);
+
+our $VERSION = '0.49';
+
+use overload; # inherit overload from Math::BigFloat
+
+# Globals
+$accuracy = $precision = undef;
+$round_mode = 'even';
+$div_scale = 40;
+
+sub new {
+ my $proto = shift;
+ my $class = ref($proto) || $proto;
+
+ my $value = shift;
+ my $a = $accuracy;
+ $a = $_[0] if defined $_[0];
+ my $p = $precision;
+ $p = $_[1] if defined $_[1];
+ my $self = Math::BigFloat->new($value, $a, $p, $round_mode);
+
+ # remember, downgrading may return a BigInt, so don't meddle with class
+ # bless $self, $class;
+
+ print "MBF new '$value' => '$self' (", ref($self), ")";
+ return $self;
+}
+
+sub import {
+ print "MBF import ", join(' ', @_);
+ my $self = shift;
+
+ # we catch the constants, the rest goes go BigFloat
+ my @a = ();
+ foreach (@_) {
+ push @a, $_ if $_ ne ':constant';
+ }
+ overload::constant float => sub { $self->new(shift); };
+
+ Math::BigFloat->import(@a); # need it for subclasses
+# $self->export_to_level(1,$self,@_); # need this ?
+}
+
+1;
diff --git a/lib/Math/BigInt/Trace.pm b/lib/Math/BigInt/Trace.pm
new file mode 100644
index 0000000..5f83c79
--- /dev/null
+++ b/lib/Math/BigInt/Trace.pm
@@ -0,0 +1,48 @@
+#!perl
+
+package Math::BigInt::Trace;
+
+require 5.010;
+use strict;
+use warnings;
+
+use Exporter;
+use Math::BigInt;
+
+our ($accuracy, $precision, $round_mode, $div_scale);
+
+our @ISA = qw(Exporter Math::BigInt);
+
+our $VERSION = '0.49';
+
+use overload; # inherit overload from Math::BigInt
+
+# Globals
+$accuracy = $precision = undef;
+$round_mode = 'even';
+$div_scale = 40;
+
+sub new {
+ my $proto = shift;
+ my $class = ref($proto) || $proto;
+
+ my $value = shift;
+ my $a = $accuracy;
+ $a = $_[0] if defined $_[0];
+ my $p = $precision;
+ $p = $_[1] if defined $_[1];
+ my $self = Math::BigInt->new($value, $a, $p, $round_mode);
+ bless $self, $class;
+ print "MBI new '$value' => '$self' (", ref($self), ")";
+ return $self;
+}
+
+sub import {
+ print "MBI import ", join(' ', @_);
+ my $self = shift;
+ Math::BigInt::import($self, @_); # need it for subclasses
+# $self->export_to_level(1, $self, @_); # need this ?
+ @_ = ();
+}
+
+1;
diff --git a/lib/bigint.pm b/lib/bigint.pm
new file mode 100644
index 0000000..92aeae8
--- /dev/null
+++ b/lib/bigint.pm
@@ -0,0 +1,822 @@
+package bigint;
+
+use 5.010;
+use strict;
+use warnings;
+
+our $VERSION = '0.49';
+
+use Exporter;
+our @ISA = qw( Exporter );
+our @EXPORT_OK = qw( PI e bpi bexp hex oct );
+our @EXPORT = qw( inf NaN );
+
+use overload;
+
+##############################################################################
+
+# These are all alike, and thus faked by AUTOLOAD
+
+my @faked = qw/round_mode accuracy precision div_scale/;
+our ($AUTOLOAD, $_lite); # _lite for testsuite
+
+sub AUTOLOAD {
+ my $name = $AUTOLOAD;
+
+ $name =~ s/.*:://; # split package
+ no strict 'refs';
+ foreach my $n (@faked) {
+ if ($n eq $name) {
+ *{"bigint::$name"} =
+ sub {
+ my $self = shift;
+ no strict 'refs';
+ if (defined $_[0]) {
+ return Math::BigInt->$name($_[0]);
+ }
+ return Math::BigInt->$name();
+ };
+ return &$name;
+ }
+ }
+
+ # delayed load of Carp and avoid recursion
+ require Carp;
+ Carp::croak ("Can't call bigint\-\>$name, not a valid method");
+}
+
+sub upgrade {
+ $Math::BigInt::upgrade;
+}
+
+sub _binary_constant {
+ # this takes a binary/hexadecimal/octal constant string and returns it
+ # as string suitable for new. Basically it converts octal to decimal, and
+ # passes every thing else unmodified back.
+ my $string = shift;
+
+ return Math::BigInt->new($string) if $string =~ /^0[bx]/;
+
+ # so it must be an octal constant
+ Math::BigInt->from_oct($string);
+}
+
+sub _float_constant {
+ # this takes a floating point constant string and returns it truncated to
+ # integer. For instance, '4.5' => '4', '1.234e2' => '123' etc
+ my $float = shift;
+
+ # some simple cases first
+ return $float if ($float =~ /^[+-]?[0-9]+$/); # '+123','-1','0' etc
+ return $float
+ if ($float =~ /^[+-]?[0-9]+\.?[eE]\+?[0-9]+$/); # 123e2, 123.e+2
+ return '0' if ($float =~ /^[+-]?[0]*\.[0-9]+$/); # .2, 0.2, -.1
+ if ($float =~ /^[+-]?[0-9]+\.[0-9]*$/) { # 1., 1.23, -1.2 etc
+ $float =~ s/\..*//;
+ return $float;
+ }
+ my ($mis, $miv, $mfv, $es, $ev) = Math::BigInt::_split($float);
+ return $float if !defined $mis; # doesn't look like a number to me
+ my $ec = int($$ev);
+ my $sign = $$mis;
+ $sign = '' if $sign eq '+';
+ if ($$es eq '-') {
+ # ignore fraction part entirely
+ if ($ec >= length($$miv)) { # 123.23E-4
+ return '0';
+ }
+ return $sign . substr($$miv, 0, length($$miv) - $ec); # 1234.45E-2 = 12
+ }
+ # xE+y
+ if ($ec >= length($$mfv)) {
+ $ec -= length($$mfv);
+ return $sign.$$miv.$$mfv if $ec == 0; # 123.45E+2 => 12345
+ return $sign.$$miv.$$mfv.'E'.$ec; # 123.45e+3 => 12345e1
+ }
+ $mfv = substr($$mfv, 0, $ec);
+ $sign.$$miv.$mfv; # 123.45e+1 => 1234
+}
+
+sub unimport {
+ $^H{bigint} = undef; # no longer in effect
+ overload::remove_constant('binary', '', 'float', '', 'integer');
+}
+
+sub in_effect {
+ my $level = shift || 0;
+ my $hinthash = (caller($level))[10];
+ $hinthash->{bigint};
+}
+
+#############################################################################
+# the following two routines are for "use bigint qw/hex oct/;":
+
+use constant LEXICAL => $] > 5.009004;
+
+# Internal function with the same semantics as CORE::hex(). This function is
+# not used directly, but rather by other front-end functions.
+
+sub _hex_core {
+ my $str = shift;
+
+ # Strip off, clean, and parse as much as we can from the beginning.
+
+ my $x;
+ if ($str =~ s/ ^ (0?[xX])? ( [0-9a-fA-F]* ( _ [0-9a-fA-F]+ )* ) //x) {
+ my $chrs = $2;
+ $chrs =~ tr/_//d;
+ $chrs = '0' unless CORE::length $chrs;
+ $x = Math::BigInt -> from_hex($chrs);
+ } else {
+ $x = Math::BigInt -> bzero();
+ }
+
+ # Warn about trailing garbage.
+
+ if (CORE::length($str)) {
+ require Carp;
+ Carp::carp(sprintf("Illegal hexadecimal digit '%s' ignored",
+ substr($str, 0, 1)));
+ }
+
+ return $x;
+}
+
+# Internal function with the same semantics as CORE::oct(). This function is
+# not used directly, but rather by other front-end functions.
+
+sub _oct_core {
+ my $str = shift;
+
+ $str =~ s/^\s*//;
+
+ # Hexadecimal input.
+
+ return _hex_core($str) if $str =~ /^0?[xX]/;
+
+ my $x;
+
+ # Binary input.
+
+ if ($str =~ /^0?[bB]/) {
+
+ # Strip off, clean, and parse as much as we can from the beginning.
+
+ if ($str =~ s/ ^ (0?[bB])? ( [01]* ( _ [01]+ )* ) //x) {
+ my $chrs = $2;
+ $chrs =~ tr/_//d;
+ $chrs = '0' unless CORE::length $chrs;
+ $x = Math::BigInt -> from_bin($chrs);
+ }
+
+ # Warn about trailing garbage.
+
+ if (CORE::length($str)) {
+ require Carp;
+ Carp::carp(sprintf("Illegal binary digit '%s' ignored",
+ substr($str, 0, 1)));
+ }
+
+ return $x;
+ }
+
+ # Octal input. Strip off, clean, and parse as much as we can from the
+ # beginning.
+
+ if ($str =~ s/ ^ ( [0-7]* ( _ [0-7]+ )* ) //x) {
+ my $chrs = $1;
+ $chrs =~ tr/_//d;
+ $chrs = '0' unless CORE::length $chrs;
+ $x = Math::BigInt -> from_oct($chrs);
+ }
+
+ # Warn about trailing garbage. CORE::oct() only warns about 8 and 9.
+
+ if (CORE::length($str)) {
+ my $chr = substr($str, 0, 1);
+ if ($chr eq '8' || $chr eq '9') {
+ require Carp;
+ Carp::carp(sprintf("Illegal octal digit '%s' ignored", $chr));
+ }
+ }
+
+ return $x;
+}
+
+{
+ my $proto = LEXICAL ? '_' : ';$';
+ eval '
+sub hex(' . $proto . ') {' . <<'.';
+ my $str = @_ ? $_[0] : $_;
+ _hex_core($str);
+}
+.
+
+ eval '
+sub oct(' . $proto . ') {' . <<'.';
+ my $str = @_ ? $_[0] : $_;
+ _oct_core($str);
+}
+.
+}
+
+#############################################################################
+# the following two routines are for Perl 5.9.4 or later and are lexical
+
+my ($prev_oct, $prev_hex, $overridden);
+
+if (LEXICAL) { eval <<'.' }
+sub _hex(_) {
+ my $hh = (caller 0)[10];
+ return $prev_hex ? &$prev_hex($_[0]) : CORE::hex($_[0])
+ unless $$hh{bigint}||$$hh{bignum}||$$hh{bigrat};
+ _hex_core($_[0]);
+}
+
+sub _oct(_) {
+ my $hh = (caller 0)[10];
+ return $prev_oct ? &$prev_oct($_[0]) : CORE::oct($_[0])
+ unless $$hh{bigint}||$$hh{bignum}||$$hh{bigrat};
+ _oct_core($_[0]);
+}
+.
+
+sub _override {
+ return if $overridden;
+ $prev_oct = *CORE::GLOBAL::oct{CODE};
+ $prev_hex = *CORE::GLOBAL::hex{CODE};
+ no warnings 'redefine';
+ *CORE::GLOBAL::oct = \&_oct;
+ *CORE::GLOBAL::hex = \&_hex;
+ $overridden++;
+}
+
+sub import {
+ my $self = shift;
+
+ $^H{bigint} = 1; # we are in effect
+
+ # for newer Perls always override hex() and oct() with a lexical version:
+ if (LEXICAL) {
+ _override();
+ }
+ # some defaults
+ my $lib = '';
+ my $lib_kind = 'try';
+
+ my @import = (':constant'); # drive it w/ constant
+ my @a = @_;
+ my $l = scalar @_;
+ my $j = 0;
+ my ($ver, $trace); # version? trace?
+ my ($a, $p); # accuracy, precision
+ for (my $i = 0; $i < $l; $i++, $j++) {
+ if ($_[$i] =~ /^(l|lib|try|only)$/) {
+ # this causes a different low lib to take care...
+ $lib_kind = $1;
+ $lib_kind = 'lib' if $lib_kind eq 'l';
+ $lib = $_[$i + 1] || '';
+ my $s = 2;
+ $s = 1 if @a - $j < 2; # avoid "can not modify non-existent..."
+ splice @a, $j, $s;
+ $j -= $s;
+ $i++;
+ } elsif ($_[$i] =~ /^(a|accuracy)$/) {
+ $a = $_[$i + 1];
+ my $s = 2;
+ $s = 1 if @a - $j < 2; # avoid "can not modify non-existent..."
+ splice @a, $j, $s;
+ $j -= $s;
+ $i++;
+ } elsif ($_[$i] =~ /^(p|precision)$/) {
+ $p = $_[$i + 1];
+ my $s = 2;
+ $s = 1 if @a - $j < 2; # avoid "can not modify non-existent..."
+ splice @a, $j, $s;
+ $j -= $s;
+ $i++;
+ } elsif ($_[$i] =~ /^(v|version)$/) {
+ $ver = 1;
+ splice @a, $j, 1;
+ $j--;
+ } elsif ($_[$i] =~ /^(t|trace)$/) {
+ $trace = 1;
+ splice @a, $j, 1;
+ $j--;
+ } elsif ($_[$i] !~ /^(PI|e|bpi|bexp|hex|oct)\z/) {
+ die ("unknown option $_[$i]");
+ }
+ }
+ my $class;
+ $_lite = 0; # using M::BI::L ?
+ if ($trace) {
+ require Math::BigInt::Trace;
+ $class = 'Math::BigInt::Trace';
+ } else {
+ # see if we can find Math::BigInt::Lite
+ if (!defined $a && !defined $p) { # rounding won't work to well
+ local @INC = @INC;
+ pop @INC if $INC[-1] eq '.';
+ if (eval { require Math::BigInt::Lite; 1 }) {
+ @import = (); # :constant in Lite, not MBI
+ Math::BigInt::Lite->import(':constant');
+ $_lite = 1; # signal okay
+ }
+ }
+ require Math::BigInt if $_lite == 0; # not already loaded?
+ $class = 'Math::BigInt'; # regardless of MBIL or not
+ }
+ push @import, $lib_kind => $lib if $lib ne '';
+ # Math::BigInt::Trace or plain Math::BigInt
+ $class->import(@import);
+
+ bigint->accuracy($a) if defined $a;
+ bigint->precision($p) if defined $p;
+ if ($ver) {
+ print "bigint\t\t\t v$VERSION\n";
+ print "Math::BigInt::Lite\t v$Math::BigInt::Lite::VERSION\n" if $_lite;
+ print "Math::BigInt\t\t v$Math::BigInt::VERSION";
+ my $config = Math::BigInt->config();
+ print " lib => $config->{lib} v$config->{lib_version}\n";
+ exit;
+ }
+ # we take care of floating point constants, since BigFloat isn't available
+ # and BigInt doesn't like them:
+ overload::constant float =>
+ sub {
+ Math::BigInt->new(_float_constant(shift));
+ };
+ # Take care of octal/hexadecimal constants
+ overload::constant binary =>
+ sub {
+ _binary_constant(shift);
+ };
+
+ # if another big* was already loaded:
+ my ($package) = caller();
+
+ no strict 'refs';
+ if (!defined *{"${package}::inf"}) {
+ $self->export_to_level(1, $self, @a); # export inf and NaN, e and PI
+ }
+}
+
+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;
+
+__END__
+
+=pod
+
+=head1 NAME
+
+bigint - Transparent BigInteger support for Perl
+
+=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.10.0 or later
+
+ {
+ no bigint;
+ print 2 ** 256,"\n"; # a normal Perl scalar now
+ }
+
+ # Import into current package:
+ use bigint qw/hex oct/;
+ print hex("0x1234567890123490"),"\n";
+ print oct("01234567890123490"),"\n";
+
+=head1 DESCRIPTION
+
+All operators (including basic math operations) except the range operator C<..>
+are overloaded. Integer constants are created as proper BigInts.
+
+Floating point constants are truncated to integer. All parts and results of
+expressions are also truncated.
+
+Unlike L, this pragma creates integer constants that are only
+limited in their size by the available memory and CPU time.
+
+=head2 use integer vs. use bigint
+
+There is one small difference between C