math mechanixs 1.1.0.1

Math Mechanixs is an easy to use general purpose FREE math software program. (FREE registration is required after 60 days). The typical tool for solving mathematical problem has been the calculator. Unfortunately, a calculator can be very limiting. They do not allow the user to record detailed notes regarding their work. Until the graphing calculator, the user could not graph their data either. Math Mechanixs has an integrated Math Editor that allows the you to compute complex functions and expressions while keeping detailed notes on your work. You can save your worksheet and share it with others. Math Mechanixs also includes a comprehensive Function Library with over 170 predefined functions. The Function Library is also extendable by the user and is even more powerful when combined with our unique Function Solver, which provides a quick and easy way to solve any function. Math Mechanixs includes the ability to graph data on your computer s display (in full color). You can save/export the graph data to other applications as well. You can create numerous types of beautiful 2D and 3D graphs from functions or data points. These graphs can be custom labeled by the user. You can also add point labels, zoom, rotate and translate your graphs. Our latest version also includes a calculus utility for performing single, double and triple integration/differentiation. There is also an itegrated context sensitive help system with a number of tutorials in .wmv file format which will significantly reduce the time it takes to learn Math Mechanixs. Users around the world have found Math Mechanixs to be extremely useful and we are sure you will too.

Math Mechanixs is a FREE and easy to use scientific and engineering math software program. (FREE registration is required after 30 days of usage). Math Mechanixs has an integrated Scientific Calculator and Math Editor that allows the you to compute complex functions and expressions while keeping detailed notes on your work. You can save your worksheet and share it with others. Math Mechanixs also includes a comprehensive and extendable function library with over 200 predefined functions. There are 45 advanced statistical functions including a complete set of random number generators following various types of statistical distributions. The function library is also extendable allowing you to create your own functions and categories. The function library is even more powerful when combined with our unique function solver, which provides a quick and easy way to solve any function. Math Mechanixs includes the ability to graph data on your computers display (in full color). You can save and export the graph data to other applications as well. You can create numerous types of beautiful 2D and 3D graphs from functions or data points. You can custom label your graphs, add point labels, zoom, rotate and translate your graphs. There is a root finding utility for finding real and complex roots of polynomial. Math Mechanixs also includes a calculus utility for performing single, double and triple integration and differentiation. There is also an integrated context sensitive help system with numerous tutorials in .wmv file format which will significantly reduce the time it takes to learn Math Mechanixs.

Math::NumberCruncher Perl module contains a collection of useful math-related functions.

SYNOPSIS

It should be noted that as of v4.0, there is now an OO interface to Math::NumberCruncher. For backwards compatibility, however, the previous, functional style will always be supported.

# OO Style

use Math::NumberCruncher;

$ref = Math::NumberCruncher->new();

# From this point on, all of the subroutines shown below will be available # through $ref (i.e., ( $high,$low ) = $ref->Range( @array )). For the sake # of brevity, consult the functional documentation (below) for the use # of specific functions.

# Functional Style

use Math::NumberCruncher;

