Adding upstream version 4.22.0.upstream/4.22.0

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 617 insertions, 0 deletions

diff --git a/upstream/debian-unstable/man3/bignum.3perl b/upstream/debian-unstable/man3/bignum.3perl
new file mode 100644
index 00000000..0f9cc5ef
--- /dev/null
+++ b/upstream/debian-unstable/man3/bignum.3perl
@@ -0,0 +1,617 @@
+.\" -*- mode: troff; coding: utf-8 -*-
+.\" Automatically generated by Pod::Man 5.01 (Pod::Simple 3.43)
+.\"
+.\" Standard preamble:
+.\" ========================================================================
+.de Sp \" Vertical space (when we can't use .PP)
+.if t .sp .5v
+.if n .sp
+..
+.de Vb \" Begin verbatim text
+.ft CW
+.nf
+.ne \\$1
+..
+.de Ve \" End verbatim text
+.ft R
+.fi
+..
+.\" \*(C` and \*(C' are quotes in nroff, nothing in troff, for use with C<>.
+.ie n \{\
+.    ds C` ""
+.    ds C' ""
+'br\}
+.el\{\
+.    ds C`
+.    ds C'
+'br\}
+.\"
+.\" Escape single quotes in literal strings from groff's Unicode transform.
+.ie \n(.g .ds Aq \(aq
+.el       .ds Aq '
+.\"
+.\" If the F register is >0, we'll generate index entries on stderr for
+.\" titles (.TH), headers (.SH), subsections (.SS), items (.Ip), and index
+.\" entries marked with X<> in POD.  Of course, you'll have to process the
+.\" output yourself in some meaningful fashion.
+.\"
+.\" Avoid warning from groff about undefined register 'F'.
+.de IX
+..
+.nr rF 0
+.if \n(.g .if rF .nr rF 1
+.if (\n(rF:(\n(.g==0)) \{\
+.    if \nF \{\
+.        de IX
+.        tm Index:\\$1\t\\n%\t"\\$2"
+..
+.        if !\nF==2 \{\
+.            nr % 0
+.            nr F 2
+.        \}
+.    \}
+.\}
+.rr rF
+.\" ========================================================================
+.\"
+.IX Title "bignum 3perl"
+.TH bignum 3perl 2024-01-12 "perl v5.38.2" "Perl Programmers Reference Guide"
+.\" For nroff, turn off justification.  Always turn off hyphenation; it makes
+.\" way too many mistakes in technical documents.
+.if n .ad l
+.nh
+.SH NAME
+bignum \- transparent big number support for Perl
+.SH SYNOPSIS
+.IX Header "SYNOPSIS"
+.Vb 1
+\&    use bignum;
+\&
+\&    $x = 2 + 4.5;                       # Math::BigFloat 6.5
+\&    print 2 ** 512 * 0.1;               # Math::BigFloat 134...09.6
+\&    print 2 ** 512;                     # Math::BigInt 134...096
+\&    print inf + 42;                     # Math::BigInt inf
+\&    print NaN * 7;                      # Math::BigInt NaN
+\&    print hex("0x1234567890123490");    # Perl v5.10.0 or later
+\&
+\&    {
+\&        no bignum;
+\&        print 2 ** 256;                 # a normal Perl scalar now
+\&    }
+\&
+\&    # for older Perls, import into current package:
+\&    use bignum qw/hex oct/;
+\&    print hex("0x1234567890123490");
+\&    print oct("01234567890123490");
+.Ve
+.SH DESCRIPTION
+.IX Header "DESCRIPTION"
+.SS "Literal numeric constants"
+.IX Subsection "Literal numeric constants"
+By default, every literal integer becomes a Math::BigInt object, and literal
+non-integer becomes a Math::BigFloat object. Whether a numeric literal is
+considered an integer or non-integers depends only on the value of the constant,
+not on how it is represented. For instance, the constants 3.14e2 and 0x1.3ap8
+become Math::BigInt objects, because they both represent the integer value
+decimal 314.
+.PP
+The default \f(CW\*(C`use bignum;\*(C'\fR is equivalent to
+.PP
+.Vb 1
+\&    use bignum downgrade => "Math::BigInt", upgrade => "Math::BigFloat";
+.Ve
+.PP
+The classes used for integers and non-integers can be set at compile time with
+the \f(CW\*(C`downgrade\*(C'\fR and \f(CW\*(C`upgrade\*(C'\fR options, for example
+.PP
+.Vb 2
+\&    # use Math::BigInt for integers and Math::BigRat for non\-integers
+\&    use bignum upgrade => "Math::BigRat";
+.Ve
+.PP
+Note that disabling downgrading and upgrading does not affect how numeric
+literals are converted to objects
+.PP
+.Vb 4
+\&    # disable both downgrading and upgrading
+\&    use bignum downgrade => undef, upgrade => undef;
+\&    $x = 2.4;       # becomes 2.4 as a Math::BigFloat
+\&    $y = 2;         # becomes 2 as a Math::BigInt
+.Ve
+.SS "Upgrading and downgrading"
+.IX Subsection "Upgrading and downgrading"
+By default, when the result of a computation is an integer, an Inf, or a NaN,
+the result is downgraded even when all the operands are instances of the upgrade
+class.
+.PP
+.Vb 4
+\&    use bignum;
+\&    $x = 2.4;       # becomes 2.4 as a Math::BigFloat
+\&    $y = 1.2;       # becomes 1.2 as a Math::BigFloat
+\&    $z = $x / $y;   # becomes 2 as a Math::BigInt due to downgrading
+.Ve
+.PP
+Equivalently, by default, when the result of a computation is a finite
+non-integer, the result is upgraded even when all the operands are instances of
+the downgrade class.
+.PP
+.Vb 4
+\&    use bignum;
+\&    $x = 7;         # becomes 7 as a Math::BigInt
+\&    $y = 2;         # becomes 2 as a Math::BigInt
+\&    $z = $x / $y;   # becomes 3.5 as a Math::BigFloat due to upgrading
+.Ve
+.PP
+The classes used for downgrading and upgrading can be set at runtime with the
+"\fBdowngrade()\fR" and "\fBupgrade()\fR" methods, but see "CAVEATS" below.
+.PP
+The upgrade and downgrade classes don't have to be Math::BigInt and
+Math::BigFloat. For example, to use Math::BigRat as the upgrade class, use
+.PP
+.Vb 3
+\&    use bignum upgrade => "Math::BigRat";
+\&    $x = 2;         # becomes 2 as a Math::BigInt
+\&    $y = 3.6;       # becomes 18/5 as a Math::BigRat
+.Ve
+.PP
+The upgrade and downgrade classes can be modified at runtime
+.PP
+.Vb 4
+\&    use bignum;
+\&    $x = 3;         # becomes 3 as a Math::BigInt
+\&    $y = 2;         # becomes 2 as a Math::BigInt
+\&    $z = $x / $y;   # becomes 1.5 as a Math::BigFlaot
+\&
+\&    bignum \-> upgrade("Math::BigRat");
+\&    $w = $x / $y;   # becomes 3/2 as a Math::BigRat
+.Ve
+.PP
+Disabling downgrading doesn't change the fact that literal constant integers are
+converted to the downgrade class, it only prevents downgrading as a result of a
+computation. E.g.,
+.PP
+.Vb 5
+\&    use bignum downgrade => undef;
+\&    $x = 2;         # becomes 2 as a Math::BigInt
+\&    $y = 2.4;       # becomes 2.4 as a Math::BigFloat
+\&    $z = 1.2;       # becomes 1.2 as a Math::BigFloat
+\&    $w = $x / $y;   # becomes 2 as a Math::BigFloat due to no downgrading
+.Ve
+.PP
+If you want all numeric literals, both integers and non-integers, to become
+Math::BigFloat objects, use the bigfloat pragma.
+.PP
+Equivalently, disabling upgrading doesn't change the fact that literal constant
+non-integers are converted to the upgrade class, it only prevents upgrading as a
+result of a computation. E.g.,
+.PP
+.Vb 5
+\&    use bignum upgrade => undef;
+\&    $x = 2.5;       # becomes 2.5 as a Math::BigFloat
+\&    $y = 7;         # becomes 7 as a Math::BigInt
+\&    $z = 2;         # becomes 2 as a Math::BigInt
+\&    $w = $x / $y;   # becomes 3 as a Math::BigInt due to no upgrading
+.Ve
+.PP
+If you want all numeric literals, both integers and non-integers, to become
+Math::BigInt objects, use the bigint pragma.
+.PP
+You can even do
+.PP
+.Vb 1
+\&    use bignum upgrade => "Math::BigRat", upgrade => undef;
+.Ve
+.PP
+which converts all integer literals to Math::BigInt objects and all non-integer
+literals to Math::BigRat objects. However, when the result of a computation
+involving two Math::BigInt objects results in a non-integer (e.g., 7/2), the
+result will be truncted to a Math::BigInt rather than being upgraded to a
+Math::BigRat, since upgrading is disabled.
+.SS Overloading
+.IX Subsection "Overloading"
+Since all numeric literals become objects, you can call all the usual methods
+from Math::BigInt and Math::BigFloat on them. This even works to some extent on
+expressions:
+.PP
+.Vb 3
+\&    perl \-Mbignum \-le \*(Aq$x = 1234; print $x\->bdec()\*(Aq
+\&    perl \-Mbignum \-le \*(Aqprint 1234\->copy()\->binc();\*(Aq
+\&    perl \-Mbignum \-le \*(Aqprint 1234\->copy()\->binc()\->badd(6);\*(Aq
+.Ve
+.SS Options
+.IX Subsection "Options"
+\&\f(CW\*(C`bignum\*(C'\fR recognizes some options that can be passed while loading it via via
+\&\f(CW\*(C`use\*(C'\fR. The following options exist:
+.IP "a or accuracy" 4
+.IX Item "a or accuracy"
+This sets the accuracy for all math operations. The argument must be greater
+than or equal to zero. See Math::BigInt's \fBbround()\fR method for details.
+.Sp
+.Vb 1
+\&    perl \-Mbignum=a,50 \-le \*(Aqprint sqrt(20)\*(Aq
+.Ve
+.Sp
+Note that setting precision and accuracy at the same time is not possible.
+.IP "p or precision" 4
+.IX Item "p or precision"
+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 means round to integer.
+See Math::BigInt's \fBbfround()\fR method for details.
+.Sp
+.Vb 1
+\&    perl \-Mbignum=p,\-50 \-le \*(Aqprint sqrt(20)\*(Aq
+.Ve
+.Sp
+Note that setting precision and accuracy at the same time is not possible.
+.IP "l, lib, try, or only" 4
+.IX Item "l, lib, try, or only"
+Load a different math lib, see "Math Library".
+.Sp
+.Vb 4
+\&    perl \-Mbignum=l,GMP \-e \*(Aqprint 2 ** 512\*(Aq
+\&    perl \-Mbignum=lib,GMP \-e \*(Aqprint 2 ** 512\*(Aq
+\&    perl \-Mbignum=try,GMP \-e \*(Aqprint 2 ** 512\*(Aq
+\&    perl \-Mbignum=only,GMP \-e \*(Aqprint 2 ** 512\*(Aq
+.Ve
+.IP hex 4
+.IX Item "hex"
+Override the built-in \fBhex()\fR method with a version that can handle big numbers.
+This overrides it by exporting it to the current package. Under Perl v5.10.0 and
+higher, this is not so necessary, as \fBhex()\fR is lexically overridden in the
+current scope whenever the \f(CW\*(C`bignum\*(C'\fR pragma is active.
+.IP oct 4
+.IX Item "oct"
+Override the built-in \fBoct()\fR method with a version that can handle big numbers.
+This overrides it by exporting it to the current package. Under Perl v5.10.0 and
+higher, this is not so necessary, as \fBoct()\fR is lexically overridden in the
+current scope whenever the \f(CW\*(C`bignum\*(C'\fR pragma is active.
+.IP "v or version" 4
+.IX Item "v or version"
+this prints out the name and version of the modules and then exits.
+.Sp
+.Vb 1
+\&    perl \-Mbignum=v
+.Ve
+.SS "Math Library"
+.IX Subsection "Math Library"
+Math with the numbers is done (by default) by a backend library module called
+Math::BigInt::Calc. The default is equivalent to saying:
+.PP
+.Vb 1
+\&    use bignum lib => \*(AqCalc\*(Aq;
+.Ve
+.PP
+you can change this by using:
+.PP
+.Vb 1
+\&    use bignum lib => \*(AqGMP\*(Aq;
+.Ve
+.PP
+The following would first try to find Math::BigInt::Foo, then Math::BigInt::Bar,
+and if this also fails, revert to Math::BigInt::Calc:
+.PP
+.Vb 1
+\&    use bignum lib => \*(AqFoo,Math::BigInt::Bar\*(Aq;
+.Ve
+.PP
+Using c<lib> warns if none of the specified libraries can be found and
+Math::BigInt and Math::BigFloat fell back to one of the default
+libraries. To suppress this warning, use \f(CW\*(C`try\*(C'\fR instead:
+.PP
+.Vb 1
+\&    use bignum try => \*(AqGMP\*(Aq;
+.Ve
+.PP
+If you want the code to die instead of falling back, use \f(CW\*(C`only\*(C'\fR instead:
+.PP
+.Vb 1
+\&    use bignum only => \*(AqGMP\*(Aq;
+.Ve
+.PP
+Please see respective module documentation for further details.
+.SS "Method calls"
+.IX Subsection "Method calls"
+Since all numbers are now objects, you can use the methods that are part of the
+Math::BigInt and Math::BigFloat API.
+.PP
+But a warning is in order. When using the following to make a copy of a number,
+only a shallow copy will be made.
+.PP
+.Vb 2
+\&    $x = 9; $y = $x;
+\&    $x = $y = 7;
+.Ve
+.PP
+Using the copy or the original with overloaded math is okay, e.g., the following
+work:
+.PP
+.Vb 2
+\&    $x = 9; $y = $x;
+\&    print $x + 1, " ", $y,"\en";     # prints 10 9
+.Ve
+.PP
+but calling any method that modifies the number directly will result in \fBboth\fR
+the original and the copy being destroyed:
+.PP
+.Vb 2
+\&    $x = 9; $y = $x;
+\&    print $x\->badd(1), " ", $y,"\en";        # prints 10 10
+\&
+\&    $x = 9; $y = $x;
+\&    print $x\->binc(1), " ", $y,"\en";        # prints 10 10
+\&
+\&    $x = 9; $y = $x;
+\&    print $x\->bmul(2), " ", $y,"\en";        # prints 18 18
+.Ve
+.PP
+Using methods that do not modify, but test that the contents works:
+.PP
+.Vb 2
+\&    $x = 9; $y = $x;
+\&    $z = 9 if $x\->is_zero();                # works fine
+.Ve
+.PP
+See the documentation about the copy constructor and \f(CW\*(C`=\*(C'\fR in overload, as well
+as the documentation in Math::BigFloat for further details.
+.SS Methods
+.IX Subsection "Methods"
+.IP \fBinf()\fR 4
+.IX Item "inf()"
+A shortcut to return \f(CW\*(C`inf\*(C'\fR as an object. Useful because Perl does not always
+handle bareword \f(CW\*(C`inf\*(C'\fR properly.
+.IP \fBNaN()\fR 4
+.IX Item "NaN()"
+A shortcut to return \f(CW\*(C`NaN\*(C'\fR as an object. Useful because Perl does not always
+handle bareword \f(CW\*(C`NaN\*(C'\fR properly.
+.IP e 4
+.IX Item "e"
+.Vb 1
+\&    # perl \-Mbignum=e \-wle \*(Aqprint e\*(Aq
+.Ve
+.Sp
+Returns Euler's number \f(CW\*(C`e\*(C'\fR, aka \fBexp\fR\|(1) (= 2.7182818284...).
+.IP PI 4
+.IX Item "PI"
+.Vb 1
+\&    # perl \-Mbignum=PI \-wle \*(Aqprint PI\*(Aq
+.Ve
+.Sp
+Returns PI (= 3.1415926532..).
+.IP \fBbexp()\fR 4
+.IX Item "bexp()"
+.Vb 1
+\&    bexp($power, $accuracy);
+.Ve
+.Sp
+Returns Euler's number \f(CW\*(C`e\*(C'\fR raised to the appropriate power, to the wanted
+accuracy.
+.Sp
+Example:
+.Sp
+.Vb 1
+\&    # perl \-Mbignum=bexp \-wle \*(Aqprint bexp(1,80)\*(Aq
+.Ve
+.IP \fBbpi()\fR 4
+.IX Item "bpi()"
+.Vb 1
+\&    bpi($accuracy);
+.Ve
+.Sp
+Returns PI to the wanted accuracy.
+.Sp
+Example:
+.Sp
+.Vb 1
+\&    # perl \-Mbignum=bpi \-wle \*(Aqprint bpi(80)\*(Aq
+.Ve
+.IP \fBaccuracy()\fR 4
+.IX Item "accuracy()"
+Set or get the accuracy.
+.IP \fBprecision()\fR 4
+.IX Item "precision()"
+Set or get the precision.
+.IP \fBround_mode()\fR 4
+.IX Item "round_mode()"
+Set or get the rounding mode.
+.IP \fBdiv_scale()\fR 4
+.IX Item "div_scale()"
+Set or get the division scale.
+.IP \fBupgrade()\fR 4
+.IX Item "upgrade()"
+Set or get the class that the downgrade class upgrades to, if any. Set the
+upgrade class to \f(CW\*(C`undef\*(C'\fR to disable upgrading. See \f(CW\*(C`/CAVEATS\*(C'\fR below.
+.IP \fBdowngrade()\fR 4
+.IX Item "downgrade()"
+Set or get the class that the upgrade class downgrades to, if any. Set the
+downgrade class to \f(CW\*(C`undef\*(C'\fR to disable upgrading. See "CAVEATS" below.
+.IP \fBin_effect()\fR 4
+.IX Item "in_effect()"
+.Vb 1
+\&    use bignum;
+\&
+\&    print "in effect\en" if bignum::in_effect;       # true
+\&    {
+\&        no bignum;
+\&        print "in effect\en" if bignum::in_effect;   # false
+\&    }
+.Ve
+.Sp
+Returns true or false if \f(CW\*(C`bignum\*(C'\fR is in effect in the current scope.
+.Sp
+This method only works on Perl v5.9.4 or later.
+.SH CAVEATS
+.IX Header "CAVEATS"
+.IP "The \fBupgrade()\fR and \fBdowngrade()\fR methods" 4
+.IX Item "The upgrade() and downgrade() methods"
+Note that setting both the upgrade and downgrade classes at runtime with the
+"\fBupgrade()\fR" and "\fBdowngrade()\fR" methods, might not do what you expect:
+.Sp
+.Vb 4
+\&    # Assuming that downgrading and upgrading hasn\*(Aqt been modified so far, so
+\&    # the downgrade and upgrade classes are Math::BigInt and Math::BigFloat,
+\&    # respectively, the following sets the upgrade class to Math::BigRat, i.e.,
+\&    # makes Math::BigInt upgrade to Math::BigRat:
+\&
+\&    bignum \-> upgrade("Math::BigRat");
+\&
+\&    # The following sets the downgrade class to Math::BigInt::Lite, i.e., makes
+\&    # the new upgrade class Math::BigRat downgrade to Math::BigInt::Lite
+\&
+\&    bignum \-> downgrade("Math::BigInt::Lite");
+\&
+\&    # Note that at this point, it is still Math::BigInt, not Math::BigInt::Lite,
+\&    # that upgrades to Math::BigRat, so to get Math::BigInt::Lite to upgrade to
+\&    # Math::BigRat, we need to do the following (again):
+\&
+\&    bignum \-> upgrade("Math::BigRat");
+.Ve
+.Sp
+A simpler way to do this at runtime is to use \fBimport()\fR,
+.Sp
+.Vb 2
+\&    bignum \-> import(upgrade => "Math::BigRat",
+\&                     downgrade => "Math::BigInt::Lite");
+.Ve
+.IP "Hexadecimal, octal, and binary floating point literals" 4
+.IX Item "Hexadecimal, octal, and binary floating point literals"
+Perl (and this module) accepts hexadecimal, octal, and binary floating point
+literals, but use them with care with Perl versions before v5.32.0, because some
+versions of Perl silently give the wrong result.
+.IP "Operator vs literal overloading" 4
+.IX Item "Operator vs literal overloading"
+\&\f(CW\*(C`bigrat\*(C'\fR works by overloading handling of integer and floating point literals,
+converting them to Math::BigRat objects.
+.Sp
+This means that arithmetic involving only string values or string literals are
+performed using Perl's built-in operators.
+.Sp
+For example:
+.Sp
+.Vb 4
+\&    use bigrat;
+\&    my $x = "900000000000000009";
+\&    my $y = "900000000000000007";
+\&    print $x \- $y;
+.Ve
+.Sp
+outputs \f(CW0\fR on default 32\-bit builds, since \f(CW\*(C`bignum\*(C'\fR never sees the string
+literals. To ensure the expression is all treated as \f(CW\*(C`Math::BigFloat\*(C'\fR objects,
+use a literal number in the expression:
+.Sp
+.Vb 1
+\&    print +(0+$x) \- $y;
+.Ve
+.IP Ranges 4
+.IX Item "Ranges"
+Perl does not allow overloading of ranges, so you can neither safely use ranges
+with \f(CW\*(C`bignum\*(C'\fR endpoints, nor is the iterator variable a \f(CW\*(C`Math::BigFloat\*(C'\fR.
+.Sp
+.Vb 7
+\&    use 5.010;
+\&    for my $i (12..13) {
+\&      for my $j (20..21) {
+\&        say $i ** $j;  # produces a floating\-point number,
+\&                       # not an object
+\&      }
+\&    }
+.Ve
+.IP \fBin_effect()\fR 4
+.IX Item "in_effect()"
+This method only works on Perl v5.9.4 or later.
+.IP \fBhex()\fR/\fBoct()\fR 4
+.IX Item "hex()/oct()"
+\&\f(CW\*(C`bignum\*(C'\fR 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
+\&\f(CW\*(C`no bignum\*(C'\fR:
+.Sp
+.Vb 1
+\&    use bignum qw/hex oct/;
+\&
+\&    print hex("0x1234567890123456");
+\&    {
+\&        no bignum;
+\&        print hex("0x1234567890123456");
+\&    }
+.Ve
+.Sp
+The second call to \fBhex()\fR will warn about a non-portable constant.
+.Sp
+Compare this to:
+.Sp
+.Vb 1
+\&    use bignum;
+\&
+\&    # will warn only under Perl older than v5.9.4
+\&    print hex("0x1234567890123456");
+.Ve
+.SH EXAMPLES
+.IX Header "EXAMPLES"
+Some cool command line examples to impress the Python crowd ;)
+.PP
+.Vb 10
+\&    perl \-Mbignum \-le \*(Aqprint sqrt(33)\*(Aq
+\&    perl \-Mbignum \-le \*(Aqprint 2**255\*(Aq
+\&    perl \-Mbignum \-le \*(Aqprint 4.5+2**255\*(Aq
+\&    perl \-Mbignum \-le \*(Aqprint 3/7 + 5/7 + 8/3\*(Aq
+\&    perl \-Mbignum \-le \*(Aqprint 123\->is_odd()\*(Aq
+\&    perl \-Mbignum \-le \*(Aqprint log(2)\*(Aq
+\&    perl \-Mbignum \-le \*(Aqprint exp(1)\*(Aq
+\&    perl \-Mbignum \-le \*(Aqprint 2 ** 0.5\*(Aq
+\&    perl \-Mbignum=a,65 \-le \*(Aqprint 2 ** 0.2\*(Aq
+\&    perl \-Mbignum=l,GMP \-le \*(Aqprint 7 ** 7777\*(Aq
+.Ve
+.SH BUGS
+.IX Header "BUGS"
+Please report any bugs or feature requests to
+\&\f(CW\*(C`bug\-bignum at rt.cpan.org\*(C'\fR, or through the web interface at
+<https://rt.cpan.org/Ticket/Create.html?Queue=bignum> (requires login).
+We will be notified, and then you'll automatically be notified of
+progress on your bug as I make changes.
+.SH SUPPORT
+.IX Header "SUPPORT"
+You can find documentation for this module with the perldoc command.
+.PP
+.Vb 1
+\&    perldoc bignum
+.Ve
+.PP
+You can also look for information at:
+.IP \(bu 4
+GitHub
+.Sp
+<https://github.com/pjacklam/p5\-bignum>
+.IP \(bu 4
+RT: CPAN's request tracker
+.Sp
+<https://rt.cpan.org/Dist/Display.html?Name=bignum>
+.IP \(bu 4
+MetaCPAN
+.Sp
+<https://metacpan.org/release/bignum>
+.IP \(bu 4
+CPAN Testers Matrix
+.Sp
+<http://matrix.cpantesters.org/?dist=bignum>
+.IP \(bu 4
+CPAN Ratings
+.Sp
+<https://cpanratings.perl.org/dist/bignum>
+.SH LICENSE
+.IX Header "LICENSE"
+This program is free software; you may redistribute it and/or modify it under
+the same terms as Perl itself.
+.SH "SEE ALSO"
+.IX Header "SEE ALSO"
+bigint and bigrat.
+.PP
+Math::BigInt, Math::BigFloat, Math::BigRat and Math::Big as well as
+Math::BigInt::FastCalc, Math::BigInt::Pari and Math::BigInt::GMP.
+.SH AUTHORS
+.IX Header "AUTHORS"
+.IP \(bu 4
+(C) by Tels <http://bloodgate.com/> in early 2002 \- 2007.
+.IP \(bu 4
+Maintained by Peter John Acklam <pjacklam@gmail.com>, 2014\-.