NAME

Math::BigNum::Inf - Represents the +/-Infinity value.

VERSION

Version 0.14

SYNOPSIS

use Math::BigNum;
say Math::BigNum->inf;         # => "inf"

my $inf = Math::BigNum::Inf->new;
say $inf->atan;                # => 1.57079632679489661923132169163975

DESCRIPTION

Math::BigNum::Inf is an abstract type that represents +/-Infinity.

SUBROUTINES/METHODS

new

Inf->new                       # => Inf
Inf->new('-')                  # => -Inf

Returns on objects representing the +/-Infinity abstract value.

neg

$x->neg                        # => BigNum
-$x                            # => BigNum

Negative value of $x. Returns abs($x) when $x is negative, otherwise returns -$x.

bneg

$x->bneg                       # => BigNum

Negative value of $x, changing $x in-place.

abs

$x->abs                        # => Inf

Absolute value of $x.

babs

$x->babs                       # => Inf

Sets $x in-place to its absolute value.

copy

$x->copy                       # => Inf

Returns a deep copy of the self object.

mone

$x->mone                       # => BigNum

Returns a BigNum object which stores the value -1.

zero

$x->zero                       # => BigNum

Returns a BigNum object which stores the value 0.

one

$x->one                        # => BigNum

Returns a BigNum object which stores the value +1.

bmone

$x->bmone                      # => BigNum

Promotes $x to a BigNum object which stores the value -1.

bzero

$x->bzero                      # => BigNum

Promotes $x to a BigNum object which stores the value 0.

bone

$x->bone                       # => BigNum

Promotes $x to a BigNum object which stores the value +1.

nan

$x->nan                        # => Nan

Returns a Nan object, which stores the Not-a-Number value.

bnan

$x->bnan                       # => Nan

Promotes $x to a Nan object.

inf

$x->inf                        # => Inf

Returns an Inf object, which stores the +Infinity value.

ninf

$x->ninf                       # => Inf

Returns an Inf object, which stores the -Infinity value.

binf

$x->binf                       # => Inf

Changes $x in-place to +Infinity.

bninf

$x->bninf                      # => Inf

Changes $x in-place to -Infinity.

add / iadd

$x->add(BigNum)                # => Inf
$x->add(Scalar)                # => Inf
$x->add(Inf)                   # => Inf | Nan

Scalar + Inf                   # => Inf
Inf + BigNum                   # => Inf
Inf + Scalar                   # => Inf
Inf + Inf                      # => Inf | Nan

Addition of $x and $y.

badd / biadd

$x->badd(BigNum)               # => Inf
$x->badd(Scalar)               # => Inf
$x->badd(Inf)                  # => Inf | Nan

Inf += BigNum                  # => Inf
Inf += Scalar                  # => Inf
Inf += Inf                     # => Inf | Nan

Addition of $x and $y, changing $x in-place.

sub / isub

$x->sub(BigNum)                # => Inf
$x->sub(Scalar)                # => Inf
$x->sub(Inf)                   # => Inf | Nan

Scalar - Inf                   # => Inf
Inf - BigNum                   # => Inf
Inf - Scalar                   # => Inf
Inf - Inf                      # => Inf | Nan

Subtraction of $x and $y.

bsub / bisub

$x->bsub(BigNum)               # => Inf
$x->bsub(Scalar)               # => Inf
$x->bsub(Inf)                  # => Inf | Nan

Inf -= BigNum                  # => Inf
Inf -= Scalar                  # => Inf
Inf -= Inf                     # => Inf | Nan

Subtraction of $x and $y, changing $x in-place.

mul / imul

$x->mul(BigNum)                # => Inf | Nan
$x->mul(Scalar)                # => Inf | Nan
$x->mul(Inf)                   # => Inf

Scalar * Inf                   # => Inf | Nan
Inf * BigNum                   # => Inf | Nan
Inf * Scalar                   # => Inf | Nan
Inf * Inf                      # => Inf

Multiplication of $x and $y.

bmul / bimul

$x->bmul(BigNum)               # => Inf | Nan
$x->bmul(Scalar)               # => Inf | Nan
$x->bmul(Inf)                  # => Inf

Inf *= BigNum                  # => Inf | Nan
Inf *= Scalar                  # => Inf | Nan
Inf *= Inf                     # => Inf

Multiplication of $x and $y, changing $x in-place.

div / idiv

$x->div(BigNum)                # => Inf
$x->div(Scalar)                # => Inf
$x->div(Inf)                   # => Nan

Scalar / Inf                   # => BigNum(0)
Inf / BigNum                   # => Inf
Inf / Scalar                   # => Inf
Inf / Inf                      # => Nan

Division of $x and $y.

bdiv / bidiv

$x->bdiv(BigNum)               # => Inf
$x->bdiv(Scalar)               # => Inf
$x->bdiv(Inf)                  # => Nan

Inf /= BigNum                  # => Inf
Inf /= Scalar                  # => Inf
Inf /= Inf                     # => Nan

Division of $x and $y, changing $x in-place.

eq

$x->eq(Inf)                    # => Bool
$x->eq(Nan)                    # => Bool
$x->eq(BigNum)                 # => Bool

$x == $y                       # => Bool

Equality test:

Inf == Inf      # true
Inf == -Inf     # false
Inf == 0        # false
Inf == MaN      # false

ne

$x->ne(Inf)                    # => Bool
$x->ne(Nan)                    # => Bool
$x->ne(BigNum)                 # => Bool