($high, $low) = Math::NumberCruncher::Range(@array);
$mean = Math::NumberCruncher::Mean(@array);
$median = Math::NumberCruncher::Median(@array [, $decimal_places]);
$odd_median = Math::NumberCruncher::OddMedian(@array);
$mode = Math::NumberCruncher::Mode(@array);
$covariance = Math::NumberCruncher::Covariance(@array1, @array2);
$correlation = Math::NumberCruncher::Correlation(@array1, @array2);
($slope, $y_intercept) = Math::NumberCruncher::BestFit(@array1, @array2 [, $decimal_places]);
$distance = Math::NumberCruncher::Distance($x1,$y1,$z1,$x2,$y2,$z2 [, $decimal_places]);
$distance = Math::NumberCruncher::Distance($x1,$y1,$x1,$x2 [, $decimal_places]);
$distance = Math::NumberCruncher::ManhattanDistance($x1,$y1,$x2,$y2);
$probAll = Math::NumberCruncher::AllOf(0.3,0.25,0.91,0.002);
$probNone = Math::NumberCruncher::NoneOf(0.4,0.5772,0.212);
$probSome = Math::NumberCruncher::SomeOf(0.11,0.56,0.3275);
$factorial = Math::NumberCruncher::Factorial($some_number);
$permutations = Math::NumberCruncher::Permutation($n);
$permutations = Math::NumberCruncher::Permutation($n,$k);
$roll = Math::NumberCruncher::Dice(3,12,4);
$randInt = Math::NumberCruncher::RandInt(10,50);
$randomElement = Math::NumberCruncher::RandomElement(@array);
Math::NumberCruncher::ShuffleArray(@array);
@unique = Math::NumberCruncher::Unique(@array);
@a_only = Math::NumberCruncher::Compare(@a,@b);
@union = Math::NumberCruncher::Union(@a,@b);
@intersection = Math::NumberCruncher::Intersection(@a,@b);
@difference = Math::NumberCruncher::Difference(@a,@b);
$gaussianRand = Math::NumberCruncher::GaussianRand();
$ways = Math::NumberCruncher::Choose($n,$k);
$binomial = Math::NumberCruncher::Binomial($attempts,$successes,$probability);
$gaussianDist = Math::NumberCruncher::GaussianDist($x,$mean,$variance);
$StdDev = Math::NumberCruncher::StandardDeviation(@array [, $decimal_places]);
$variance = Math::NumberCruncher::Variance(@array [, $decimal_places]);
@scores = Math::NumberCruncher::StandardScores(@array [, $decimal_places]);
$confidence = Math::NumberCruncher::SignSignificance($trials,$hits,$probability);
$e = Math::Numbercruncher::EMC2( "m512", "miles" [, $decimal_places] );
$m = Math::NumberCruncher::EMC2( "e987432" "km" [, $decimal_places] );
$force = Math::NumberCruncher::FMA( "m12", "a73.5" [, $decimal_places] );
$mass = Math::NumberCruncher::FMA( "a43", "f1324" [, $decimal_places] );
$acceleration = Math::NumberCruncher::FMA( "f53512", "m356" [, $decimal_places] );
$predicted_value = Math::NubmerCruncher::Predict( $slope, $y_intercept, $proposed_x [, $decimal_places] );
$area = Math::NumberCruncher::TriangleHeron( $a, $b, $c [, $decimal_places] );
$area = Math::NumberCruncher::TriangleHeron( 1,3, 5,7, 8,2 [, $decimal_places] );
$perimeter = Math::NumberCruncher::PolygonPerimeter( $x0,$y0, $x1,$y1, $x2,$y2, ... [, p$decimal_places]);
$direction = Math::NumberCruncher::Clockwise( $x0,$y0, $x1,$y1, $x2,$y2 );
$collision = Math::NumberCruncher::InPolygon( $x, $y, @xy );
@points = Math::NumberCruncher::BoundingBox_Points( $d, @p );
$in_triangle = Math::NumberCruncher::InTriangle( $x,$y, $x0,$y0, $x1,$y1, $x2,$y2 );
$area = Math::NumberCruncher::PolygonArea( 0, 1, 1, 0, 2, 0, 3, 2, 2, 3 [, p$decimal_places] );
$area = Math::NumberCruncher::CircleArea( $diameter [, $decimal_places] );
$circumference = Math::NumberCruncher::Circumference( $diameter [, $decimal_places] );
$volume = Math::NumberCruncher::SphereVolume( $radius [, $decimal_places] );
$surface_area = Math::NumberCruncher::SphereSurface( $radius [, $decimal_places] );
$years = Math::NumberCruncher::RuleOf72( $interest_rate [, $decimal_places] );
$volume = Math::NumberCruncher::CylinderVolume( $radius, $height [, $decimal_places] );
$volume = Math::NumberCruncher::ConeVolume( $lowerBaseArea, $height [, $decimal_places] );
$radians = Math::NumberCruncher::deg2rad( $degrees [, $decimal_places] );
$degrees = Math::NumberCruncher::rad2deg( $radians [, $decimal_places] );
$Fahrenheit = Math::NumberCruncher::C2F( $Celsius [, $decimal_places] );
$Celsius = Math::NumberCruncher::F2C( $Fahrenheit [, $decimal_places] );
$cm = Math::NumberCruncher::in2cm( $inches [, $decimal_places] );
$inches = Math::NumberCruncher::cm2in( $cm [, $decimal_places] );
$ft = Math::NumberCruncher::m2ft( $m [, $decimal_places] );
$m = Math::NumberCruncher::ft2m( $ft [, $decimal_places] );
$miles = Math::NumberCruncher::km2miles( $km [, $decimal_places] );
$km = Math::NumberCruncher::miles2km( $miles [, $decimal_places] );
$lb = Math::NumberCruncher::kg2lb( $kg [, $decimal_places] );
$kg = Math::NumberCruncher::lb2kg( $lb [, $decimal_places] );
$RelativeStride = Math::NumberCruncher::RelativeStride( $stride_length, $leg_length [, $decimal_places] );
$RelativeStride = Math::NumberCruncher::RelativeStride_2( $DimensionlessSpeed [, $decimal_places] );
$DimensionlessSpeed = Math::NumberCruncher::DimensionlessSpeed( $RelativeStride [, $decimal_places] );
$DimensionlessSpeed = Math::NumberCruncher::DimensionlessSpeed_2( $ActualSpeed, $leg_length [, $decimal_places]);
$ActualSpeed = Math::NumberCruncher::ActualSpeed( $leg_length, $DimensionlessSpeed [, $decimal_places] );
$eccentricity = Math::NumberCruncher::Eccentricity( $half_major_axis, $half_minor_axis [, $decimal_places] );
$LatusRectum = Math::NumberCruncher::LatusRectum( $half_major_axis, $half_minor_axis [, $decimal_places] );
$EllipseArea = Math::NumberCruncher::EllipseArea( $half_major_axis, $half_minor_axis [, $decimal_places] );
$OrbitalVelocity = Math::NumberCruncher::OrbitalVelocity( $r, $a, $M [, $decimal_places] );
$sine = Math::NumberCruncher::sin( $x [, $decimal_places] );
$cosine = Math::NumberCruncher::cos( $x [, $decimal_places] );
$tangent = Math::NumberCruncher::tan( $x [, $decimal_places] );
$arcsin = Math::NumberCruncher::asin( $x [, $decimal_places] );
$arccos = Math::NumberCruncher::acos( $x [, $decimal_places] );
$arctan = Math::NumberCruncher::atan( $x [, $decimal_places] );
$cotangent = Math::NumberCruncher::cot( $x [, $decimal_places] );
$arccot = Math::NumberCruncher::acot( $x [, $decimal_places] );
$secant = Math::NumberCruncher::sec( $x [, $decimal_places] );
$arcsec = Math::NumberCruncher::asec( $x [, $decimal_places] );
$cosecant = Math::NumberCruncher::csc( $x [, $decimal_places] );
$arccosecant = Math::NumberCruncher::acsc( $x [, $decimal_places] );
$exsecant = Math::NumberCruncher::exsec( $x [, $decimal_places] );
$versine = Math::NumberCruncher::vers( $x [, $decimal_places] );
$coversine = Math::NumberCruncher::covers( $x [, $decimal_places] );
$haversine = Math::NumberCruncher::hav( $x [, $decimal_places] );
$grouped = Math::NumberCruncher::Commas( $number );
$SqrRoot = Math::NumberCruncher::SqrRoot( $number [, $decimal_places] );
$square_root = Math::NumberCruncher::sqrt( $x [, $decimal_places] );
$root = Math::NumberCruncher::Root( 55, 3 [, $decimal_places] );
$root = Math::NumberCruncher::Root2( 55, 3 [, $decimal_places] );
$log = Math::NumberCruncher::Ln( 100 [, $decimal_places] );
$log = Math::NumberCruncher::log( $num [, $decimal_places] );
$num = Math::NumberCruncher::Exp( 0.111 [, $decimal_places] );
$num = Math::NumberCruncher::exp( $log [, $decimal_places] );
$Pi = Math::NumberCruncher::PICONST( $decimal_places );
$E = Math::NumberCruncher::ECONST( $decimal_places );
( $A, $B, $C ) = Math::NumberCruncher::PythagTriples( $x, $y [, $decimal_places] );
$z = Math::NumberCruncher::PythagTriplesSeq( $x, $y [, $decimal_places] );
@nums = Math::NumberCruncher::SIS( [$start, $numbers, $increment] );
$inverse = Math::NumberCruncher::Inverse( $number [, $decimal_places] );
@constants = Math::NumberCruncher::CONSTANTS( all [, $decimal_places] );
$bernoulli = Math::NumberCruncher::Bernoulli( $num [, $decimal_places] );
@bernoulli = Math::NumberCruncher::Bernoulli( $num );

