Free reciprocal software for linux

PDL::LinearAlgebra Perl module contains linear algebra utils for PDL.

SYNOPSIS

use PDL::LinearAlgebra;

$a = random (100,100);
($U, $s, $V) = mdsvd($a);

This module provides a convenient interface to PDL::LinearAlgebra::Real and PDL::LinearAlgebra::Complex.

FUNCTIONS

setlaerror

Set action type when error is encountered, returns previous type. Available values are NO, WARN and BARF (predefined constants). If, for example, in computation of the inverse, singularity is detected, the routine can silently return values from computation (see manuals), warn about singularity or barf. BARF is the default value.

$a = sequence(5,5);
$err = setlaerror(NO);
($inv, $info)= minv($a);
if ($info){
# Change the diagonal (the inverse doesnt exist but its an example)
$a->diagonal(0,1)+=1e-8;
($inv, $info)= minv($a);
}
if ($info){
print "Cant compute the inversen";
}
else{
print "Inverse of $a is $inv";
}
setlaerror($err);

getlaerror

Get error type.

0 => NO,
1 => WARN,
2 => BARF
t
PDL = t(PDL, SCALAR(conj))
conj : Conjugate Transpose = 1 | Transpose = 0, default = 1;

Convenient function for transposing real or complex 2D array(s). For PDL::Complex, if conj is true returns conjugate transpose array(s) and doesnt support dataflow. Supports threading.

issym

PDL = issym(PDL, SCALAR|PDL(tol),SCALAR(hermitian))
tol : tolerance value, default: 1e-8 for double else 1e-5
hermitian : Hermitian = 1 | Symmetric = 0, default = 1;

Check symmetricity/Hermitianicity of matrix. Supports threading.

diag

Return i-th diagonal if matrix in entry or matrix with i-th diagonal with entry. I-th diagonal returned flows data back&forth. Can be used as lvalue subs if your perl supports it. Supports threading.

PDL = diag(PDL, SCALAR(i), SCALAR(vector)))
i : i-th diagonal, default = 0
vector : create diagonal matrices by threading over row vectors, default = 0
my $a = random(5,5);
my $diag = diag($a,2);
# If your perl support lvaluable subroutines.
$a->diag(-2) .= pdl(1,2,3);
# Construct a (5,5,5) PDL (5 matrices) with
# diagonals from row vectors of $a
$a->diag(0,1)

tritosym

Return symmetric or Hermitian matrix from lower or upper triangular matrix. Supports inplace and threading. Uses tricpy or ctricpy from Lapack.

PDL = tritosym(PDL, SCALAR(uplo), SCALAR(conj))
uplo : UPPER = 0 | LOWER = 1, default = 0
conj : Hermitian = 1 | Symmetric = 0, default = 1;
# Assume $a is symmetric triangular
my $a = random(10,10);
my $b = tritosym($a);

positivise

Return entry pdl with changed sign by row so that average of positive sign > 0. In other words thread among dimension 1 and row = -row if Sum(sign(row)) < 0. Works inplace.

my $a = random(10,10);
$a -= 0.5;
$a->xchg(0,1)->inplace->positivise;

mcrossprod

Compute the cross-product of two matrix: A x B. If only one matrix is given, take B to be the same as A. Supports threading. Uses crossprod or ccrossprod.

