Free math presentation interacitve tool plot function software for linux

Math::Cephes::Complex is a Perl interface to the cephes complex number routines.

SYNOPSIS

use Math::Cephes::Complex qw(cmplx);
my $z1 = cmplx(2,3); # $z1 = 2 + 3 i
my $z2 = cmplx(3,4); # $z2 = 3 + 4 i
my $z3 = $z1->radd($z2); # $z3 = $z1 + $z2

Math::Fraction is a Perl module to manipulate exact fractions.
SYNOPSIS
use Math::Fraction;
$a = frac(1,2); $b = frac(6,7);
print "$a + $b = ", $a + $b, "$a * $b = ", $a * $b;
print $a->num;
Main features:
- Being able to add, subtract, multiply, and divide, among other things just like you would normal numbers thats to the overload module.
- Being able to convert a decimal, including repeating ones, into a fraction. For example, 1.142857142857 would become 8/7.
- Being able to control how the fraction is displayed. For example 8/7 verses 1 1/7
- Being able to use arbitrary size numbers in the numerator and the denominator.
- Being able to covert between SMALL (using normal floats/integers) and BIG (using arbitrary size floats/integers) as needed so you do not have to worry about it. (New as of ver .4a)
- Being able to have multiple default sets so that a function can modify the defaults with out effecting other functions (New as of ver .4a)

Plotting all 2D and 3D functions had never been so easy. Many samples are included.
Its also possible to print or export the plots in postscript format.
Main features:
- Plot any 2D or 3D parametric function
- Save and open parameters of a plot
- Print or export to postscript format
- Separate output and control windows to allow more working space
- Many samples included
- Zoom and axis control

Math::Polynomial::Solve is a Perl module to find the roots of polynomial equations.

SYNOPSIS

use Math::Complex; # The roots may be complex numbers.
use Math::Polynomial::Solve qw(poly_roots);

my @x = poly_roots(@coefficients);
or
use Math::Complex; # The roots may be complex numbers.
use Math::Polynomial::Solve qw(poly_roots get_hessenberg set_hessenberg);

#
# Force the use of the matrix method.
#
set_hessenberg(1);
my @x = poly_roots(@coefficients);
or
use Math::Complex; # The roots may be complex numbers.
use Math::Polynomial::Solve
qw(linear_roots quadratic_roots cubic_roots quartic_roots);

# Find the roots of ax + b
my @x1 = linear_roots($a, $b);

# Find the roots of ax**2 + bx +c
my @x2 = quadratic_roots($a, $b, $c);

# Find the roots of ax**3 + bx**2 +cx + d
my @x3 = cubic_roots($a, $b, $c, $d);

# Find the roots of ax**4 + bx**3 +cx**2 + dx + e
my @x4 = quartic_roots($a, $b, $c, $d, $e);

Math::BigInt::Calc is a pure Perl module to support Math::BigInt.

SYNOPSIS

Provides support for big integer calculations. Not intended to be used by other modules. Other modules which sport the same functions can also be used to support Math::BigInt, like Math::BigInt::GMP or Math::BigInt::Pari.

In order to allow for multiple big integer libraries, Math::BigInt was rewritten to use library modules for core math routines. Any module which follows the same API as this can be used instead by using the following:

use Math::BigInt lib => libname;
libname is either the long name (Math::BigInt::Pari), or only the short version like Pari.

METHODS

The following functions MUST be defined in order to support the use by Math::BigInt v1.70 or later:

api_version() return API version, 1 for v1.70, 2 for v1.83
_new(string) return ref to new object from ref to decimal string
_zero() return a new object with value 0
_one() return a new object with value 1
_two() return a new object with value 2
_ten() return a new object with value 10

_str(obj) return ref to a string representing the object
_num(obj) returns a Perl integer/floating point number
NOTE: because of Perl numeric notation defaults,
the _numified obj may lose accuracy due to
machine-dependent floating point size limitations

