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

PDL::LinearAlgebra::Trans is a Linear Algebra based transcendental functions for PDL.

SYNOPSIS

use PDL::LinearAlgebra::Trans;

$a = random (100,100);
$sqrt = msqrt($a);

This module provides some matrix transcendental functions. Moreover it provides sec, asec, sech, asech, cot, acot, acoth, coth, csc, acsc, csch, acsch.

EOD

pp_add_exported(, mexp mexpts mlog msqrt mpow mcos msin mtan msec mcsc mcot mcosh msinh mtanh msech mcsch mcoth macos masin matan masec macsc macot macosh masinh matanh masech macsch macoth sec asec sech asech cot acot acoth coth mfun csc acsc csch acsch toreal pi);

pp_def(geexp, Pars => [io,phys]A(n,n);int deg();scale();[io]trace();int [o]ns();int [o]info(), GenericTypes => [D], Code => /* ----------------------------------------------------------------------| int dgpadm_(integer *ideg, integer *m, double *t, double *h__, integer *ldh, double *wsp, integer *lwsp, integer *ipiv, integer *iexph, integer *ns, integer *iflag)

Math::Symbolic::MiscAlgebra contains miscellaneous algebra routines like det().

SYNOPSIS

use Math::Symbolic qw/:all/;
use Math::Symbolic::MiscAlgebra qw/:all/; # not loaded by Math::Symbolic

@matrix = ([x*y, z*x, y*z],[x, z, z],[x, x, y]);
$det = det @matrix;

@vector = (x, y, z);
$solution = solve_linear(@matrix, @vector);

This module provides several subroutines related to algebra such as computing the determinant of quadratic matrices, solving linear equation systems and computation of Bell Polynomials.

Please note that the code herein may or may not be refactored into the OO-interface of the Math::Symbolic module in the future.

You may choose to have any of the following routines exported to the calling namespace. :all tag exports all of the following:

det
linear_solve
bell_polynomial

GeoGebra project is a dynamic mathematics software that joins geometry, algebra, and calculus.

Two views are characteristic of GeoGebra: an expression in the algebra window corresponds to an object in the geometry window and vice versa

Closebracket let you define multiple shell actions in a single command to speed up the typing of the most repetitive shell commands. The command name of Closebracket is `] and `][, thats because these characters are near the "Enter" key and it is easy to type them fast.
`] stands for "primary fire", while `][ is the secondary one.
After few days youll find Closebracket very additive.
Closebracket is dedicated to the God of Laziness, may He bless you (when He feels to do it).
Installation:
Download the latest tarball from http://www.freaknet.org/alpt/src/utils/closebracket/tarball/
Use the ./install.sh script to install it. It will copy the files in ~/.closebracket and add some aliases in ~/.bashrc
Usage:
Since too many words are needed to describe all the actions that are included
by default, Ill show you them by examples.
Keep in mind that you can tune them and define your own actions by editing the
~/.closebracket/closebracket.conf file.
In the first line closebracket is used to activate an action. The second line is the equivalent of that action.
##
### Basic shell movements
##
$ ]
$ ls # ls current directory
$ ][
$ cd # cd to home
$ ] dir/
$ cd dir/
$ ][ dir/
$ ls dir/
$ ][ file
$ cat file
$ ][ non_existent_file
$ vim non_existent_file
##
### Remote shells
##
$ ] shell # With closebracket you keep the list of the
$ ssh shell.expanded.org # name of your remote shells in
# ~/.closebracket/shells. In this case we put
# "shell.expanded.org" in the list.
# Closebracket searches the closest match with
# the word you typed and then use that as the
# remote shell hostname.
$ ] shell:file
$ vim scp://shell.expanded.org/file # Beware of the Vim power
$ ] user@shell:/path/file
$ ] scp://user@shell.expanded.org/path/file
$ ][ shell:dir/
$ scp -r shell.expanded.org:dir/ .
$ ][ shell:dir/ local_dir/
$ scp -r shell.expanded.org:dir/ local_dir/
$ ][ file1 file3 dir1 dir3 shell:remote_dir/
$ scp -r file1 file3 dir1 dir3 shell.expanded.org:remote_dir/
##
### URLs, mail addresses and algebra
##
$ ] http://URL
$ firefox http://URL
$ ][ http://URL
$ wget http://URL
$ ] email@address.org
$ mutt email@address.org
$ ] 2*2+1-21%2^2
$ echo 2*2+1-21%2^2 | bc -l
$ ] "2*2+1*sqrt(400)/l(2)^2" # if you want to use parentesis you
$ echo "2*2+1*sqrt(400)/l(2)^2" | bc -l # have to use quotes ;(
##
### File type based on extension
##
$ ] pack.tar.gz # This works for .tar, .tar.bz2,
$ tar xfz pack.tar.gz; cd pack/ # .tar.gz, .tgz, .zip, .rar
# If the directory unpacked isnt the
# same of the filename of the tarball
# it understands that ^_-
$ ] movie_or_mp3.ogg # .avi, .mp3, .wav, .wmv, ...
$ mplayer movie_or_mp3.ogg
$ ] image.jpg # .jpg, .png, .gif, ...
$ gqview image.jpg # if you are in tty it launches `seejpeg
$ ][ image.jpg
$ gimp image.jpg
$ ] file.htm # .htm, .html, .php, ...
$ firefox file.htm # if you are in tty it launches `links instead.
Enhancements:
- ] file:line is now equivalent to executing "vim file +line".
- The "untarra script will now repair broken tar/zip/rar archives, i.e. archives that would decompress files in ./.

Geo::Raster is a Perl extension for raster algebra.

SYNOPSIS

use Geo::Raster;
or
use Geo::Raster qw(:types);
or
use Geo::Raster qw(:types :logics :db);

Geo::Raster is an object-oriented interface to libral, a C library for rasters and raster algebra. Geo::Raster makes using libral easy and adds some very useful functionality to it. libral rasters are in-memory for fast and easy processing. libral rasters can be created from GDAL rasters. GDAL provides access to rasters in many formats.

Geo::Raster also adds the required functionality to display rasters in Gtk2::Ex::Geo.

Each cell in raster/grid is assumed to be a square.

The grid point represents the center of the cell and not the area of the cell (when such distinction needs to be made). TODO: This needs more attention.

A grid is indexed like this:

j = 0..N-1
------------------>
.
i = 0..M-1 .
.
.
V
there is also a (x,y) world coordinate system
maxY ^
.
.
y .
minY .
------------------>
minX maxX
x

minX is the left edge of first cell in line. maxX is the right edge of the last cell in a line. minY and maxY represent similarly the boundaries of the raster.

dnAnalytics Numerical Library is a numerical library for the .NET Framework. The library is written in C# and is available as a fully managed library, but also provides an interface to native BLAS and LAPACK libraries.
dnAnalytics Numerical Library is compatible with Mono and has been tested on Windows, and various Linux distributions. The current release includes matrix, vector and complex number classes, and support for basic linear algebra routines (such as LU, Cholesky, QR, Levinson, and SVD).
We will be adding optimization, calculus, random number, statistical, option pricing, genetic programming, and neural network components in the future.
Main features:
- Fully managed mode.
- Optional support for the native numerical libraries:
- Intel Math Kernel Library (MKL)
- AMD Core Math Library (ACML)
- ATLAS and CLAPACK
- Support for sparse matrices and vectors.
- Dense and sparse solvers.
- QR, LU, SVD, Cholesky, Levinson, and Symmetric Levinson decomposition classes.
- Matrix IO classes that read and write matrices form/to Matrix Market and delimited files.
- Complex and "special" math routines.
- Overload mathematical operators to simplify complex expressions.
- Runs under Microsoft Windows and Linux.
- Works with Mono.