PDL = mcrossprod(PDL(A), (PDL(B))
my $a = random(10,10);
my $crossproduct = mcrossprod($a);

mrank

Compute the rank of a matrix, using a singular value decomposition. from Lapack.

SCALAR = mrank(PDL, SCALAR(TOL))
TOL: tolerance value, default : mnorm(dims(PDL),inf) * mnorm(PDL) * EPS
my $a = random(10,10);
my $b = mrank($a, 1e-5);

mnorm

Compute norm of real or complex matrix Supports threading.
PDL(norm) = mnorm(PDL, SCALAR(ord));

ord :
0|inf : Infinity norm
1|one : One norm
2|two : norm 2 (default)
3|fro : frobenius norm
my $a = random(10,10);
my $norm = mnrom($a);

mdet

Compute determinant of a general square matrix using LU factorization. Supports threading. Uses getrf or cgetrf from Lapack.

PDL(determinant) = mdet(PDL);
my $a = random(10,10);
my $det = mdet($a);

mposdet

Compute determinant of a symmetric or Hermitian positive definite square matrix using Cholesky factorization. Supports threading. Uses potrf or cpotrf from Lapack.

(PDL, PDL) = mposdet(PDL, SCALAR)
SCALAR : UPPER = 0 | LOWER = 1, default = 0
my $a = random(10,10);
my $det = mposdet($a);

mcond

Compute the condition number (two-norm) of a general matrix.
The condition number (two-norm) is defined:

norm (a) * norm (inv (a)).

Uses a singular value decomposition. Supports threading.

PDL = mcond(PDL)
my $a = random(10,10);
my $cond = mcond($a);

mrcond

Estimate the reciprocal condition number of a general square matrix using LU factorization in either the 1-norm or the infinity-norm.
The reciprocal condition number is defined:

1/(norm (a) * norm (inv (a)))

Supports threading.

PDL = mrcond(PDL, SCALAR(ord))
ord :
0 : Infinity norm (default)
1 : One norm
my $a = random(10,10);
my $rcond = mrcond($a,1);

morth

Return an orthonormal basis of the range space of matrix A.

PDL = morth(PDL(A), SCALAR(tol))
tol : tolerance for determining rank, default: 1e-8 for double else 1e-5
my $a = random(10,10);
my $ortho = morth($a, 1e-8);

mnull

Return an orthonormal basis of the null space of matrix A.

PDL = mnull(PDL(A), SCALAR(tol))
tol : tolerance for determining rank, default: 1e-8 for double else 1e-5
my $a = random(10,10);
my $null = mnull($a, 1e-8);

minv

Compute inverse of a general square matrix using LU factorization. Supports inplace and threading. Uses getrf and getri or cgetrf and cgetri from Lapack and return inverse, info in array context.

PDL(inv) = minv(PDL)
my $a = random(10,10);
my $inv = minv($a);

mtriinv

Compute inverse of a triangular matrix. Supports inplace and threading. Uses trtri or ctrtri from Lapack. Returns inverse, info in array context.

(PDL, PDL(info))) = mtriinv(PDL, SCALAR(uplo), SCALAR|PDL(diag))
uplo : UPPER = 0 | LOWER = 1, default = 0
diag : UNITARY DIAGONAL = 1, default = 0
# Assume $a is upper triangular
my $a = random(10,10);
my $inv = mtriinv($a);

BigInteger is an arbitrary length integer extension module for Perl.

SYNOPSIS

use Math::BigInteger;

The BigInteger extension module gives access to Eric Youngs bignum library. This provides a faster alternative to the Math::BigInt library.
The basic object in this library is a BigInteger. It is used to hold a single large integer.

It is not intended that this package be used directly, but instead be used by a wrapper package, such as the Math::BigInteger class.

FUNCTIONS

Many of the following functions can be used in two styles, by calling the function on an object, or by calling the function explicitly; for example, here are two ways of assigning to $a the sum of $b and $c:

$a->add($b, $c);
or

BigInteger::add($a, $b, $c);

Creation/Destruction routines.

new
my $bi = new BigInteger; # Create a new BigInteger object.
clone
my $b = $a->clone();

Create a new BigInteger object from another BigInteger object.

copy
copy($a, $b);

Copy one BigInteger object to another.

save
my $data = $bi->save();

Save a BigInteger object as a MSB-first string.

restore
my $bi = restore BigInteger $data;

Create a new BigInteger object from a MSB-first string.

Comparison functions

ucmp
ucmp($a, $b);

Return -1 if $a is less than $b, 0 if $a and $b are the same and 1 is $a is greater than $b. This is an unsigned comparison.

cmp
cmp($a, $b);

Return -1 if $a is less than $b, 0 if $a and $b are the same and 1 is $a is greater than $b. This is a signed comparison.

Arithmetic Functions

inc $bi->inc();

Increment $bi by one:

dec $bi->dec();

Decrement $bi by one:

add
$r->add($a, $b);

Add $a and $b and return the result in $r.

mul
$r->mul($a, $b);

Multiply $a by $b and return the result in $r. Note that $r must not be the same object as $a or $b.

div
div($dv, $rem, $m, $d);

Divide $m by $d and return the result in $dv and the remainder in $rem. Either of $dv or $rem can be undef, in which case that value is not returned.

mod
$rem->mod($m, $d);

Find the remainder of $m divided by $d and return it in $rem. This function is more efficient than div.

lshift
$r->lshift($a, $n);

Shift $a left by $n bits.

lshift1
$r->lshift1($a);

Shift $a left by 1 bit. This form is more efficient than lshift($r, $a, 1).

rshift
$r->rshift($a, $n);

Shift $a right by $n bits.

rshift1
$r->rshift1($a);

Shift $a right by 1 bit. This form is more efficient than rshift($r, $a, 1).

mod_exp
$r->mod_exp($a, $p, $mod);

