Free math questions software for linux

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

MathStudio project is an interactive equation editor and step-by-step solver.
MathStudio is a project aimed at making math-typing, plotting, and symbolic math easier.
Its user can easily input, plot, and save/load math data in various formats (e.g., MathML). Step-by-step resolution makes this a powerful learning tool.
Main features:
- Open Source
- Cross-platform
- Compiler support
- Easy to use
- Simple, extensible
- Intermediate steps

Math::String::Charset is a simple charset for Math::String objects.

SYNOPSIS

use Math::String::Charset;

$a = new Math::String::Charset; # default a-z
$b = new Math::String::Charset [a..z]; # same
$c = new Math::String::Charset
{ start => [a..z], sep => }; # with between chars

print $b->length(); # a-z => 26

# construct a charset from bigram table, and an initial set (containing
# valid start-characters)
# Note: After an a, either an b, c or a can follow, in this order
# After an d only an a can follow
$bi = new Math::String::Charset ( {
start => a..d,
bi => {
a => [ b, c, a ],
b => [ c, b ],
c => [ a, c ],
d => [ a, ],
q => [ ], # q will be automatically in end
}
end => [ a, b, ],
} );
print $bi->length(); # a,b => 2 (cross of end and start)
print scalar $bi->class(2); # count of combinations with 2 letters
# will be 3+2+2+1 => 8

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

print $d->first(0),"n"; # undef, too short
print $d->first(1),"n"; # undef, to short
print $d->first(2),"n"; # aa

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

print $d->first(0),"n"; #
print $d->first(1),"n"; # a
print $d->last(1),"n"; # z
print $d->first(2),"n"; # aa

This module lets you create an charset object, which is used to contruct Math::String objects. This object knows how to handle simple charsets as well as complex onex consisting of bi-grams (later tri and more).

In case of more complex charsets, a reference to a Math::String::Charset::Nested or Math::String::Charset::grouped will be returned.

The default charset is the set containing "abcdefghijklmnopqrstuvwxyz" (thus producing always lower case output).

Math Objects is a math template library written in C++ using generic programming techniques. In order to use the "Math Objects" library, the user only has to include the header files he needs (e.g. Matrix.h, Polynomial.h etc.).
In order to compile the library the user needs an ISO/IEC 14882:1998 standard compliant C++ compiler (e.g. one that supports partial template specializations).
The math library has math objects like matrices, polynomials, rational functions, extended precision numbers, complex numbers etc. that can be handled in a similar way like basic numerical types (e.g. integers or floating point numbers).
One can access properties of a mathematical type through a (partial) specialization of a traits class for that type (AlgebraicTraits). Having the traits classes to expose properties of mathematical objects, one can define for example matrices of polynomials having extended precision complex coefficients and apply to them basic linear algebra algorithms using normal C++ syntax.
This library also implements two functions using two deterministic algorithms that compute the Smith form for polynomial matrices, and the Smith-McMillan form of a transfer functions matrix also keeping track of the transformation matrices.
These algorithms can be used to describe a MIMO (multi input-multi output) system by means of its zeros and poles and also give the MFD (matrix fraction description) of the system.
Enhancements:
- Recoded the LongInt class aiming for better runtime efficiency.

Math::Cephes::Matrix is a Perl interface to the cephes matrix routines.

SYNOPSIS