Math::BigRat package arbitrary big rational numbers.

SYNOPSIS

use Math::BigRat;

my $x = Math::BigRat->new(3/7); $x += 5/9;

print $x->bstr(),"n";
print $x ** 2,"n";

my $y = Math::BigRat->new(inf);
print "$y ", ($y->is_inf ? is : is not) , " infinityn";

my $z = Math::BigRat->new(144); $z->bsqrt();

Math::BigRat complements Math::BigInt and Math::BigFloat by providing support for arbitrary big rational numbers.

MATH LIBRARY

You can change the underlying module that does the low-level math operations by using:

use Math::BigRat try => GMP;

Note: This needs Math::BigInt::GMP installed.
The following would first try to find Math::BigInt::Foo, then Math::BigInt::Bar, and when this also fails, revert to Math::BigInt::Calc:

use Math::BigRat try => Foo,Math::BigInt::Bar;

If you want to get warned when the fallback occurs, replace "try" with "lib":

use Math::BigRat lib => Foo,Math::BigInt::Bar;

If you want the code to die instead, replace "try" with "only":

use Math::BigRat only => Foo,Math::BigInt::Bar;

Math Kards is a study aid for K6 students. The widget will present you simple math functions (addition, subtraction, multiplication, and division) from 0 to 12 as cards in a deck. Math Kards uses the Macintosh Speech System to read the math fact on each card to the user. Cards can be presented in random, ascending, or descending order.