Raise $a to the $p power and return the remainder into $r when divided by $m.

modmul_recip
modmul_recip($r, $x, $y, $m, $i, $nb);

This function is used to perform an efficient mod_mul operation. If one is going to repeatedly perform mod_mul with the same modulus is worth calculating the reciprocal of the modulus and then using this function. This operation uses the fact that a/b == a*r where r is the reciprocal of b. On modern computers multiplication is very fast and big number division is very slow. $x is multiplied by $y and then divided by $m and the remainder is returned in $r. $i is the reciprocal of $m and $nb is the number of bits as returned from reciprocal. This function is used in mod_exp.

mul_mod
$r->mul_mod($a, $b, $m);

Multiply $a by $b and return the remainder into $r when divided by $m.
reciprical
$r->reciprical($m);

Return the reciprocal of $m into $r.

Miscellaneous Routines

num_bits
my $size = $bi->numbits();

Return the size (in bits) of the BigInteger.

gcd
$r->gcd($a, $b);

$r has the greatest common divisor of $a and $b.

inverse_modn
$r->inverse_modn($a, $n);

This function creates a new BigInteger and returns it in $r. This number is the inverse mod $n of $a. By this it is meant that the returned value $r satisfies (a*r)%n == 1. This function is used in the generation of RSA keys.

Math::Cephes is a Perl interface to the cephes math library.

SYNOPSIS

use Math::Cephes qw(:all);

This module provides an interface to over 150 functions of the
cephes math library of Stephen Moshier. No functions are exported
by default, but rather must be imported explicitly, as in

use Math::Cephes qw(sin cos);

There are a number of export tags defined which allow
importing groups of functions:
use Math::Cephes qw(:constants);
imports the variables

$PI : 3.14159265358979323846 # pi
$PIO2 : 1.57079632679489661923 # pi/2
$PIO4 : 0.785398163397448309616 # pi/4
$SQRT2 : 1.41421356237309504880 # sqrt(2)
$SQRTH : 0.707106781186547524401 # sqrt(2)/2
$LOG2E : 1.4426950408889634073599 # 1/log(2)
$SQ2OPI : 0.79788456080286535587989 # sqrt( 2/pi )
$LOGE2 : 0.693147180559945309417 # log(2)
$LOGSQ2 : 0.346573590279972654709 # log(2)/2
$THPIO4 : 2.35619449019234492885 # 3*pi/4
$TWOOPI : 0.636619772367581343075535 # 2/pi

As well, there are 4 machine-specific numbers available:

$MACHEP : machine roundoff error
$MAXLOG : maximum log on the machine
$MINLOG : minimum log on the machine
$MAXNUM : largest number represented
use Math::Cephes qw(:trigs);
imports

acos: Inverse circular cosine
asin: Inverse circular sine
atan: Inverse circular tangent (arctangent)
atan2: Quadrant correct inverse circular tangent
cos: Circular cosine
cosdg: Circular cosine of angle in degrees
cot: Circular cotangent
cotdg: Circular cotangent of argument in degrees
hypot: hypotenuse associated with the sides of a right triangle
radian: Degrees, minutes, seconds to radians
sin: Circular sine
sindg: Circular sine of angle in degrees
tan: Circular tangent
tandg: Circular tangent of argument in degrees
cosm1: Relative error approximations for function arguments near unity
use Math::Cephes qw(:hypers);
imports

acosh: Inverse hyperbolic cosine
asinh: Inverse hyperbolic sine
atanh: Inverse hyperbolic tangent
cosh: Hyperbolic cosine
sinh: Hyperbolic sine
tanh: Hyperbolic tangent
use Math::Cephes qw(:explog);
imports

exp: Exponential function
expxx: exp(x*x)
exp10: Base 10 exponential function (Common antilogarithm)
exp2: Base 2 exponential function
log: Natural logarithm
log10: Common logarithm
log2: Base 2 logarithm
log1p,expm1: Relative error approximations for function arguments near unity.
use Math::Cephes qw(:cmplx);
imports

new_cmplx: create a new complex number object
cabs: Complex absolute value
cacos: Complex circular arc cosine
cacosh: Complex inverse hyperbolic cosine
casin: Complex circular arc sine
casinh: Complex inverse hyperbolic sine
catan: Complex circular arc tangent
catanh: Complex inverse hyperbolic tangent
ccos: Complex circular cosine
ccosh: Complex hyperbolic cosine
ccot: Complex circular cotangent
cexp: Complex exponential function
clog: Complex natural logarithm
cadd: add two complex numbers
csub: subtract two complex numbers
cmul: multiply two complex numbers
cdiv: divide two complex numbers
cmov: copy one complex number to another
cneg: negate a complex number
cpow: Complex power function
csin: Complex circular sine
csinh: Complex hyperbolic sine
csqrt: Complex square root
ctan: Complex circular tangent
ctanh: Complex hyperbolic tangent
use Math::Cephes qw(:utils);
imports