use Math::Cephes::Matrix qw(mat);
# mat is a shortcut for Math::Cephes::Matrix->new
my $M = mat([ [1, 2, -1], [2, -3, 1], [1, 0, 3]]);
my $C = mat([ [1, 2, 4], [2, 9, 2], [6, 2, 7]]);
my $D = $M->add($C); # D = M + C
my $Dc = $D->coef;
for (my $i=0; $inew($arr_ref);

where $arr_ref is a reference to an array of arrays, as in the following example:

$arr_ref = [ [1, 2, -1], [2, -3, 1], [1, 0, 3] ]

which represents
/ 1 2 -1
| 2 -3 1 |
1 0 3 /

A copy of a Math::Cephes::Matrix object may be done as

my $M_copy = $M->new();

Methods

coef: get coefficients of the matrix

SYNOPSIS:

my $c = $M->coef;

DESCRIPTION:

This returns an reference to an array of arrays containing the coefficients of the matrix.
clr: set all coefficients equal to a value.

SYNOPSIS:

$M->clr($n);

DESCRIPTION:

This sets all the coefficients of the matrix identically to $n. If $n is not given, a default of 0 is used.
add: add two matrices

SYNOPSIS:

$P = $M->add($N);

DESCRIPTION:

This sets $P equal to $M + $N.
sub: subtract two matrices

SYNOPSIS:

$P = $M->sub($N);

DESCRIPTION:

This sets $P equal to $M - $N.
mul: multiply two matrices or a matrix and a vector

SYNOPSIS:

$P = $M->mul($N);

DESCRIPTION:

This sets $P equal to $M * $N. This method can handle matrix multiplication, when $N is a matrix, as well as matrix-vector multiplication, where $N is an array reference representing a column vector.
div: divide two matrices

SYNOPSIS:

$P = $M->div($N);

DESCRIPTION:

This sets $P equal to $M * ($N)^(-1).
inv: invert a matrix

SYNOPSIS:

$I = $M->inv();

DESCRIPTION:

This sets $I equal to ($M)^(-1).
transp: transpose a matrix

SYNOPSIS:

$T = $M->transp();

DESCRIPTION:

This sets $T equal to the transpose of $M.
simq: solve simultaneous equations

SYNOPSIS:

my $M = Math::Cephes::Matrix->new([ [1, 2, -1], [2, -3, 1], [1, 0, 3]]);
my $B = [2, -1, 10];
my $X = $M->simq($B);
for (my $i=0; $inew([ [1, 2, 3], [2, 2, 3], [3, 3, 4]]);
my ($E, $EV1) = $S->eigens();
my $EV = $EV1->coef;
for (my $i=0; $i[$i]->[$j];
}
print "The eigenvector is @$vn";
}

where $M is a Math::Cephes::Matrix object representing a real symmetric matrix. $E is an array reference containing the eigenvalues of $M, and $EV is a Math::Cephes::Matrix object representing the eigenvalues, the ith row corresponding to the ith eigenvalue.

DESCRIPTION:

If M is an N x N real symmetric matrix, and X is an N component column vector, the eigenvalue problem

M X = lambda X

will in general have N solutions, with X the eigenvectors and lambda the eigenvalues.

Math::Matrix can multiply and invert Matrices.

The following methods are available:

new

Constructor arguments are a list of references to arrays of the same length. The arrays are copied. The method returns undef in case of error.

$a = new Math::Matrix ([rand,rand,rand],
[rand,rand,rand],
[rand,rand,rand]);

If you call new as method, a zero filled matrix with identical deminsions is returned.

clone

You can clone a matrix by calling:

$b = $a->clone;

size

You can determine the dimensions of a matrix by calling:

($m, $n) = $a->size;

concat

Concatenates two matrices of same row count. The result is a new matrix or undef in case of error.

$b = new Math::Matrix ([rand],[rand],[rand]);
$c = $a->concat($b);

transpose

Returns the transposed matrix. This is the matrix where colums and rows of the argument matrix are swaped.

multiply

Multiplies two matrices where the length of the rows in the first matrix is the same as the length of the columns in the second matrix. Returns the product or undef in case of error.

solve

Solves a equation system given by the matrix. The number of colums must be greater than the number of rows. If variables are dependent from each other, the second and all further of the dependent coefficients are 0. This means the method can handle such systems. The method returns a matrix containing the solutions in its columns or undef in case of error.

invert

Invert a Matrix using solve.

multiply_scalar

Multiplies a matrix and a scalar resulting in a matrix of the same dimensions with each element scaled with the scalar.

$a->multiply_scalar(2); scale matrix by factor 2

add

Add two matrices of the same dimensions.

substract

Shorthand for add($other->negative)

equal

Decide if two matrices are equal. The criterion is, that each pair of elements differs less than $Math::Matrix::eps.

slice

Extract columns:

a->slice(1,3,5);

determinant

Compute the determinant of a matrix.

dot_product

Compute the dot product of two vectors.

absolute

Compute the absolute value of a vector.

normalizing

Normalize a vector.

cross_product

Compute the cross-product of vectors.

print

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

pinvert

Compute the pseudo-inverse of the matrix: ((AA)^-1)A

EXAMPLE

use Math::Matrix;

srand(time);
$a = new Math::Matrix ([rand,rand,rand],
[rand,rand,rand],
[rand,rand,rand]);
$x = new Math::Matrix ([rand,rand,rand]);
$a->print("An");
$E = $a->concat($x->transpose);
$E->print("Equation systemn");
$s = $E->solve;
$s->print("Solutions sn");
$a->multiply($s)->print("A*sn");

MathTables is a program that helps parents teach their children how to use the four basic math operations, multiplication, substraction, addition and division.

With MathTables parents can print sheets full of math operations for their children to answer. They can also print corresponding sheets with the solutions so that either them, or the children themselves, can work on the corrections.

This program arose from the actual need to print math tables almost daily for my children, as requested by their school.

MathTables is written in Python using the PyGTK toolkit.

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)
$x->bacmp($y); # compare absolutely (undef,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