Free lapack software for linux

LAPACK is a linear algebra library, based on LINPACK and EISPACK.
LAPACK is written in Fortran77 and provides routines for solving systems of simultaneous linear equations, least-squares solutions of linear systems of equations, eigenvalue problems, and singular value problems.
The associated matrix factorizations (LU, Cholesky, QR, SVD, Schur, generalized Schur) are also provided, as are related computations such as reordering of the Schur factorizations and estimating condition numbers. Dense and banded matrices are handled, but not general sparse matrices. In all areas, similar functionality is provided for real and complex matrices, in both single and double precision.
If youre uncertain of the LAPACK routine name to address your applications needs, check out the LAPACK Search Engine.
The original goal of the LAPACK project was to make the widely used EISPACK and LINPACK libraries run efficiently on shared-memory vector and parallel processors.
On these machines, LINPACK and EISPACK are inefficient because their memory access patterns disregard the multi-layered memory hierarchies of the machines, thereby spending too much time moving data instead of doing useful floating-point operations.
LAPACK addresses this problem by reorganizing the algorithms to use block matrix operations, such as matrix multiplication, in the innermost loops. These block operations can be optimized for each architecture to account for the memory hierarchy, and so provide a transportable way to achieve high efficiency on diverse modern machines. We use the term "transportable" instead of "portable" because, for fastest possible performance, LAPACK requires that highly optimized block matrix operations be already implemented on each machine.
LAPACK routines are written so that as much as possible of the computation is performed by calls to the Basic Linear Algebra Subprograms (BLAS). While LINPACK and EISPACK are based on the vector operation kernels of the Level 1 BLAS, LAPACK was designed at the outset to exploit the Level 3 BLAS -- a set of specifications for Fortran subprograms that do various types of matrix multiplication and the solution of triangular systems with multiple right-hand sides.
Because of the coarse granularity of the Level 3 BLAS operations, their use promotes high efficiency on many high-performance computers, particularly if specially coded implementations are provided by the manufacturer.
Highly efficient machine-specific implementations of the BLAS are available for many modern high-performance computers. For details of known vendor- or ISV-provided BLAS, consult the BLAS FAQ. Alternatively, the user can download ATLAS to automatically generate an optimized BLAS library for the architecture. A Fortran77 reference implementation of the BLAS in available from netlib; however, its use is discouraged as it will not perform as well as a specially tuned implementation.
Enhancements:
- The BLAS implementation was completed.
- The number of timers accessible was increased.
- Code cleanups and bugfixes were made.

Free Finite Element Package is a modular collection of C libraries which contain numerical methods required when working with linear and quadratic finite elements in two dimensions.

FFEP works on GNU/Linux and is portable to every system where MEML (i.e. LAPACK and BLAS) are available. The goal of FFEP is to provide basic functions for approximating the solution of elliptic and parabolic partial differential equation in two dimensions with Dirichlet and Neumann boundary conditions.

PDL::LinearAlgebra::Complex is a PDL interface to the lapack linear algebra programming library (complex number).

SYNOPSIS

use PDL::Complex
use PDL::LinearAlgebra::Complex;

$a = r2C random (100,100);
$s = r2C zeroes(100);
$u = r2C zeroes(100,100);
$v = r2C zeroes(100,100);
$info = 0;
$job = 0;
cgesdd($a, $job, $info, $s , $u, $v);

This module provide an interface to parts of the lapack library (complex number). These routine accept either float or double piddles.

EOD