cbrt: Cube root
ceil: ceil
drand: Pseudorandom number generator
fabs: Absolute value
fac: Factorial function
floor: floor
frexp: frexp
ldexp: multiplies x by 2**n.
lrand: Pseudorandom number generator
lsqrt: Integer square root
pow: Power function
powi: Real raised to integer power
round: Round double to nearest or even integer valued double
sqrt: Square root
use Math::Cephes qw(:bessels);
imports

i0: Modified Bessel function of order zero
i0e: Modified Bessel function of order zero, exponentially scaled
i1: Modified Bessel function of order one
i1e: Modified Bessel function of order one, exponentially scaled
iv: Modified Bessel function of noninteger order
j0: Bessel function of order zero
j1: Bessel function of order one
jn: Bessel function of integer order
jv: Bessel function of noninteger order
k0: Modified Bessel function, third kind, order zero
k0e: Modified Bessel function, third kind, order zero, exponentially scaled
k1: Modified Bessel function, third kind, order one
k1e: Modified Bessel function, third kind, order one, exponentially scaled
kn: Modified Bessel function, third kind, integer order
y0: Bessel function of the second kind, order zero
y1: Bessel function of second kind of order one
yn: Bessel function of second kind of integer order
yv: Bessel function Yv with noninteger v
use Math::Cephes qw(:dists);
imports

bdtr: Binomial distribution
bdtrc: Complemented binomial distribution
bdtri: Inverse binomial distribution
btdtr: Beta distribution
chdtr: Chi-square distribution
chdtrc: Complemented Chi-square distribution
chdtri: Inverse of complemented Chi-square distribution
fdtr: F distribution
fdtrc: Complemented F distribution
fdtri: Inverse of complemented F distribution
gdtr: Gamma distribution function
gdtrc: Complemented gamma distribution function
nbdtr: Negative binomial distribution
nbdtrc: Complemented negative binomial distribution
nbdtri: Functional inverse of negative binomial distribution
ndtr: Normal distribution function
ndtri: Inverse of Normal distribution function
pdtr: Poisson distribution
pdtrc: Complemented poisson distribution
pdtri: Inverse Poisson distribution
stdtr: Students t distribution
stdtri: Functional inverse of Students t distribution
use Math::Cephes qw(:gammas);
imports

fac: Factorial function
gamma: Gamma function
igam: Incomplete gamma integral
igamc: Complemented incomplete gamma integral
igami: Inverse of complemented imcomplete gamma integral
psi: Psi (digamma) function
rgamma: Reciprocal gamma function
use Math::Cephes qw(:betas);
imports

beta: Beta function
incbet: Incomplete beta integral
incbi: Inverse of imcomplete beta integral
lbeta: Natural logarithm of |beta|
use Math::Cephes qw(:elliptics);
imports

ellie: Incomplete elliptic integral of the second kind
ellik: Incomplete elliptic integral of the first kind
ellpe: Complete elliptic integral of the second kind
ellpj: Jacobian Elliptic Functions
ellpk: Complete elliptic integral of the first kind
use Math::Cephes qw(:hypergeometrics);
imports

hyp2f0: Gauss hypergeometric function F
hyp2f1: Gauss hypergeometric function F
hyperg: Confluent hypergeometric function
onef2: Hypergeometric function 1F2
threef0: Hypergeometric function 3F0
use Math::Cephes qw(:misc);
imports

airy: Airy function
bernum: Bernoulli numbers
dawsn: Dawsons Integral
ei: Exponential integral
erf: Error function
erfc: Complementary error function
expn: Exponential integral En
fresnl: Fresnel integral
plancki: Integral of Plancks black body radiation formula
polylog: Polylogarithm function
shichi: Hyperbolic sine and cosine integrals
sici: Sine and cosine integrals
simpson: Simpsons rule to find an integral
spence: Dilogarithm
struve: Struve function
vecang: angle between two vectors
zeta: Riemann zeta function of two arguments
zetac: Riemann zeta function
use Math::Cephes qw(:fract);
imports

new_fract: create a new fraction object
radd: add two fractions
rmul: multiply two fractions
rsub: subtracttwo fractions
rdiv: divide two fractions
euclid: finds the greatest common divisor