Math Kards is a nice Widget to leaving lying around your daughters or sons desktop.

Math::Vec is a Object-Oriented Vector Math Methods in Perl.

SYNOPSIS

use Math::Vec;
$v = Math::Vec->new(0,1,2);

or

use Math::Vec qw(NewVec);
$v = NewVec(0,1,2);
@res = $v->Cross([1,2.5,0]);
$p = NewVec(@res);
$q = $p->Dot([0,1,0]);

or

use Math::Vec qw(:terse);
$v = V(0,1,2);
$q = ($v x [1,2.5,0]) * [0,1,0];

NOTICE

This module is still somewhat incomplete. If a function does nothing, there is likely a really good reason. Please have a look at the code if you are trying to use this in a production environment.

Math::GMPz is a Perl interface to the GMP librarys integer (mpz) functions.

A bignum module utilising the Gnu MP (GMP) library. Basically this module simply wraps nearly all of the integer functions provided by that library. The documentation below extensively plagiarises the documentation at http://swox.com/gmp/manual.

See the Math::GMPz test suite for examples of usage.

SYNOPSIS

use Math::GMPz qw(:mpz :primes :supp);

my $string = fa9eeeeeeeeeeeeea1234dcbaef1;
my $base = 16;

# Create the Math::GMPz object
my $bn1 = Rmpz_init_set_str($string, $base);

# Create another Math::GMPz object that holds
# an initial value of zero, but has enough
# memory allocated to store a 131-bit number.
# If 131 bits turns out to be insufficient, it
# doesnt matter - additional memory is allocated
# automatically to Math::GMPz objects as needed
# by the GMP library.
my $bn2 = Rmpz_init2(131);

# Create another Math::GMPz object initialised to 0.
my $bn3 = Rmpz_init();