_add(obj,obj) Simple addition of two objects
_mul(obj,obj) Multiplication of two objects
_div(obj,obj) Division of the 1st object by the 2nd
In list context, returns (result,remainder).
NOTE: this is integer math, so no
fractional part will be returned.
The second operand will be not be 0, so no need to
check for that.
_sub(obj,obj) Simple subtraction of 1 object from another
a third, optional parameter indicates that the params
are swapped. In this case, the first param needs to
be preserved, while you can destroy the second.
sub (x,y,1) => return x - y and keep x intact!
_dec(obj) decrement object by one (input is guaranteed to be > 0)
_inc(obj) increment object by one


_acmp(obj,obj) operator for objects (return -1, 0 or 1)

_len(obj) returns count of the decimal digits of the object
_digit(obj,n) returns the nth decimal digit of object

_is_one(obj) return true if argument is 1
_is_two(obj) return true if argument is 2
_is_ten(obj) return true if argument is 10
_is_zero(obj) return true if argument is 0
_is_even(obj) return true if argument is even (0,2,4,6..)
_is_odd(obj) return true if argument is odd (1,3,5,7..)

_copy return a ref to a true copy of the object

_check(obj) check whether internal representation is still intact
return 0 for ok, otherwise error message as string

_from_hex(str) return new object from a hexadecimal string
_from_bin(str) return new object from a binary string
_from_oct(str) return new object from an octal string

_as_hex(str) return string containing the value as
unsigned hex string, with the 0x prepended.
Leading zeros must be stripped.
_as_bin(str) Like as_hex, only as binary string containing only
zeros and ones. Leading zeros must be stripped and a
0b must be prepended.

_rsft(obj,N,B) shift object in base B by N digits right
_lsft(obj,N,B) shift object in base B by N digits left

_xor(obj1,obj2) XOR (bit-wise) object 1 with object 2
Note: XOR, AND and OR pad with zeros if size mismatches
_and(obj1,obj2) AND (bit-wise) object 1 with object 2
_or(obj1,obj2) OR (bit-wise) object 1 with object 2

_mod(obj1,obj2) Return remainder of div of the 1st by the 2nd object
_sqrt(obj) return the square root of object (truncated to int)
_root(obj) return the nth (n >= 3) root of obj (truncated to int)
_fac(obj) return factorial of object 1 (1*2*3*4..)
_pow(obj1,obj2) return object 1 to the power of object 2
return undef for NaN
_zeros(obj) return number of trailing decimal zeros
_modinv return inverse modulus
_modpow return modulus of power ($x ** $y) % $z
_log_int(X,N) calculate integer log() of X in base N
X >= 0, N >= 0 (return undef for NaN)
returns (RESULT, EXACT) where EXACT is:
1 : result is exactly RESULT
0 : result was truncated to RESULT
undef : unknown whether result is exactly RESULT
_gcd(obj,obj) return Greatest Common Divisor of two objects
The following functions are REQUIRED for an api_version of 2 or greater:
_1ex($x) create the number 1Ex where x >= 0
_alen(obj) returns approximate count of the decimal digits of the
object. This estimate MUST always be greater or equal
to what _len() returns.
_nok(n,k) calculate n over k (binomial coefficient)

The following functions are optional, and can be defined if the underlying lib has a fast way to do them. If undefined, Math::BigInt will use pure Perl (hence slow) fallback routines to emulate these:

_signed_or
_signed_and
_signed_xor

Input strings come in as unsigned but with prefix (i.e. as 123, 0xabc or 0b1101).

So the library needs only to deal with unsigned big integers. Testing of input parameter validity is done by the caller, so you need not worry about underflow (f.i. in _sub(), _dec()) nor about division by zero or similar cases.

The first parameter can be modified, that includes the possibility that you return a reference to a completely different object instead. Although keeping the reference and just changing its contents is preferred over creating and returning a different reference.

Return values are always references to objects, strings, or true/false for comparison routines.

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.

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 );