diff options
Diffstat (limited to 'upstream/archlinux/man3/Math::BigRat.3perl')
| -rw-r--r-- | upstream/archlinux/man3/Math::BigRat.3perl | 884 |
1 files changed, 884 insertions, 0 deletions
diff --git a/upstream/archlinux/man3/Math::BigRat.3perl b/upstream/archlinux/man3/Math::BigRat.3perl new file mode 100644 index 00000000..1ad10107 --- /dev/null +++ b/upstream/archlinux/man3/Math::BigRat.3perl @@ -0,0 +1,884 @@ +.\" -*- 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 "Math::BigRat 3perl" +.TH Math::BigRat 3perl 2024-02-11 "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 +Math::BigRat \- arbitrary size rational number math package +.SH SYNOPSIS +.IX Header "SYNOPSIS" +.Vb 1 +\& use Math::BigRat; +\& +\& my $x = Math::BigRat\->new(\*(Aq3/7\*(Aq); $x += \*(Aq5/9\*(Aq; +\& +\& print $x\->bstr(), "\en"; +\& print $x ** 2, "\en"; +\& +\& my $y = Math::BigRat\->new(\*(Aqinf\*(Aq); +\& print "$y ", ($y\->is_inf ? \*(Aqis\*(Aq : \*(Aqis not\*(Aq), " infinity\en"; +\& +\& my $z = Math::BigRat\->new(144); $z\->bsqrt(); +.Ve +.SH DESCRIPTION +.IX Header "DESCRIPTION" +Math::BigRat complements Math::BigInt and Math::BigFloat by providing support +for arbitrary big rational numbers. +.SS "MATH LIBRARY" +.IX Subsection "MATH LIBRARY" +You can change the underlying module that does the low-level +math operations by using: +.PP +.Vb 1 +\& use Math::BigRat try => \*(AqGMP\*(Aq; +.Ve +.PP +Note: This needs Math::BigInt::GMP installed. +.PP +The following would first try to find Math::BigInt::Foo, then +Math::BigInt::Bar, and when this also fails, revert to Math::BigInt::Calc: +.PP +.Vb 1 +\& use Math::BigRat try => \*(AqFoo,Math::BigInt::Bar\*(Aq; +.Ve +.PP +If you want to get warned when the fallback occurs, replace "try" with "lib": +.PP +.Vb 1 +\& use Math::BigRat lib => \*(AqFoo,Math::BigInt::Bar\*(Aq; +.Ve +.PP +If you want the code to die instead, replace "try" with "only": +.PP +.Vb 1 +\& use Math::BigRat only => \*(AqFoo,Math::BigInt::Bar\*(Aq; +.Ve +.SH METHODS +.IX Header "METHODS" +Any methods not listed here are derived from Math::BigFloat (or +Math::BigInt), so make sure you check these two modules for further +information. +.IP \fBnew()\fR 4 +.IX Item "new()" +.Vb 1 +\& $x = Math::BigRat\->new(\*(Aq1/3\*(Aq); +.Ve +.Sp +Create a new Math::BigRat object. Input can come in various forms: +.Sp +.Vb 9 +\& $x = Math::BigRat\->new(123); # scalars +\& $x = Math::BigRat\->new(\*(Aqinf\*(Aq); # infinity +\& $x = Math::BigRat\->new(\*(Aq123.3\*(Aq); # float +\& $x = Math::BigRat\->new(\*(Aq1/3\*(Aq); # simple string +\& $x = Math::BigRat\->new(\*(Aq1 / 3\*(Aq); # spaced +\& $x = Math::BigRat\->new(\*(Aq1 / 0.1\*(Aq); # w/ floats +\& $x = Math::BigRat\->new(Math::BigInt\->new(3)); # BigInt +\& $x = Math::BigRat\->new(Math::BigFloat\->new(\*(Aq3.1\*(Aq)); # BigFloat +\& $x = Math::BigRat\->new(Math::BigInt::Lite\->new(\*(Aq2\*(Aq)); # BigLite +\& +\& # You can also give D and N as different objects: +\& $x = Math::BigRat\->new( +\& Math::BigInt\->new(\-123), +\& Math::BigInt\->new(7), +\& ); # => \-123/7 +.Ve +.IP \fBnumerator()\fR 4 +.IX Item "numerator()" +.Vb 1 +\& $n = $x\->numerator(); +.Ve +.Sp +Returns a copy of the numerator (the part above the line) as signed BigInt. +.IP \fBdenominator()\fR 4 +.IX Item "denominator()" +.Vb 1 +\& $d = $x\->denominator(); +.Ve +.Sp +Returns a copy of the denominator (the part under the line) as positive BigInt. +.IP \fBparts()\fR 4 +.IX Item "parts()" +.Vb 1 +\& ($n, $d) = $x\->parts(); +.Ve +.Sp +Return a list consisting of (signed) numerator and (unsigned) denominator as +BigInts. +.IP \fBdparts()\fR 4 +.IX Item "dparts()" +Returns the integer part and the fraction part. +.IP \fBfparts()\fR 4 +.IX Item "fparts()" +Returns the smallest possible numerator and denominator so that the numerator +divided by the denominator gives back the original value. For finite numbers, +both values are integers. Mnemonic: fraction. +.IP \fBnumify()\fR 4 +.IX Item "numify()" +.Vb 1 +\& my $y = $x\->numify(); +.Ve +.Sp +Returns the object as a scalar. This will lose some data if the object +cannot be represented by a normal Perl scalar (integer or float), so +use "\fBas_int()\fR" or "\fBas_float()\fR" instead. +.Sp +This routine is automatically used whenever a scalar is required: +.Sp +.Vb 3 +\& my $x = Math::BigRat\->new(\*(Aq3/1\*(Aq); +\& @array = (0, 1, 2, 3); +\& $y = $array[$x]; # set $y to 3 +.Ve +.IP \fBas_int()\fR 4 +.IX Item "as_int()" +.PD 0 +.IP \fBas_number()\fR 4 +.IX Item "as_number()" +.PD +.Vb 2 +\& $x = Math::BigRat\->new(\*(Aq13/7\*(Aq); +\& print $x\->as_int(), "\en"; # \*(Aq1\*(Aq +.Ve +.Sp +Returns a copy of the object as BigInt, truncated to an integer. +.Sp +\&\f(CWas_number()\fR is an alias for \f(CWas_int()\fR. +.IP \fBas_float()\fR 4 +.IX Item "as_float()" +.Vb 2 +\& $x = Math::BigRat\->new(\*(Aq13/7\*(Aq); +\& print $x\->as_float(), "\en"; # \*(Aq1\*(Aq +\& +\& $x = Math::BigRat\->new(\*(Aq2/3\*(Aq); +\& print $x\->as_float(5), "\en"; # \*(Aq0.66667\*(Aq +.Ve +.Sp +Returns a copy of the object as BigFloat, preserving the +accuracy as wanted, or the default of 40 digits. +.Sp +This method was added in v0.22 of Math::BigRat (April 2008). +.IP \fBas_hex()\fR 4 +.IX Item "as_hex()" +.Vb 2 +\& $x = Math::BigRat\->new(\*(Aq13\*(Aq); +\& print $x\->as_hex(), "\en"; # \*(Aq0xd\*(Aq +.Ve +.Sp +Returns the BigRat as hexadecimal string. Works only for integers. +.IP \fBas_bin()\fR 4 +.IX Item "as_bin()" +.Vb 2 +\& $x = Math::BigRat\->new(\*(Aq13\*(Aq); +\& print $x\->as_bin(), "\en"; # \*(Aq0x1101\*(Aq +.Ve +.Sp +Returns the BigRat as binary string. Works only for integers. +.IP \fBas_oct()\fR 4 +.IX Item "as_oct()" +.Vb 2 +\& $x = Math::BigRat\->new(\*(Aq13\*(Aq); +\& print $x\->as_oct(), "\en"; # \*(Aq015\*(Aq +.Ve +.Sp +Returns the BigRat as octal string. Works only for integers. +.IP \fBfrom_hex()\fR 4 +.IX Item "from_hex()" +.Vb 1 +\& my $h = Math::BigRat\->from_hex(\*(Aq0x10\*(Aq); +.Ve +.Sp +Create a BigRat from a hexadecimal number in string form. +.IP \fBfrom_oct()\fR 4 +.IX Item "from_oct()" +.Vb 1 +\& my $o = Math::BigRat\->from_oct(\*(Aq020\*(Aq); +.Ve +.Sp +Create a BigRat from an octal number in string form. +.IP \fBfrom_bin()\fR 4 +.IX Item "from_bin()" +.Vb 1 +\& my $b = Math::BigRat\->from_bin(\*(Aq0b10000000\*(Aq); +.Ve +.Sp +Create a BigRat from an binary number in string form. +.IP \fBbnan()\fR 4 +.IX Item "bnan()" +.Vb 1 +\& $x = Math::BigRat\->bnan(); +.Ve +.Sp +Creates a new BigRat object representing NaN (Not A Number). +If used on an object, it will set it to NaN: +.Sp +.Vb 1 +\& $x\->bnan(); +.Ve +.IP \fBbzero()\fR 4 +.IX Item "bzero()" +.Vb 1 +\& $x = Math::BigRat\->bzero(); +.Ve +.Sp +Creates a new BigRat object representing zero. +If used on an object, it will set it to zero: +.Sp +.Vb 1 +\& $x\->bzero(); +.Ve +.IP \fBbinf()\fR 4 +.IX Item "binf()" +.Vb 1 +\& $x = Math::BigRat\->binf($sign); +.Ve +.Sp +Creates a new BigRat object representing infinity. The optional argument is +either '\-' or '+', indicating whether you want infinity or minus infinity. +If used on an object, it will set it to infinity: +.Sp +.Vb 2 +\& $x\->binf(); +\& $x\->binf(\*(Aq\-\*(Aq); +.Ve +.IP \fBbone()\fR 4 +.IX Item "bone()" +.Vb 1 +\& $x = Math::BigRat\->bone($sign); +.Ve +.Sp +Creates a new BigRat object representing one. The optional argument is +either '\-' or '+', indicating whether you want one or minus one. +If used on an object, it will set it to one: +.Sp +.Vb 2 +\& $x\->bone(); # +1 +\& $x\->bone(\*(Aq\-\*(Aq); # \-1 +.Ve +.IP \fBlength()\fR 4 +.IX Item "length()" +.Vb 1 +\& $len = $x\->length(); +.Ve +.Sp +Return the length of \f(CW$x\fR in digits for integer values. +.IP \fBdigit()\fR 4 +.IX Item "digit()" +.Vb 2 +\& print Math::BigRat\->new(\*(Aq123/1\*(Aq)\->digit(1); # 1 +\& print Math::BigRat\->new(\*(Aq123/1\*(Aq)\->digit(\-1); # 3 +.Ve +.Sp +Return the N'ths digit from X when X is an integer value. +.IP \fBbnorm()\fR 4 +.IX Item "bnorm()" +.Vb 1 +\& $x\->bnorm(); +.Ve +.Sp +Reduce the number to the shortest form. This routine is called +automatically whenever it is needed. +.IP \fBbfac()\fR 4 +.IX Item "bfac()" +.Vb 1 +\& $x\->bfac(); +.Ve +.Sp +Calculates the factorial of \f(CW$x\fR. For instance: +.Sp +.Vb 2 +\& print Math::BigRat\->new(\*(Aq3/1\*(Aq)\->bfac(), "\en"; # 1*2*3 +\& print Math::BigRat\->new(\*(Aq5/1\*(Aq)\->bfac(), "\en"; # 1*2*3*4*5 +.Ve +.Sp +Works currently only for integers. +.IP \fBbround()\fR/\fBround()\fR/\fBbfround()\fR 4 +.IX Item "bround()/round()/bfround()" +Are not yet implemented. +.IP \fBbmod()\fR 4 +.IX Item "bmod()" +.Vb 1 +\& $x\->bmod($y); +.Ve +.Sp +Returns \f(CW$x\fR modulo \f(CW$y\fR. When \f(CW$x\fR is finite, and \f(CW$y\fR is finite and non-zero, the +result is identical to the remainder after floored division (F\-division). If, +in addition, both \f(CW$x\fR and \f(CW$y\fR are integers, the result is identical to the result +from Perl's % operator. +.IP \fBbmodinv()\fR 4 +.IX Item "bmodinv()" +.Vb 1 +\& $x\->bmodinv($mod); # modular multiplicative inverse +.Ve +.Sp +Returns the multiplicative inverse of \f(CW$x\fR modulo \f(CW$mod\fR. If +.Sp +.Vb 1 +\& $y = $x \-> copy() \-> bmodinv($mod) +.Ve +.Sp +then \f(CW$y\fR is the number closest to zero, and with the same sign as \f(CW$mod\fR, +satisfying +.Sp +.Vb 1 +\& ($x * $y) % $mod = 1 % $mod +.Ve +.Sp +If \f(CW$x\fR and \f(CW$y\fR are non-zero, they must be relative primes, i.e., +\&\f(CW\*(C`bgcd($y, $mod)==1\*(C'\fR. '\f(CW\*(C`NaN\*(C'\fR' is returned when no modular multiplicative +inverse exists. +.IP \fBbmodpow()\fR 4 +.IX Item "bmodpow()" +.Vb 2 +\& $num\->bmodpow($exp,$mod); # modular exponentiation +\& # ($num**$exp % $mod) +.Ve +.Sp +Returns the value of \f(CW$num\fR taken to the power \f(CW$exp\fR in the modulus +\&\f(CW$mod\fR using binary exponentiation. \f(CW\*(C`bmodpow\*(C'\fR is far superior to +writing +.Sp +.Vb 1 +\& $num ** $exp % $mod +.Ve +.Sp +because it is much faster \- it reduces internal variables into +the modulus whenever possible, so it operates on smaller numbers. +.Sp +\&\f(CW\*(C`bmodpow\*(C'\fR also supports negative exponents. +.Sp +.Vb 1 +\& bmodpow($num, \-1, $mod) +.Ve +.Sp +is exactly equivalent to +.Sp +.Vb 1 +\& bmodinv($num, $mod) +.Ve +.IP \fBbneg()\fR 4 +.IX Item "bneg()" +.Vb 1 +\& $x\->bneg(); +.Ve +.Sp +Used to negate the object in-place. +.IP \fBis_one()\fR 4 +.IX Item "is_one()" +.Vb 1 +\& print "$x is 1\en" if $x\->is_one(); +.Ve +.Sp +Return true if \f(CW$x\fR is exactly one, otherwise false. +.IP \fBis_zero()\fR 4 +.IX Item "is_zero()" +.Vb 1 +\& print "$x is 0\en" if $x\->is_zero(); +.Ve +.Sp +Return true if \f(CW$x\fR is exactly zero, otherwise false. +.IP \fBis_pos()\fR/\fBis_positive()\fR 4 +.IX Item "is_pos()/is_positive()" +.Vb 1 +\& print "$x is >= 0\en" if $x\->is_positive(); +.Ve +.Sp +Return true if \f(CW$x\fR is positive (greater than or equal to zero), otherwise +false. Please note that '+inf' is also positive, while 'NaN' and '\-inf' aren't. +.Sp +\&\f(CWis_positive()\fR is an alias for \f(CWis_pos()\fR. +.IP \fBis_neg()\fR/\fBis_negative()\fR 4 +.IX Item "is_neg()/is_negative()" +.Vb 1 +\& print "$x is < 0\en" if $x\->is_negative(); +.Ve +.Sp +Return true if \f(CW$x\fR is negative (smaller than zero), otherwise false. Please +note that '\-inf' is also negative, while 'NaN' and '+inf' aren't. +.Sp +\&\f(CWis_negative()\fR is an alias for \f(CWis_neg()\fR. +.IP \fBis_int()\fR 4 +.IX Item "is_int()" +.Vb 1 +\& print "$x is an integer\en" if $x\->is_int(); +.Ve +.Sp +Return true if \f(CW$x\fR has a denominator of 1 (e.g. no fraction parts), otherwise +false. Please note that '\-inf', 'inf' and 'NaN' aren't integer. +.IP \fBis_odd()\fR 4 +.IX Item "is_odd()" +.Vb 1 +\& print "$x is odd\en" if $x\->is_odd(); +.Ve +.Sp +Return true if \f(CW$x\fR is odd, otherwise false. +.IP \fBis_even()\fR 4 +.IX Item "is_even()" +.Vb 1 +\& print "$x is even\en" if $x\->is_even(); +.Ve +.Sp +Return true if \f(CW$x\fR is even, otherwise false. +.IP \fBbceil()\fR 4 +.IX Item "bceil()" +.Vb 1 +\& $x\->bceil(); +.Ve +.Sp +Set \f(CW$x\fR to the next bigger integer value (e.g. truncate the number to integer +and then increment it by one). +.IP \fBbfloor()\fR 4 +.IX Item "bfloor()" +.Vb 1 +\& $x\->bfloor(); +.Ve +.Sp +Truncate \f(CW$x\fR to an integer value. +.IP \fBbint()\fR 4 +.IX Item "bint()" +.Vb 1 +\& $x\->bint(); +.Ve +.Sp +Round \f(CW$x\fR towards zero. +.IP \fBbsqrt()\fR 4 +.IX Item "bsqrt()" +.Vb 1 +\& $x\->bsqrt(); +.Ve +.Sp +Calculate the square root of \f(CW$x\fR. +.IP \fBbroot()\fR 4 +.IX Item "broot()" +.Vb 1 +\& $x\->broot($n); +.Ve +.Sp +Calculate the N'th root of \f(CW$x\fR. +.IP \fBbadd()\fR 4 +.IX Item "badd()" +.Vb 1 +\& $x\->badd($y); +.Ve +.Sp +Adds \f(CW$y\fR to \f(CW$x\fR and returns the result. +.IP \fBbmul()\fR 4 +.IX Item "bmul()" +.Vb 1 +\& $x\->bmul($y); +.Ve +.Sp +Multiplies \f(CW$y\fR to \f(CW$x\fR and returns the result. +.IP \fBbsub()\fR 4 +.IX Item "bsub()" +.Vb 1 +\& $x\->bsub($y); +.Ve +.Sp +Subtracts \f(CW$y\fR from \f(CW$x\fR and returns the result. +.IP \fBbdiv()\fR 4 +.IX Item "bdiv()" +.Vb 2 +\& $q = $x\->bdiv($y); +\& ($q, $r) = $x\->bdiv($y); +.Ve +.Sp +In scalar context, divides \f(CW$x\fR by \f(CW$y\fR and returns the result. In list context, +does floored division (F\-division), returning an integer \f(CW$q\fR and a remainder \f(CW$r\fR +so that \f(CW$x\fR = \f(CW$q\fR * \f(CW$y\fR + \f(CW$r\fR. The remainer (modulo) is equal to what is returned +by \f(CW\*(C`$x\->bmod($y)\*(C'\fR. +.IP \fBbinv()\fR 4 +.IX Item "binv()" +.Vb 1 +\& $x\->binv(); +.Ve +.Sp +Inverse of \f(CW$x\fR. +.IP \fBbdec()\fR 4 +.IX Item "bdec()" +.Vb 1 +\& $x\->bdec(); +.Ve +.Sp +Decrements \f(CW$x\fR by 1 and returns the result. +.IP \fBbinc()\fR 4 +.IX Item "binc()" +.Vb 1 +\& $x\->binc(); +.Ve +.Sp +Increments \f(CW$x\fR by 1 and returns the result. +.IP \fBcopy()\fR 4 +.IX Item "copy()" +.Vb 1 +\& my $z = $x\->copy(); +.Ve +.Sp +Makes a deep copy of the object. +.Sp +Please see the documentation in Math::BigInt for further details. +.IP \fBbstr()\fR/\fBbsstr()\fR 4 +.IX Item "bstr()/bsstr()" +.Vb 3 +\& my $x = Math::BigRat\->new(\*(Aq8/4\*(Aq); +\& print $x\->bstr(), "\en"; # prints 1/2 +\& print $x\->bsstr(), "\en"; # prints 1/2 +.Ve +.Sp +Return a string representing this object. +.IP \fBbcmp()\fR 4 +.IX Item "bcmp()" +.Vb 1 +\& $x\->bcmp($y); +.Ve +.Sp +Compares \f(CW$x\fR with \f(CW$y\fR and takes the sign into account. +Returns \-1, 0, 1 or undef. +.IP \fBbacmp()\fR 4 +.IX Item "bacmp()" +.Vb 1 +\& $x\->bacmp($y); +.Ve +.Sp +Compares \f(CW$x\fR with \f(CW$y\fR while ignoring their sign. Returns \-1, 0, 1 or undef. +.IP \fBbeq()\fR 4 +.IX Item "beq()" +.Vb 1 +\& $x \-> beq($y); +.Ve +.Sp +Returns true if and only if \f(CW$x\fR is equal to \f(CW$y\fR, and false otherwise. +.IP \fBbne()\fR 4 +.IX Item "bne()" +.Vb 1 +\& $x \-> bne($y); +.Ve +.Sp +Returns true if and only if \f(CW$x\fR is not equal to \f(CW$y\fR, and false otherwise. +.IP \fBblt()\fR 4 +.IX Item "blt()" +.Vb 1 +\& $x \-> blt($y); +.Ve +.Sp +Returns true if and only if \f(CW$x\fR is equal to \f(CW$y\fR, and false otherwise. +.IP \fBble()\fR 4 +.IX Item "ble()" +.Vb 1 +\& $x \-> ble($y); +.Ve +.Sp +Returns true if and only if \f(CW$x\fR is less than or equal to \f(CW$y\fR, and false +otherwise. +.IP \fBbgt()\fR 4 +.IX Item "bgt()" +.Vb 1 +\& $x \-> bgt($y); +.Ve +.Sp +Returns true if and only if \f(CW$x\fR is greater than \f(CW$y\fR, and false otherwise. +.IP \fBbge()\fR 4 +.IX Item "bge()" +.Vb 1 +\& $x \-> bge($y); +.Ve +.Sp +Returns true if and only if \f(CW$x\fR is greater than or equal to \f(CW$y\fR, and false +otherwise. +.IP \fBblsft()\fR/\fBbrsft()\fR 4 +.IX Item "blsft()/brsft()" +Used to shift numbers left/right. +.Sp +Please see the documentation in Math::BigInt for further details. +.IP \fBband()\fR 4 +.IX Item "band()" +.Vb 1 +\& $x\->band($y); # bitwise and +.Ve +.IP \fBbior()\fR 4 +.IX Item "bior()" +.Vb 1 +\& $x\->bior($y); # bitwise inclusive or +.Ve +.IP \fBbxor()\fR 4 +.IX Item "bxor()" +.Vb 1 +\& $x\->bxor($y); # bitwise exclusive or +.Ve +.IP \fBbnot()\fR 4 +.IX Item "bnot()" +.Vb 1 +\& $x\->bnot(); # bitwise not (two\*(Aqs complement) +.Ve +.IP \fBbpow()\fR 4 +.IX Item "bpow()" +.Vb 1 +\& $x\->bpow($y); +.Ve +.Sp +Compute \f(CW$x\fR ** \f(CW$y\fR. +.Sp +Please see the documentation in Math::BigInt for further details. +.IP \fBblog()\fR 4 +.IX Item "blog()" +.Vb 1 +\& $x\->blog($base, $accuracy); # logarithm of x to the base $base +.Ve +.Sp +If \f(CW$base\fR is not defined, Euler's number (e) is used: +.Sp +.Vb 1 +\& print $x\->blog(undef, 100); # log(x) to 100 digits +.Ve +.IP \fBbexp()\fR 4 +.IX Item "bexp()" +.Vb 1 +\& $x\->bexp($accuracy); # calculate e ** X +.Ve +.Sp +Calculates two integers A and B so that A/B is equal to \f(CW\*(C`e ** $x\*(C'\fR, where \f(CW\*(C`e\*(C'\fR is +Euler's number. +.Sp +This method was added in v0.20 of Math::BigRat (May 2007). +.Sp +See also \f(CWblog()\fR. +.IP \fBbnok()\fR 4 +.IX Item "bnok()" +.Vb 1 +\& $x\->bnok($y); # x over y (binomial coefficient n over k) +.Ve +.Sp +Calculates the binomial coefficient n over k, also called the "choose" +function. The result is equivalent to: +.Sp +.Vb 3 +\& ( n ) n! +\& | \- | = \-\-\-\-\-\-\- +\& ( k ) k!(n\-k)! +.Ve +.Sp +This method was added in v0.20 of Math::BigRat (May 2007). +.IP \fBconfig()\fR 4 +.IX Item "config()" +.Vb 2 +\& Math::BigRat\->config("trap_nan" => 1); # set +\& $accu = Math::BigRat\->config("accuracy"); # get +.Ve +.Sp +Set or get configuration parameter values. Read-only parameters are marked as +RO. Read-write parameters are marked as RW. The following parameters are +supported. +.Sp +.Vb 10 +\& Parameter RO/RW Description +\& Example +\& ============================================================ +\& lib RO Name of the math backend library +\& Math::BigInt::Calc +\& lib_version RO Version of the math backend library +\& 0.30 +\& class RO The class of config you just called +\& Math::BigRat +\& version RO version number of the class you used +\& 0.10 +\& upgrade RW To which class numbers are upgraded +\& undef +\& downgrade RW To which class numbers are downgraded +\& undef +\& precision RW Global precision +\& undef +\& accuracy RW Global accuracy +\& undef +\& round_mode RW Global round mode +\& even +\& div_scale RW Fallback accuracy for div, sqrt etc. +\& 40 +\& trap_nan RW Trap NaNs +\& undef +\& trap_inf RW Trap +inf/\-inf +\& undef +.Ve +.SH "NUMERIC LITERALS" +.IX Header "NUMERIC LITERALS" +After \f(CW\*(C`use Math::BigRat \*(Aq:constant\*(Aq\*(C'\fR all numeric literals in the given scope +are converted to \f(CW\*(C`Math::BigRat\*(C'\fR objects. This conversion happens at compile +time. Every non-integer is convert to a NaN. +.PP +For example, +.PP +.Vb 1 +\& perl \-MMath::BigRat=:constant \-le \*(Aqprint 2**150\*(Aq +.Ve +.PP +prints the exact value of \f(CW\*(C`2**150\*(C'\fR. Note that without conversion of constants +to objects the expression \f(CW\*(C`2**150\*(C'\fR is calculated using Perl scalars, which +leads to an inaccurate result. +.PP +Please note that strings are not affected, so that +.PP +.Vb 1 +\& use Math::BigRat qw/:constant/; +\& +\& $x = "1234567890123456789012345678901234567890" +\& + "123456789123456789"; +.Ve +.PP +does give you what you expect. You need an explicit Math::BigRat\->\fBnew()\fR around +at least one of the operands. You should also quote large constants to prevent +loss of precision: +.PP +.Vb 1 +\& use Math::BigRat; +\& +\& $x = Math::BigRat\->new("1234567889123456789123456789123456789"); +.Ve +.PP +Without the quotes Perl first converts the large number to a floating point +constant at compile time, and then converts the result to a Math::BigRat object +at run time, which results in an inaccurate result. +.SS "Hexadecimal, octal, and binary floating point literals" +.IX Subsection "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. Below are some examples of +different ways to write the number decimal 314. +.PP +Hexadecimal floating point literals: +.PP +.Vb 3 +\& 0x1.3ap+8 0X1.3AP+8 +\& 0x1.3ap8 0X1.3AP8 +\& 0x13a0p\-4 0X13A0P\-4 +.Ve +.PP +Octal floating point literals (with "0" prefix): +.PP +.Vb 3 +\& 01.164p+8 01.164P+8 +\& 01.164p8 01.164P8 +\& 011640p\-4 011640P\-4 +.Ve +.PP +Octal floating point literals (with "0o" prefix) (requires v5.34.0): +.PP +.Vb 3 +\& 0o1.164p+8 0O1.164P+8 +\& 0o1.164p8 0O1.164P8 +\& 0o11640p\-4 0O11640P\-4 +.Ve +.PP +Binary floating point literals: +.PP +.Vb 3 +\& 0b1.0011101p+8 0B1.0011101P+8 +\& 0b1.0011101p8 0B1.0011101P8 +\& 0b10011101000p\-2 0B10011101000P\-2 +.Ve +.SH BUGS +.IX Header "BUGS" +Please report any bugs or feature requests to +\&\f(CW\*(C`bug\-math\-bigrat at rt.cpan.org\*(C'\fR, or through the web interface at +<https://rt.cpan.org/Ticket/Create.html?Queue=Math\-BigRat> +(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 Math::BigRat +.Ve +.PP +You can also look for information at: +.IP \(bu 4 +GitHub +.Sp +<https://github.com/pjacklam/p5\-Math\-BigRat> +.IP \(bu 4 +RT: CPAN's request tracker +.Sp +<https://rt.cpan.org/Dist/Display.html?Name=Math\-BigRat> +.IP \(bu 4 +MetaCPAN +.Sp +<https://metacpan.org/release/Math\-BigRat> +.IP \(bu 4 +CPAN Testers Matrix +.Sp +<http://matrix.cpantesters.org/?dist=Math\-BigRat> +.IP \(bu 4 +CPAN Ratings +.Sp +<https://cpanratings.perl.org/dist/Math\-BigRat> +.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" +bigrat, Math::BigFloat and Math::BigInt as well as the backends +Math::BigInt::FastCalc, Math::BigInt::GMP, and Math::BigInt::Pari. +.SH AUTHORS +.IX Header "AUTHORS" +.IP \(bu 4 +Tels <http://bloodgate.com/> 2001\-2009. +.IP \(bu 4 +Maintained by Peter John Acklam <pjacklam@gmail.com> 2011\- |