# or use the new() function:
my $bn4 = Math::GMPz->new(12345);

# Perform some operations ... see FUNCTIONS below.

.
.

# print out the value held by $bn1 (in octal):
print Rmpz_get_str($bn1, 8), "n";

# print out the value held by $bn1 (in decimal):
print Rmpz_get_str($bn1, 10);

# print out the value held by $bn1 (in base 29)
# using the (alternative) Rmpz_out_str()
# function. (This function doesnt print a newline.)
Rmpz_out_str($bn1, 29);

Math TRb-8r is a screensaver that will let you watch in awe as the amazing Math TRb-8r generates and solves complex math problems right before your eyes.

Math::String module contains arbitrary sized integers having arbitrary charsets to calculate with key rooms.

SYNOPSIS

use Math::String;
use Math::String::Charset;

$a = new Math::String cafebabe; # default a-z
$b = new Math::String deadbeef; # a-z
print $a + $b; # Math::String ""

$a = new Math::String aa; # default a-z
$b = $a;
$b++;
print "$b > $a" if ($b > $a); # prove that ++ makes it greater
$b--;
print "$b == $a" if ($b == $a); # and that ++ and -- are reverse

$d = Math::String->bzero( [0...9] ); # like Math::Bigint
$d += Math::String->new ( 9999, [ 0..9 ] );
# Math::String "9999"

print "$dn"; # string "00000n"
print $d->as_number(),"n"; # Math::BigInt "+11111"
print $d->last(5),"n"; # string "99999"
print $d->first(3),"n"; # string "111"
print $d->length(),"n"; # faster than length("$d");

