math

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.

Snakey Math is an educational game combining arithmetic practice with classic arcade action for one to four players.

Compete against other players and/or computer-controlled snakes to eat answers to problems.

Options include various number ranges, negatives, and mixed reviews.

Here are some key features of "Snakey Math":

· Arcade experience with lots of color, sound, motion, and music
· Four snakes, each of which can be controlled by a player or by the computer
· One to four players can enjoy the game on one computer
· Negative numbers, mixed reviews, and various ranges for operands are included
· Three power-ups for added fun, plus electric switches.


Limitations:

· Math settings are limited to Multiplication with numbers from 1 to 6.


Whats New in This Release:

· Adds confirmation when ending a game
· other minor improvements.

Math::MagicSquare is a Magic Square Checker and Designer.

SYNOPSIS

use Math::MagicSquare;

$a= Math::MagicSquare -> new ([num,...,num],
...,
[num,...,num]);
$a->print("string");
$a->printhtml();
$a->printimage();
$a->check();
$a->rotation();
$a->reflection();

The following methods are available:

new

Constructor arguments are a list of references to arrays of the same length.

$a = Math::MagicSquare -> new ([num,...,num],
...,
[num,...,num]);

check

This function can return 4 value

0: the Square is not Magic
1: the Square is a Semimagic Square (the sum of the rows and the columns is equal)
2: the Square is a Magic Square (the sum of the rows, the columns and the diagonals is equal)
3: the Square ia Panmagic Square (the sum of the rows, the columns, the diagonals and the broken diagonals is equal)

print

Prints the Square on STDOUT. If the method has additional parameters, these are printed before the Magic Square is printed.

printhtml

Prints the Square on STDOUT in an HTML format (exactly a inside a TABLE)

printimage

Prints the Square on STDOUT in png format.

rotation

Rotates the Magic Square of 90 degree clockwise

reflection

Reflect the Magic Square

Math::Combinatorics is a Perl module that can perform combinations and permutations on lists.

SYNOPSIS

Available as an object oriented API.

use Math::Combinatorics;

my @n = qw(a b c);
my $combinat = Math::Combinatorics->new(count => 2,
data => [@n],
);

print "combinations of 2 from: ".join(" ",@n)."n";
print "------------------------".("--" x scalar(@n))."n";
while(my @combo = $combinat->next_combination){
print join( , @combo)."n";
}

print "n";

print "permutations of 3 from: ".join(" ",@n)."n";
print "------------------------".("--" x scalar(@n))."n";
while(my @permu = $combinat->next_permutation){
print join( , @permu)."n";
}

output:

Or available via exported functions permute, combine, and factorial.

use Math::Combinatorics;

my @n = qw(a b c);
print "combinations of 2 from: ".join(" ",@n)."n";
print "------------------------".("--" x scalar(@n))."n";
print join("n", map { join " ", @$_ } combine(2,@n)),"n";
print "n";
print "permutations of 3 from: ".join(" ",@n)."n";
print "------------------------".("--" x scalar(@n))."n";
print join("n", map { join " ", @$_ } permute(@n)),"n";

Output:

combinations of 2 from: a b c
------------------------------
a b
a c
b c

permutations of 3 from: a b c
------------------------------
a b c
a c b
b a c
b c a
c a b
c b a

Output from both types of calls is the same, but the object-oriented approach consumes much less memory for large sets.