pp_defc("gesvd", HandleBad => 0, RedoDimsCode => $SIZE(r) = $PDL(A)->ndims > 2 ? min($PDL(A)->dims[1], $PDL(A)->dims[2]) : 1;, Pars => [io,phys]A(2,m,n); int jobu(); int jobvt(); [o,phys]s(r); [o,phys]U(2,p,q); [o,phys]VT(2,s,t); int [o,phys]info(), GenericTypes => [F,D], Code => generate_code
integer lwork;
char trau, travt;
types(F) %{

extern int cgesvd_(char *jobu, char *jobvt, integer *m, integer *n, float *a,
integer *lda, float *s, float *u, int *ldu,
float *vt, integer *ldvt, float *work, integer *lwork, float *rwork,
integer *info);
float *rwork;
float tmp_work[2];
%}
types(D) %{

extern int zgesvd_(char *jobz,char *jobvt, integer *m, integer *n,
double *a, integer *lda, double *s, double *u, int *ldu,
double *vt, integer *ldvt, double *work, integer *lwork, double *rwork,
integer *info);
double *rwork;
double tmp_work[2];
%}
lwork = ($PRIV(__m_size) < $PRIV(__n_size)) ? 5*$PRIV(__m_size) : 5*$PRIV(__n_size);
types(F) %{
rwork = (float *)malloc(lwork * sizeof(float));
%}
types(D) %{
rwork = (double *)malloc(lwork * sizeof(double));
%}
lwork = -1;


switch ($jobu())
{
case 1: trau = A;
break;
case 2: trau = S;
break;
case 3: trau = O;
break;
default: trau = N;
}
switch ($jobvt())
{
case 1: travt = A;
break;
case 2: travt = S;
break;
case 3: travt = O;
break;
default: travt = N;
}



$TFD(cgesvd_,zgesvd_)(
&trau,
&travt,
&$PRIV(__m_size),
&$PRIV(__n_size),
$P(A),
&$PRIV(__m_size),
$P(s),
$P(U),
&$PRIV(__p_size),
$P(VT),
&$PRIV(__s_size),
&tmp_work[0],
&lwork,
rwork,
$P(info));

lwork = (integer )tmp_work[0];
{
types(F) %{

float *work = (float *)malloc(2*lwork * sizeof(float));
%}
types(D) %{

double *work = (double *)malloc(2*lwork * sizeof(double));
%}
$TFD(cgesvd_,zgesvd_)(
&trau,
&travt,
&$PRIV(__m_size),
&$PRIV(__n_size),
$P(A),
&$PRIV(__m_size),
$P(s),
$P(U),
&$PRIV(__p_size),
$P(VT),
&$PRIV(__s_size),
work,
&lwork,
rwork,
$P(info));
free(work);
}
free(rwork);
,
Doc=>

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.

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

TBCI is a C++ library which provides classes for Matrices, Vectors, etc., and defines operations on them such as additions, multiplications, etc. There are many Matrix classes providing specializations for different sparse matrices.
They all feature a similar interface. TBCI comes with an extensive set of solvers for linear systems and an interface to lapack libraries.
It uses the temporary base class idiom, which avoids unnecessary copying of data by having a notion of real and temporary objects which are treated differently with respect to assignment and copy ctor.
Enhancements:
- A number of little bugs have been fixed.
- The CSCMatrix::setval() function only worked with proper input sorting; malloc_cache can now extend empty vectors; GMres and SVD are safer against badly prepared input.
- The sources compile fine now with -pedantic.
- There are also a few minor feature enhancements: All matrices now have a transpose() member.
- Error checking messages have been improved.
- The SMP code now has bind_threads() support, and better autotools support has been added.
- The RPMs for i386 now contain libraries both with and without SSE2 support.

FLENS is:
- a C++ interface for BLAS and LAPACK
- an extremely convenient C++ interface for BLAS and LAPACK
- an extremely efficient C++ interface to BLAS and LAPACK:
- There is no run-time overhead compared to directly calling BLAS and LAPACK.
- There are no obscure side-effects like internal creation of temporary objects
FLENS is NOT:
- just a C++ interface for BLAS and LAPACK! It is more than that:
- it is extendable: e.g. easy integration of user-defined matrix/vector types.
- it is flexible: e.g. generic programming of numerical algorithms.
FLENS is DEFINITELY NOT:
- ... a replacement for Matlab. While FLENS adopted some nice notations it has a completely different intension. Ok, Matlab uses BLAS and LAPACK just like FLENS. But it uses only a subset. Matlab basically has only two data types and these are general matrices and sparse matrices. If you have matrices with band structure Matlab will not use those BLAS and LAPACK routines that exploit this structure.
- Just to make sure you get us right: We do not want to bash Matlab. It is a great tool. But you have to figure out whats the right tool for your job. Matlab is a great tool because it is very easy to use and it allows rapid prototyping. For many people the performance of Matlab is Ok. For those people there might be absolutely no reason to even consider using FLENS.
- FLENS gives you full control about whats going on behind the scene. It provides (for example) general, triangular, symmetric and hermitian matrix types. Elements of these matrices can be stored in different formats: full storage (store all m x n elements), band storage (store only diagonals of a banded matrix), packed storage (store only the upper or lower triangular part).
- FLENS implements a view concept: You can define that a vector references a row, column or diagonal of a matrix. You can define, that elements of a triangular matrix are those stored in the upper triangular part of a general matrix,...
Enhancements:
- This release adds sparse matrix types.
- There are two types for general and symmetric matrices.
- For element storage, the "compressed row storage" format is used: the elements can be initialized in random (i.e. arbitrary) order.
- The tutorial slides have been extended with a demonstration of how to use sparse matrices, more details about how linear algebra expression are evaluated by FLENS, and an example on how to extend FLENS with new matrix/vector types.

FlowDesigner is a free (GPL/LGPL) data flow oriented development environment. It can be used to build complex applications by combining small, reusable building blocks. In some ways, it is similar to both Simulink and LabView, but is hardly a clone of either.
FlowDesigner features a RAD GUI with a visual debugger. Although FlowDesigner can be used as a rapid prototyping tool, it can still be used for building real-time applications such as audio effects processing. Since FlowDesigner is not really an interpreted language, it can be quite fast.
It is written in C++ and features a plugin mechanism that allows plugins/toolboxes to be easiliy added.
Main features:
- Signal processing
- Audio processing (DSP)
- Vector quantization
- Neural network
- Fuzzy logic
- Real-time audio effect processing (pre-alpha)
- Linear algebra using LAPACK (pre-alpha)
- Octave plug-in (pre-alpha)
- Robotics