Debian Codegraph @

upstream/opensuse-tumbleweed/man3/bignum.3pm

raw
1 .\" -*- mode: troff; coding: utf-8 -*-
2 .\" Automatically generated by Pod::Man v6.0.2 (Pod::Simple 3.45)
3 .\"
4 .\" Standard preamble:
5 .\" ========================================================================
6 .de Sp \" Vertical space (when we can't use .PP)
7 .if t .sp .5v
8 .if n .sp
9 ..
10 .de Vb \" Begin verbatim text
11 .ft CW
12 .nf
13 .ne \\$1
14 ..
15 .de Ve \" End verbatim text
16 .ft R
17 .fi
18 ..
19 .\" \*(C` and \*(C' are quotes in nroff, nothing in troff, for use with C<>.
20 .ie n \{\
21 . ds C` ""
22 . ds C' ""
23 'br\}
24 .el\{\
25 . ds C`
26 . ds C'
27 'br\}
28 .\"
29 .\" Escape single quotes in literal strings from groff's Unicode transform.
30 .ie \n(.g .ds Aq \(aq
31 .el .ds Aq '
32 .\"
33 .\" If the F register is >0, we'll generate index entries on stderr for
34 .\" titles (.TH), headers (.SH), subsections (.SS), items (.Ip), and index
35 .\" entries marked with X<> in POD. Of course, you'll have to process the
36 .\" output yourself in some meaningful fashion.
37 .\"
38 .\" Avoid warning from groff about undefined register 'F'.
39 .de IX
40 ..
41 .nr rF 0
42 .if \n(.g .if rF .nr rF 1
43 .if (\n(rF:(\n(.g==0)) \{\
44 . if \nF \{\
45 . de IX
46 . tm Index:\\$1\t\\n%\t"\\$2"
47 ..
48 . if !\nF==2 \{\
49 . nr % 0
50 . nr F 2
51 . \}
52 . \}
53 .\}
54 .rr rF
55 .\"
56 .\" Required to disable full justification in groff 1.23.0.
57 .if n .ds AD l
58 .\" ========================================================================
59 .\"
60 .IX Title "bignum 3pm"
61 .TH bignum 3pm 2026-03-09 "perl v5.42.1" "Perl Programmers Reference Guide"
62 .\" For nroff, turn off justification. Always turn off hyphenation; it makes
63 .\" way too many mistakes in technical documents.
64 .if n .ad l
65 .nh
66 .SH NAME
67 bignum \- transparent big number support for Perl
68 .SH SYNOPSIS
69 .IX Header "SYNOPSIS"
70 .Vb 1
71 \& use bignum;
72 \&
73 \& $x = 2 + 4.5; # Math::BigFloat 6.5
74 \& print 2 ** 512 * 0.1; # Math::BigFloat 134...09.6
75 \& print 2 ** 512; # Math::BigInt 134...096
76 \& print inf + 42; # Math::BigInt inf
77 \& print NaN * 7; # Math::BigInt NaN
78 \& print hex("0x1234567890123490"); # Perl v5.10.0 or later
79 \&
80 \& {
81 \& no bignum;
82 \& print 2 ** 256; # a normal Perl scalar now
83 \& }
84 \&
85 \& # for older Perls, import into current package:
86 \& use bignum qw/hex oct/;
87 \& print hex("0x1234567890123490");
88 \& print oct("01234567890123490");
89 .Ve
90 .SH DESCRIPTION
91 .IX Header "DESCRIPTION"
92 .SS "Literal numeric constants"
93 .IX Subsection "Literal numeric constants"
94 By default, every literal integer becomes a Math::BigInt object, and literal
95 non\-integer becomes a Math::BigFloat object. Whether a numeric literal is
96 considered an integer or non\-integers depends only on the value of the constant,
97 not on how it is represented. For instance, the constants 3.14e2 and 0x1.3ap8
98 become Math::BigInt objects, because they both represent the integer value
99 decimal 314.
100 .PP
101 The default \f(CW\*(C`use bignum;\*(C'\fR is equivalent to
102 .PP
103 .Vb 1
104 \& use bignum downgrade => "Math::BigInt", upgrade => "Math::BigFloat";
105 .Ve
106 .PP
107 The classes used for integers and non\-integers can be set at compile time with
108 the \f(CW\*(C`downgrade\*(C'\fR and \f(CW\*(C`upgrade\*(C'\fR options, for example
109 .PP
110 .Vb 2
111 \& # use Math::BigInt for integers and Math::BigRat for non\-integers
112 \& use bignum upgrade => "Math::BigRat";
113 .Ve
114 .PP
115 Note that disabling downgrading and upgrading does not affect how numeric
116 literals are converted to objects
117 .PP
118 .Vb 4
119 \& # disable both downgrading and upgrading
120 \& use bignum downgrade => undef, upgrade => undef;
121 \& $x = 2.4; # becomes 2.4 as a Math::BigFloat
122 \& $y = 2; # becomes 2 as a Math::BigInt
123 .Ve
124 .SS "Upgrading and downgrading"
125 .IX Subsection "Upgrading and downgrading"
126 By default, when the result of a computation is an integer, an Inf, or a NaN,
127 the result is downgraded even when all the operands are instances of the upgrade
128 class.
129 .PP
130 .Vb 4
131 \& use bignum;
132 \& $x = 2.4; # becomes 2.4 as a Math::BigFloat
133 \& $y = 1.2; # becomes 1.2 as a Math::BigFloat
134 \& $z = $x / $y; # becomes 2 as a Math::BigInt due to downgrading
135 .Ve
136 .PP
137 Equivalently, by default, when the result of a computation is a finite
138 non\-integer, the result is upgraded even when all the operands are instances of
139 the downgrade class.
140 .PP
141 .Vb 4
142 \& use bignum;
143 \& $x = 7; # becomes 7 as a Math::BigInt
144 \& $y = 2; # becomes 2 as a Math::BigInt
145 \& $z = $x / $y; # becomes 3.5 as a Math::BigFloat due to upgrading
146 .Ve
147 .PP
148 The classes used for downgrading and upgrading can be set at runtime with the
149 "\fBdowngrade()\fR" and "\fBupgrade()\fR" methods, but see "CAVEATS" below.
150 .PP
151 The upgrade and downgrade classes don\*(Aqt have to be Math::BigInt and
152 Math::BigFloat. For example, to use Math::BigRat as the upgrade class, use
153 .PP
154 .Vb 3
155 \& use bignum upgrade => "Math::BigRat";
156 \& $x = 2; # becomes 2 as a Math::BigInt
157 \& $y = 3.6; # becomes 18/5 as a Math::BigRat
158 .Ve
159 .PP
160 The upgrade and downgrade classes can be modified at runtime
161 .PP
162 .Vb 4
163 \& use bignum;
164 \& $x = 3; # becomes 3 as a Math::BigInt
165 \& $y = 2; # becomes 2 as a Math::BigInt
166 \& $z = $x / $y; # becomes 1.5 as a Math::BigFlaot
167 \&
168 \& bignum \-> upgrade("Math::BigRat");
169 \& $w = $x / $y; # becomes 3/2 as a Math::BigRat
170 .Ve
171 .PP
172 Disabling downgrading doesn\*(Aqt change the fact that literal constant integers are
173 converted to the downgrade class, it only prevents downgrading as a result of a
174 computation. E.g.,
175 .PP
176 .Vb 5
177 \& use bignum downgrade => undef;
178 \& $x = 2; # becomes 2 as a Math::BigInt
179 \& $y = 2.4; # becomes 2.4 as a Math::BigFloat
180 \& $z = 1.2; # becomes 1.2 as a Math::BigFloat
181 \& $w = $x / $y; # becomes 2 as a Math::BigFloat due to no downgrading
182 .Ve
183 .PP
184 If you want all numeric literals, both integers and non\-integers, to become
185 Math::BigFloat objects, use the bigfloat pragma.
186 .PP
187 Equivalently, disabling upgrading doesn\*(Aqt change the fact that literal constant
188 non\-integers are converted to the upgrade class, it only prevents upgrading as a
189 result of a computation. E.g.,
190 .PP
191 .Vb 5
192 \& use bignum upgrade => undef;
193 \& $x = 2.5; # becomes 2.5 as a Math::BigFloat
194 \& $y = 7; # becomes 7 as a Math::BigInt
195 \& $z = 2; # becomes 2 as a Math::BigInt
196 \& $w = $x / $y; # becomes 3 as a Math::BigInt due to no upgrading
197 .Ve
198 .PP
199 If you want all numeric literals, both integers and non\-integers, to become
200 Math::BigInt objects, use the bigint pragma.
201 .PP
202 You can even do
203 .PP
204 .Vb 1
205 \& use bignum upgrade => "Math::BigRat", upgrade => undef;
206 .Ve
207 .PP
208 which converts all integer literals to Math::BigInt objects and all non\-integer
209 literals to Math::BigRat objects. However, when the result of a computation
210 involving two Math::BigInt objects results in a non\-integer (e.g., 7/2), the
211 result will be truncted to a Math::BigInt rather than being upgraded to a
212 Math::BigRat, since upgrading is disabled.
213 .SS Overloading
214 .IX Subsection "Overloading"
215 Since all numeric literals become objects, you can call all the usual methods
216 from Math::BigInt and Math::BigFloat on them. This even works to some extent on
217 expressions:
218 .PP
219 .Vb 3
220 \& perl \-Mbignum \-le \*(Aq$x = 1234; print $x\->bdec()\*(Aq
221 \& perl \-Mbignum \-le \*(Aqprint 1234\->copy()\->binc();\*(Aq
222 \& perl \-Mbignum \-le \*(Aqprint 1234\->copy()\->binc()\->badd(6);\*(Aq
223 .Ve
224 .SS Options
225 .IX Subsection "Options"
226 \&\f(CW\*(C`bignum\*(C'\fR recognizes some options that can be passed while loading it via via
227 \&\f(CW\*(C`use\*(C'\fR. The following options exist:
228 .IP "a or accuracy" 4
229 .IX Item "a or accuracy"
230 This sets the accuracy for all math operations. The argument must be greater
231 than or equal to zero. See Math::BigInt\*(Aqs \fBbround()\fR method for details.
232 .Sp
233 .Vb 1
234 \& perl \-Mbignum=a,50 \-le \*(Aqprint sqrt(20)\*(Aq
235 .Ve
236 .Sp
237 Note that setting precision and accuracy at the same time is not possible.
238 .IP "p or precision" 4
239 .IX Item "p or precision"
240 This sets the precision for all math operations. The argument can be any
241 integer. Negative values mean a fixed number of digits after the dot, while a
242 positive value rounds to this digit left from the dot. 0 means round to integer.
243 See Math::BigInt\*(Aqs \fBbfround()\fR method for details.
244 .Sp
245 .Vb 1
246 \& perl \-Mbignum=p,\-50 \-le \*(Aqprint sqrt(20)\*(Aq
247 .Ve
248 .Sp
249 Note that setting precision and accuracy at the same time is not possible.
250 .IP "l, lib, try, or only" 4
251 .IX Item "l, lib, try, or only"
252 Load a different math lib, see "Math Library".
253 .Sp
254 .Vb 4
255 \& perl \-Mbignum=l,GMP \-e \*(Aqprint 2 ** 512\*(Aq
256 \& perl \-Mbignum=lib,GMP \-e \*(Aqprint 2 ** 512\*(Aq
257 \& perl \-Mbignum=try,GMP \-e \*(Aqprint 2 ** 512\*(Aq
258 \& perl \-Mbignum=only,GMP \-e \*(Aqprint 2 ** 512\*(Aq
259 .Ve
260 .IP hex 4
261 .IX Item "hex"
262 Override the built\-in \fBhex()\fR method with a version that can handle big numbers.
263 This overrides it by exporting it to the current package. Under Perl v5.10.0 and
264 higher, this is not so necessary, as \fBhex()\fR is lexically overridden in the
265 current scope whenever the \f(CW\*(C`bignum\*(C'\fR pragma is active.
266 .IP oct 4
267 .IX Item "oct"
268 Override the built\-in \fBoct()\fR method with a version that can handle big numbers.
269 This overrides it by exporting it to the current package. Under Perl v5.10.0 and
270 higher, this is not so necessary, as \fBoct()\fR is lexically overridden in the
271 current scope whenever the \f(CW\*(C`bignum\*(C'\fR pragma is active.
272 .IP "v or version" 4
273 .IX Item "v or version"
274 this prints out the name and version of the modules and then exits.
275 .Sp
276 .Vb 1
277 \& perl \-Mbignum=v
278 .Ve
279 .SS "Math Library"
280 .IX Subsection "Math Library"
281 Math with the numbers is done (by default) by a backend library module called
282 Math::BigInt::Calc. The default is equivalent to saying:
283 .PP
284 .Vb 1
285 \& use bignum lib => \*(AqCalc\*(Aq;
286 .Ve
287 .PP
288 you can change this by using:
289 .PP
290 .Vb 1
291 \& use bignum lib => \*(AqGMP\*(Aq;
292 .Ve
293 .PP
294 The following would first try to find Math::BigInt::Foo, then Math::BigInt::Bar,
295 and if this also fails, revert to Math::BigInt::Calc:
296 .PP
297 .Vb 1
298 \& use bignum lib => \*(AqFoo,Math::BigInt::Bar\*(Aq;
299 .Ve
300 .PP
301 Using c<lib> warns if none of the specified libraries can be found and
302 Math::BigInt and Math::BigFloat fell back to one of the default
303 libraries. To suppress this warning, use \f(CW\*(C`try\*(C'\fR instead:
304 .PP
305 .Vb 1
306 \& use bignum try => \*(AqGMP\*(Aq;
307 .Ve
308 .PP
309 If you want the code to die instead of falling back, use \f(CW\*(C`only\*(C'\fR instead:
310 .PP
311 .Vb 1
312 \& use bignum only => \*(AqGMP\*(Aq;
313 .Ve
314 .PP
315 Please see respective module documentation for further details.
316 .SS "Method calls"
317 .IX Subsection "Method calls"
318 Since all numbers are now objects, you can use the methods that are part of the
319 Math::BigInt and Math::BigFloat API.
320 .PP
321 But a warning is in order. When using the following to make a copy of a number,
322 only a shallow copy will be made.
323 .PP
324 .Vb 2
325 \& $x = 9; $y = $x;
326 \& $x = $y = 7;
327 .Ve
328 .PP
329 Using the copy or the original with overloaded math is okay, e.g., the following
330 work:
331 .PP
332 .Vb 2
333 \& $x = 9; $y = $x;
334 \& print $x + 1, " ", $y,"\en"; # prints 10 9
335 .Ve
336 .PP
337 but calling any method that modifies the number directly will result in \fBboth\fR
338 the original and the copy being destroyed:
339 .PP
340 .Vb 2
341 \& $x = 9; $y = $x;
342 \& print $x\->badd(1), " ", $y,"\en"; # prints 10 10
343 \&
344 \& $x = 9; $y = $x;
345 \& print $x\->binc(1), " ", $y,"\en"; # prints 10 10
346 \&
347 \& $x = 9; $y = $x;
348 \& print $x\->bmul(2), " ", $y,"\en"; # prints 18 18
349 .Ve
350 .PP
351 Using methods that do not modify, but test that the contents works:
352 .PP
353 .Vb 2
354 \& $x = 9; $y = $x;
355 \& $z = 9 if $x\->is_zero(); # works fine
356 .Ve
357 .PP
358 See the documentation about the copy constructor and \f(CW\*(C`=\*(C'\fR in overload, as well
359 as the documentation in Math::BigFloat for further details.
360 .SS Methods
361 .IX Subsection "Methods"
362 .IP \fBinf()\fR 4
363 .IX Item "inf()"
364 A shortcut to return \f(CW\*(C`inf\*(C'\fR as an object. Useful because Perl does not always
365 handle bareword \f(CW\*(C`inf\*(C'\fR properly.
366 .IP \fBNaN()\fR 4
367 .IX Item "NaN()"
368 A shortcut to return \f(CW\*(C`NaN\*(C'\fR as an object. Useful because Perl does not always
369 handle bareword \f(CW\*(C`NaN\*(C'\fR properly.
370 .IP e 4
371 .IX Item "e"
372 .Vb 1
373 \& # perl \-Mbignum=e \-wle \*(Aqprint e\*(Aq
374 .Ve
375 .Sp
376 Returns Euler\*(Aqs number \f(CW\*(C`e\*(C'\fR, aka \fBexp\fR\|(1) (= 2.7182818284...).
377 .IP PI 4
378 .IX Item "PI"
379 .Vb 1
380 \& # perl \-Mbignum=PI \-wle \*(Aqprint PI\*(Aq
381 .Ve
382 .Sp
383 Returns PI (= 3.1415926532..).
384 .IP \fBbexp()\fR 4
385 .IX Item "bexp()"
386 .Vb 1
387 \& bexp($power, $accuracy);
388 .Ve
389 .Sp
390 Returns Euler\*(Aqs number \f(CW\*(C`e\*(C'\fR raised to the appropriate power, to the wanted
391 accuracy.
392 .Sp
393 Example:
394 .Sp
395 .Vb 1
396 \& # perl \-Mbignum=bexp \-wle \*(Aqprint bexp(1,80)\*(Aq
397 .Ve
398 .IP \fBbpi()\fR 4
399 .IX Item "bpi()"
400 .Vb 1
401 \& bpi($accuracy);
402 .Ve
403 .Sp
404 Returns PI to the wanted accuracy.
405 .Sp
406 Example:
407 .Sp
408 .Vb 1
409 \& # perl \-Mbignum=bpi \-wle \*(Aqprint bpi(80)\*(Aq
410 .Ve
411 .IP \fBaccuracy()\fR 4
412 .IX Item "accuracy()"
413 Set or get the accuracy.
414 .IP \fBprecision()\fR 4
415 .IX Item "precision()"
416 Set or get the precision.
417 .IP \fBround_mode()\fR 4
418 .IX Item "round_mode()"
419 Set or get the rounding mode.
420 .IP \fBdiv_scale()\fR 4
421 .IX Item "div_scale()"
422 Set or get the division scale.
423 .IP \fBupgrade()\fR 4
424 .IX Item "upgrade()"
425 Set or get the class that the downgrade class upgrades to, if any. Set the
426 upgrade class to \f(CW\*(C`undef\*(C'\fR to disable upgrading. See \f(CW\*(C`/CAVEATS\*(C'\fR below.
427 .IP \fBdowngrade()\fR 4
428 .IX Item "downgrade()"
429 Set or get the class that the upgrade class downgrades to, if any. Set the
430 downgrade class to \f(CW\*(C`undef\*(C'\fR to disable upgrading. See "CAVEATS" below.
431 .IP \fBin_effect()\fR 4
432 .IX Item "in_effect()"
433 .Vb 1
434 \& use bignum;
435 \&
436 \& print "in effect\en" if bignum::in_effect; # true
437 \& {
438 \& no bignum;
439 \& print "in effect\en" if bignum::in_effect; # false
440 \& }
441 .Ve
442 .Sp
443 Returns true or false if \f(CW\*(C`bignum\*(C'\fR is in effect in the current scope.
444 .Sp
445 This method only works on Perl v5.9.4 or later.
446 .SH CAVEATS
447 .IX Header "CAVEATS"
448 .IP "The \fBupgrade()\fR and \fBdowngrade()\fR methods" 4
449 .IX Item "The upgrade() and downgrade() methods"
450 Note that setting both the upgrade and downgrade classes at runtime with the
451 "\fBupgrade()\fR" and "\fBdowngrade()\fR" methods, might not do what you expect:
452 .Sp
453 .Vb 4
454 \& # Assuming that downgrading and upgrading hasn\*(Aqt been modified so far, so
455 \& # the downgrade and upgrade classes are Math::BigInt and Math::BigFloat,
456 \& # respectively, the following sets the upgrade class to Math::BigRat, i.e.,
457 \& # makes Math::BigInt upgrade to Math::BigRat:
458 \&
459 \& bignum \-> upgrade("Math::BigRat");
460 \&
461 \& # The following sets the downgrade class to Math::BigInt::Lite, i.e., makes
462 \& # the new upgrade class Math::BigRat downgrade to Math::BigInt::Lite
463 \&
464 \& bignum \-> downgrade("Math::BigInt::Lite");
465 \&
466 \& # Note that at this point, it is still Math::BigInt, not Math::BigInt::Lite,
467 \& # that upgrades to Math::BigRat, so to get Math::BigInt::Lite to upgrade to
468 \& # Math::BigRat, we need to do the following (again):
469 \&
470 \& bignum \-> upgrade("Math::BigRat");
471 .Ve
472 .Sp
473 A simpler way to do this at runtime is to use \fBimport()\fR,
474 .Sp
475 .Vb 2
476 \& bignum \-> import(upgrade => "Math::BigRat",
477 \& downgrade => "Math::BigInt::Lite");
478 .Ve
479 .IP "Hexadecimal, octal, and binary floating point literals" 4
480 .IX Item "Hexadecimal, octal, and binary floating point literals"
481 Perl (and this module) accepts hexadecimal, octal, and binary floating point
482 literals, but use them with care with Perl versions before v5.32.0, because some
483 versions of Perl silently give the wrong result.
484 .IP "Operator vs literal overloading" 4
485 .IX Item "Operator vs literal overloading"
486 \&\f(CW\*(C`bigrat\*(C'\fR works by overloading handling of integer and floating point literals,
487 converting them to Math::BigRat objects.
488 .Sp
489 This means that arithmetic involving only string values or string literals are
490 performed using Perl\*(Aqs built\-in operators.
491 .Sp
492 For example:
493 .Sp
494 .Vb 4
495 \& use bigrat;
496 \& my $x = "900000000000000009";
497 \& my $y = "900000000000000007";
498 \& print $x \- $y;
499 .Ve
500 .Sp
501 outputs \f(CW0\fR on default 32\-bit builds, since \f(CW\*(C`bignum\*(C'\fR never sees the string
502 literals. To ensure the expression is all treated as \f(CW\*(C`Math::BigFloat\*(C'\fR objects,
503 use a literal number in the expression:
504 .Sp
505 .Vb 1
506 \& print +(0+$x) \- $y;
507 .Ve
508 .IP Ranges 4
509 .IX Item "Ranges"
510 Perl does not allow overloading of ranges, so you can neither safely use ranges
511 with \f(CW\*(C`bignum\*(C'\fR endpoints, nor is the iterator variable a \f(CW\*(C`Math::BigFloat\*(C'\fR.
512 .Sp
513 .Vb 7
514 \& use 5.010;
515 \& for my $i (12..13) {
516 \& for my $j (20..21) {
517 \& say $i ** $j; # produces a floating\-point number,
518 \& # not an object
519 \& }
520 \& }
521 .Ve
522 .IP \fBin_effect()\fR 4
523 .IX Item "in_effect()"
524 This method only works on Perl v5.9.4 or later.
525 .IP \fBhex()\fR/\fBoct()\fR 4
526 .IX Item "hex()/oct()"
527 \&\f(CW\*(C`bignum\*(C'\fR overrides these routines with versions that can also handle big
528 integer values. Under Perl prior to version v5.9.4, however, this will not
529 happen unless you specifically ask for it with the two import tags "hex" and
530 "oct" \- and then it will be global and cannot be disabled inside a scope with
531 \&\f(CW\*(C`no bignum\*(C'\fR:
532 .Sp
533 .Vb 1
534 \& use bignum qw/hex oct/;
535 \&
536 \& print hex("0x1234567890123456");
537 \& {
538 \& no bignum;
539 \& print hex("0x1234567890123456");
540 \& }
541 .Ve
542 .Sp
543 The second call to \fBhex()\fR will warn about a non\-portable constant.
544 .Sp
545 Compare this to:
546 .Sp
547 .Vb 1
548 \& use bignum;
549 \&
550 \& # will warn only under Perl older than v5.9.4
551 \& print hex("0x1234567890123456");
552 .Ve
553 .SH EXAMPLES
554 .IX Header "EXAMPLES"
555 Some cool command line examples to impress the Python crowd ;)
556 .PP
557 .Vb 10
558 \& perl \-Mbignum \-le \*(Aqprint sqrt(33)\*(Aq
559 \& perl \-Mbignum \-le \*(Aqprint 2**255\*(Aq
560 \& perl \-Mbignum \-le \*(Aqprint 4.5+2**255\*(Aq
561 \& perl \-Mbignum \-le \*(Aqprint 3/7 + 5/7 + 8/3\*(Aq
562 \& perl \-Mbignum \-le \*(Aqprint 123\->is_odd()\*(Aq
563 \& perl \-Mbignum \-le \*(Aqprint log(2)\*(Aq
564 \& perl \-Mbignum \-le \*(Aqprint exp(1)\*(Aq
565 \& perl \-Mbignum \-le \*(Aqprint 2 ** 0.5\*(Aq
566 \& perl \-Mbignum=a,65 \-le \*(Aqprint 2 ** 0.2\*(Aq
567 \& perl \-Mbignum=l,GMP \-le \*(Aqprint 7 ** 7777\*(Aq
568 .Ve
569 .SH BUGS
570 .IX Header "BUGS"
571 Please report any bugs or feature requests to
572 \&\f(CW\*(C`bug\-bignum at rt.cpan.org\*(C'\fR, or through the web interface at
573 <https://rt.cpan.org/Ticket/Create.html?Queue=bignum> (requires login).
574 We will be notified, and then you\*(Aqll automatically be notified of
575 progress on your bug as I make changes.
576 .SH SUPPORT
577 .IX Header "SUPPORT"
578 You can find documentation for this module with the perldoc command.
579 .PP
580 .Vb 1
581 \& perldoc bignum
582 .Ve
583 .PP
584 You can also look for information at:
585 .IP \(bu 4
586 GitHub
587 .Sp
588 <https://github.com/pjacklam/p5\-bignum>
589 .IP \(bu 4
590 RT: CPAN\*(Aqs request tracker
591 .Sp
592 <https://rt.cpan.org/Dist/Display.html?Name=bignum>
593 .IP \(bu 4
594 MetaCPAN
595 .Sp
596 <https://metacpan.org/release/bignum>
597 .IP \(bu 4
598 CPAN Testers Matrix
599 .Sp
600 <http://matrix.cpantesters.org/?dist=bignum>
601 .SH LICENSE
602 .IX Header "LICENSE"
603 This program is free software; you may redistribute it and/or modify it under
604 the same terms as Perl itself.
605 .SH "SEE ALSO"
606 .IX Header "SEE ALSO"
607 bigint and bigrat.
608 .PP
609 Math::BigInt, Math::BigFloat, Math::BigRat and Math::Big as well as
610 Math::BigInt::FastCalc, Math::BigInt::Pari and Math::BigInt::GMP.
611 .SH AUTHORS
612 .IX Header "AUTHORS"
613 .IP \(bu 4
614 (C) by Tels <http://bloodgate.com/> in early 2002 \- 2007.
615 .IP \(bu 4
616 Maintained by Peter John Acklam <[email protected]>, 2014\-.