$d = Math::String->new ( , Math::String::Charset->new ( {
minlen => 2, start => [ a..z ], } );

print $d->minlen(),"n"; # print 2
print ++$d,"n"; # print aa

Math::NoCarry is a Perl extension for no carry arithmetic.

SYNOPSIS

use Math::NoCarry;

my $sum = Math::NoCarry::add( 123, 456 );

my $difference = Math::NoCarry::subtract( 123, 456 );

my $product = Math::NoCarry::multiply( 123, 456 );

No carry arithmetic doesnt allow you to carry digits to the next column. For example, if you add 8 and 4, you normally expect the answer to be 12, but that 1 digit is a carry. In no carry arithmetic you cant do that, so the sum of 8 and 4 is just 2. In effect, this is addition modulo 10 in each column. I discard all of the carry digits in this example:

1234
+ 5678
------
6802

For multiplication, the result of pair-wise multiplication of digits is the modulo 10 value of their normal, everyday multiplication.

123
x 456
-----
8 6 x 3
2 6 x 2
6 6 x 1

5 5 x 3
0 5 x 2
5 5 x 1

2 4 x 3
8 4 x 2
+ 4 4 x 1
-------
43878
Since multiplication and subtraction are actually types of additions, you can multiply and subtract like this as well.

No carry arithmetic is both associative and commutative.

Math::BaseCalc is a Perl module that can convert numbers between various bases.

SYNOPSIS

use Math::BaseCalc;

my $calc = new Math::BaseCalc(digits => [0,1]); #Binary
my $bin_string = $calc->to_base(465); # Convert 465 to binary

$calc->digits(oct); # Octal
my $number = $calc->from_base(1574); # Convert octal 1574 to decimal

This module facilitates the conversion of numbers between various number bases. You may define your own digit sets, or use any of several predefined digit sets.

The to_base() and from_base() methods convert between Perl numbers and strings which represent these numbers in other bases. For instance, if youre using the binary digit set [0,1], $calc->to_base(5) will return the string "101". $calc->from_base("101") will return the number 5.
To convert between, say, base 7 and base 36, use the 2-step process of first converting to a Perl number, then to the desired base for the result:

$calc7 = new Math::BaseCalc(digits=>[0..6]);
$calc36 = new Math::BaseCalc(digits=>[0..9,a..z];

$in_base_36 = $calc36->to_base( $calc7->from_base(3506) );

If you just need to handle regular octal & hexdecimal strings, you probably dont need this module. See the sprintf(), oct(), and hex() Perl functions.

Math::BigInt is an arbitrary size integer/float math package.

SYNOPSIS

use Math::BigInt;

# or make it faster: install (optional) Math::BigInt::GMP
# and always use (it will fall back to pure Perl if the
# GMP library is not installed):

# will warn if Math::BigInt::GMP cannot be found
use Math::BigInt lib => GMP;

# to supress the warning use this:
# use Math::BigInt try => GMP;

my $str = 1234567890;
my @values = (64,74,18);
my $n = 1; my $sign = -;

# Number creation
my $x = Math::BigInt->new($str); # defaults to 0
my $y = $x->copy(); # make a true copy
my $nan = Math::BigInt->bnan(); # create a NotANumber
my $zero = Math::BigInt->bzero(); # create a +0
my $inf = Math::BigInt->binf(); # create a +inf
my $inf = Math::BigInt->binf(-); # create a -inf
my $one = Math::BigInt->bone(); # create a +1
my $mone = Math::BigInt->bone(-); # create a -1

my $pi = Math::BigInt->bpi(); # returns 3
# see Math::BigFloat::bpi()

$h = Math::BigInt->new(0x123); # from hexadecimal
$b = Math::BigInt->new(0b101); # from binary
$o = Math::BigInt->from_oct(0101); # from octal

# Testing (dont modify their arguments)
# (return true if the condition is met, otherwise false)

$x->is_zero(); # if $x is +0
$x->is_nan(); # if $x is NaN
$x->is_one(); # if $x is +1
$x->is_one(-); # if $x is -1
$x->is_odd(); # if $x is odd
$x->is_even(); # if $x is even
$x->is_pos(); # if $x >= 0
$x->is_neg(); # if $x < 0
$x->is_inf($sign); # if $x is +inf, or -inf (sign is default +)
$x->is_int(); # if $x is an integer (not a float)

# comparing and digit/sign extraction
$x->bcmp($y); # compare numbers (undef,<0,=0,>0)
$x->bacmp($y); # compare absolutely (undef,<0,=0,>0)
$x->sign(); # return the sign, either +,- or NaN
$x->digit($n); # return the nth digit, counting from right
$x->digit(-$n); # return the nth digit, counting from left

# The following all modify their first argument. If you want to preserve
# $x, use $z = $x->copy()->bXXX($y); See under L for why this is
# necessary when mixing $a = $b assignments with non-overloaded math.

$x->bzero(); # set $x to 0
$x->bnan(); # set $x to NaN
$x->bone(); # set $x to +1
$x->bone(-); # set $x to -1
$x->binf(); # set $x to inf
$x->binf(-); # set $x to -inf

$x->bneg(); # negation
$x->babs(); # absolute value
$x->bnorm(); # normalize (no-op in BigInt)
$x->bnot(); # twos complement (bit wise not)
$x->binc(); # increment $x by 1
$x->bdec(); # decrement $x by 1

$x->badd($y); # addition (add $y to $x)
$x->bsub($y); # subtraction (subtract $y from $x)
$x->bmul($y); # multiplication (multiply $x by $y)
$x->bdiv($y); # divide, set $x to quotient
# return (quo,rem) or quo if scalar

$x->bmuladd($y,$z); # $x = $x * $y + $z

$x->bmod($y); # modulus (x % y)
$x->bmodpow($exp,$mod); # modular exponentation (($num**$exp) % $mod))
$x->bmodinv($mod); # the inverse of $x in the given modulus $mod

$x->bpow($y); # power of arguments (x ** y)
$x->blsft($y); # left shift in base 2
$x->brsft($y); # right shift in base 2
# returns (quo,rem) or quo if in scalar context
$x->blsft($y,$n); # left shift by $y places in base $n
$x->brsft($y,$n); # right shift by $y places in base $n
# returns (quo,rem) or quo if in scalar context

$x->band($y); # bitwise and
$x->bior($y); # bitwise inclusive or
$x->bxor($y); # bitwise exclusive or
$x->bnot(); # bitwise not (twos complement)

$x->bsqrt(); # calculate square-root
$x->broot($y); # $yth root of $x (e.g. $y == 3 => cubic root)
$x->bfac(); # factorial of $x (1*2*3*4*..$x)

$x->bnok($y); # x over y (binomial coefficient n over k)

$x->blog(); # logarithm of $x to base e (Eulers number)
$x->blog($base); # logarithm of $x to base $base (f.i. 2)
$x->bexp(); # calculate e ** $x where e is Eulers number

$x->round($A,$P,$mode); # round to accuracy or precision using mode $mode
$x->bround($n); # accuracy: preserve $n digits
$x->bfround($n); # round to $nth digit, no-op for BigInts

# The following do not modify their arguments in BigInt (are no-ops),
# but do so in BigFloat:

$x->bfloor(); # return integer less or equal than $x
$x->bceil(); # return integer greater or equal than $x

# The following do not modify their arguments:

# greatest common divisor (no OO style)
my $gcd = Math::BigInt::bgcd(@values);
# lowest common multiplicator (no OO style)
my $lcm = Math::BigInt::blcm(@values);

$x->length(); # return number of digits in number
($xl,$f) = $x->length(); # length of number and length of fraction part,
# latter is always 0 digits long for BigInts

$x->exponent(); # return exponent as BigInt
$x->mantissa(); # return (signed) mantissa as BigInt
$x->parts(); # return (mantissa,exponent) as BigInt
$x->copy(); # make a true copy of $x (unlike $y = $x;)
$x->as_int(); # return as BigInt (in BigInt: same as copy())
$x->numify(); # return as scalar (might overflow!)

# conversation to string (do not modify their argument)
$x->bstr(); # normalized string (e.g. 3)
$x->bsstr(); # norm. string in scientific notation (e.g. 3E0)
$x->as_hex(); # as signed hexadecimal string with prefixed 0x
$x->as_bin(); # as signed binary string with prefixed 0b
$x->as_oct(); # as signed octal string with prefixed 0


# precision and accuracy (see section about rounding for more)
$x->precision(); # return P of $x (or global, if P of $x undef)
$x->precision($n); # set P of $x to $n
$x->accuracy(); # return A of $x (or global, if A of $x undef)
$x->accuracy($n); # set A $x to $n

# Global methods
Math::BigInt->precision(); # get/set global P for all BigInt objects
Math::BigInt->accuracy(); # get/set global A for all BigInt objects
Math::BigInt->round_mode(); # get/set global round mode, one of
# even, odd, +inf, -inf, zero, trunc or common
Math::BigInt->config(); # return hash containing configuration

Math::CDF is a Perl module to generate probabilities and quantiles from several statistical probability functions.

SYNOPSIS

use Math::CDF;

$prob = &Math::CDF::pnorm(1.96);

if( not defined($z = &Math::CDF::qnorm(0.975)) ) { die "qnorm() failed"; }

or

use Math::CDF qw(:all);

$prob = pnorm(1.96);

This module provides a perl interface to the DCDFLIB. See the section on DCDFLIB for more information.

Functions are available for 7 continuous distributions (Beta, Chi-square, F, Gamma, Normal, Poisson and T-distribution) and for two discrete distributions (Binomial and Negative Binomial). Optional non-centrality parameters are available for the Chi-square, F and T-distributions. Cumulative probabilities are available for all 9 distributions and quantile functions are available for the 7 continuous distributions.

All cumulative probability function names begin with the character "p". They give the probability of being less than or equal to the given value [ P(X <= x) ]

All quantile function names begin with the character q. They give a value of x such that P(X <= x) = p where the value of p is provided to the function.

Non-centrality parameters are always the last function argument when available. You do not need to supply the non-centrality parameter in which case it will be assumed to be 0.

All functions will return an undefined value if the function fails (probably due to parameters being out of allowed range) but will not otherwise generate an error message. The user should check for valid output from the Math::CDF functions with the defined() function as demonstrated in the SYNOPSIS section.