$x != $y                       # => Bool

Inequality test:

Inf != Inf      # false
Inf != -Inf     # true
Inf != 0        # true
Inf != MaN      # true

cmp

$x->cmp(Inf)                   # => Scalar
$x->cmp(BigNum)                # => Scalar
$x->cmp(Nan)                   # => undef

Inf <=> Any                    # => Scalar
Any <=> Inf                    # => Scalar
Inf <=> Nan                    # => undef

Compares $x to $y and returns a positive value when $x is greater than $y, a negative value when $x is lower than $y, or zero when $x and $y are equal.

acmp

$x->acmp(Inf)                  # => Scalar
$x->acmp(BigNum)               # => Scalar
$x->acmp(Nan)                  # => undef

Compares the absolute values of $x and $y.

gt

$x->gt(Any)                    # => Bool
Inf > Any                      # => Bool
Any > Inf                      # => Bool

Returns true if $x is greater than $y.

ge

$x->ge(Any)                    # => Bool
Inf >= Any                     # => Bool
Any >= Inf                     # => Bool

Returns true if $x is greater or equal to $y.

lt

$x->lt(Any)                    # => Bool
Inf < Any                      # => Bool
Any > Inf                      # => Bool

Returns true if $x is less than $y.

le

$x->le(Any)                    # => Bool
Inf <= Any                     # => Bool
Any <= Inf                     # => Bool

Returns true if $x is less than or equal to $y.

min

$x->min(BigNum)                # => Inf | BigNum
$x->min(Inf)                   # => Inf

Returns $x if $x is lower than $y. Returns $y otherwise.

max

$x->max(BigNum)                # => Inf | BigNum
$x->max(Inf)                   # => Inf

Returns $x if $x is greater than $y. Returns $y otherwise.

atan

$x->atan                       # => BigNum

Returns the inverse tangent of $x.

sqr

$x->sqr                        # => Inf

Returns the result of $x**2.

sqrt / isqrt

$x->sqrt           => Inf

Square root of $x.

bsqrt / bisqrt

Square root of $x, changing $x in-place.

pow / ipow

$x->pow(BigNum)                # => Inf | BigNum
$x->pow(Scalar)                # => Inf | BigNum
$x->pow(Inf)                   # => Inf | BigNum

Scalar ** Inf                  # => Inf | BigNum(0)
Inf ** BigNum                  # => Inf | BigNum
Inf ** Scalar                  # => Inf | BigNum

Raises $x to the power $y.

bpow / bipow

$x->bpow(BigNum)               # => Inf | BigNum
$x->bpow(Scalar)               # => Inf | BigNum
$x->bpow(Inf)                  # => Inf | BigNum

Inf **= BigNum                 # => Inf | BigNum
Inf **= Scalar                 # => Inf | BigNum

Same pow(), except that it changes $x in-place.

root / iroot

$x->root(BigNum)               # => BigNum | Inf | Nan
$x->root(Scalar)               # => BigNum | Inf | Nan

Nth root of $x. Same as $x ** (1/$y).

broot / biroot

$x->broot(BigNum)              # => BigNum | Inf | Nan
$x->broot(Scalar)              # => BigNum | Inf | Nan

Nth root of $x, changing $x in-place.

binomial

$x->binomial(BigNum)           # => BigNum | Inf
$x->binomial(Scalar)           # => BigNum | Inf
$x->binomial(Inf)              # => BigNum | Inf

Binomial coefficient of $x and $y.

exp

$x->exp                        # => BigNum | Inf

Returns the following values:

exp(+Inf) = Inf
exp(-Inf) = 0

bexp

$x->bexp                       # => BigNum | Inf

Same as exp(), except that it changes $x in-place.

inv

$x->inv                        # => BigNum

Inverse value of +/-Infinity. Always returns zero.

mod / imod

$x->mod(BigNum)                # => Nan
$x->mod(Inf)                   # => Nan

Scalar % Inf                   # => BigNum | Inf

Returns the remained of $x divided by $y.

bmod / bimod

$x->bmod(Any)                  # => NaN

Sets $x to the reminder of $x divided by <$y>, which is always Nan.

lsft

$x->lsft(BigNum)               # => Inf
$x->lsft(Scalar)               # => Inf
$x->lsft(Inf)                  # => Inf | Nan

Inf << BigNum                  # => Inf
Inf << Scalar                  # => Inf
Inf << Inf                     # => Inf | Nan

Left-shift operation. ($x * (2 ** $y))

blsft

$x->blsft(BigNum)              # => Inf
$x->blsft(Scalar)              # => Inf
$x->blsft(Inf)                 # => Inf | Nan

Inf <<= BigNum                 # => Inf
Inf <<= Scalar                 # => Inf
Inf <<= Inf                    # => Inf | Nan

Left-shift operation, changing $x in-place. ($x * (2 ** $y))

rsft

$x->rsft(BigNum)               # => Inf
$x->rsft(Scalar)               # => Inf

Inf >> BigNum                  # => Inf
Inf >> Scalar                  # => Inf
Inf >> BigNum                  # => Inf

Right-shift operation. ($x / (2 ** $y))

brsft

$x->brsft(BigNum)              # => Inf
$x->brsft(Scalar)              # => Inf

Inf >>= BigNum                 # => Inf
Inf >>= Scalar                 # => Inf

Integer right-shift operation. ($x / (2 ** $y))

cpanm Math::BigNum

perl -MCPAN -e shell
install Math::BigNum