Free blas software for linux

Lush project is an object-oriented programming language designed for researchers, experimenters, and engineers interested in large-scale numerical and graphic applications.
Lush is designed to be used in situations where one would want to combine the flexibility of a high-level, weakly-typed interpreted language, with the efficiency of a strongly-typed, natively-compiled language, and with the easy integration of code written in C, C++, or other languages.
Lush is Free Software (under the GPL license). It runs on GNU/Linux, Mac OS-X, Solaris, Irix, and on Windows under Cygwin.
Lush can be used advantageously for projects where one would otherwise use a combination of an interpreted language like Matlab, Python, Perl, S+, or even (gasp!) BASIC, and a compiled language like C.
Lush brings the best of both worlds by wrapping three languages into one: (1) a weakly-typed, garbage-collected, dynamically scoped, interpreted language with a simple Lisp-like syntax, (2) a strongly-typed, lexically-scoped compiled language that uses the same Lisp-like syntax, and (3) the C language, which can be freely mixed with Lush code within a single program, even within a single function. It sounds complicated, but it is not. In fact, Lush is designed to be very simple to learn and easy to use.
If you do research and development in signal processing, image processing, machine learning, computer vision, bio-informatics, data mining, statistics, simulation, optimization, or artificial intelligence, and feel limited by Matlab and other existing tools, Lush is for you. If you want a simple environment to experiment with graphics, video, and sounds, Lush is for you.
Main features:
- A very clean, simple, and easy to learn Lisp-like syntax.
- A compiler that produces very efficient C code and relies on the C compiler to produce efficient native code (no inefficient bytecode or virtual machine).
- An easy way to interface C functions and libraries, and a powerful dynamic linker/loader for object files or libraries (.o, .a and .so files) written in other compiled languages.
- The ability to freely mix Lisp and C in a single function.
- A powerful set of vector/matrix/tensor operations.
- A huge library of over 10,000 numerical routines, including full interfaces to GSL, LAPACK, and BLAS.
- A library of image and signal processing routines.
- An extensive set of graphic routines, including an object-oriented GUI toolkit, an interface to OpenGL/GLU/GLUT, and the OpenInventor scene rendering engine.
- An interface to the Simple Directmedia Layer (SDL) multimedia library, including a sprite class with pixel-accurate collision detection (perfect for 2D games).
- Sound and video grabbing (using ALSA and Video4Linux).
- Several libraries for machine learning, neural net, statistical estimation, Hidden Markov Models (gblearn2, Torch, HTK, SVM).
- libraries for computer vision (OpenCV, Intels open source Vision Library), and 3D scene rendering (OpenInventor).
- bindings to the JavaVM API and to the Python C API.
- Lush is Free Software.

USF FlashMob is a Live CD made by FlashMobComputing.org
USF FlashMob RC4 contains updates that we made to the server code the night before flashmob day. This will allow power users to run larger flashmobs and configure individual nodes with different processor types. In addition we have released the source code for USF_FlashMob_RC_4 (source).
We have put the source for the FlashMob ISO image into the following directories:
- kernel: The patched and modified kernel Linux kernel (2.4.25) that we use on the CD. Kernel modules added to the CD.
- fmtools: The code that runs the FlashMob (fm_* programs).
- mpi: The source for the implementations of MPI on the CD. These are unmodified versions of LAM-MPI and LAMPI.
- blas: The source we used for the ATLAS BLAS libraries. This is unmodified.
- hpl: The modified versions of HPL we used on the CD.
Documentation to build a FlashMob CD does not exist yet. Take a look at the morphix scripts in fmtools. These will let you "unpack" and "pack" a FlashMob CD.

ATLAS (Automatically Tuned Linear Algebra Software) project is an ongoing research effort focusing on applying empirical techniques in order to provide portable performance.
ATLAS provides C and Fortran77 interfaces to a portably efficient BLAS implementation, as well as a few routines from LAPACK.
Whats New in 3.7.37 Development Release:
- Some smoothing operations to allow easier use of Windows compilers, and many major bugfixes (primarily in system analysis for configuration).

Template Numerical Toolkit (TNT) is a collection of interfaces and reference implementations of numerical objects useful for scientific computing in C++.
The toolkit defines interfaces for basic data structures, such as multidimensional arrays and sparse matrices, commonly used in numerical applications. Template Numerical Toolkits goal is to provide reusable software components that address many of the portability and maintennace problems with C++ codes.
TNT provides a distinction between interfaces and implementations of TNT components. For example, there is a TNT interface for two-dimensional arrays which describes how individual elements are accessed and how certain information, such as the array dimensions, can be used in algorithms; however, there can be several implementations of such an interface: one that uses expression templates, or one that uses BLAS kernels, or another that is instrumented to provide debugging information.
By specifying only the interface, applications codes may utilize such algorithms, while giving library developers the greatest flexibility in employing optimization or portability strategies.
TNT Data Structures
- C-style arrays
- Fortran-style arrays
- Sparse Matrices
- Vector/Matrix
TNT utilities
- array I/O
- math routines (hypot(), sign(), etc.)
- Stopwatch class for timing measurements
Libraries that utilize TNT
- JAMA: a linear algebra library with QR, SVD, Cholesky and Eigenvector solvers.
- old (pre 1.0) TNT routines for LU, QR, and Eigenvalue problems

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.

exmats goal is to provide an easy to use, yet very efficient matrix library. Overloaded operators allow to write algebraic expressions like v=A*u +u in C++, instead of bunch of boring functions.
This syntactic sugar comes with runtime cost, one way to eliminate the overhead is to use Expression Templates (ET).
Using ET, we can further boost up the efficient by analyzing the expression at compile time and generate the most efficient code for that expression.
This library is still under early development.
Main features:
Generic:
- The element type of the matrix is generic, it can be any type of the C++ build-in type like int, float, double.
- Other types like complex or arbitrary precision type can also be used as the element type.
- Matrix expression can be make up of any element type, that is, an integer matrix can be added to a float matrix and then assign to a double matrix.
Easy to use:
- You can write matrix expression using +, -, *, / operators as usual mathematic notation.
Safe:
- There are 3 levels of error checking policy you can apply on each class of matrix.
Efficient:
- Specialized, hand made comparable optimized code can be generated for different expressions.
- SIMD code can be used on small size matrix.
- Provide a interface to use BLAS as the math kernel, which is highly optimized for out of cache operations.
Enhancements:
- Cross product bug fixed
- Added determinant, minor view, cofactor view and adjoint view for matrix
- Added support for column major memory layout
- Helper macro for deriving ET enabled sub-class from exmat::Mat easily
- Array version for approximated math

HPL is a software package that solves a (random) dense linear system in double precision (64 bits) arithmetic on distributed-memory computers. It can thus be regarded as a portable as well as freely available implementation of the High Performance Computing Linpack Benchmark.

The algorithm used by HPL can be summarized by the following keywords: Two-dimensional block-cyclic data distribution - Right-looking variant of the LU factorization with row partial pivoting featuring multiple look-ahead depths - Recursive panel factorization with pivot search and column broadcast combined - Various virtual panel broadcast topologies - bandwidth reducing swap-broadcast algorithm - backward substitution with look-ahead of depth 1.

The HPL package provides a testing and timing program to quantify the accuracy of the obtained solution as well as the time it took to compute it. The best performance achievable by this software on your system depends on a large variety of factors.

Nonetheless, with some restrictive assumptions on the interconnection network, the algorithm described here and its attached implementation are scalable in the sense that their parallel efficiency is maintained constant with respect to the per processor memory usage.

The HPL software package requires the availibility on your system of an implementation of the Message Passing Interface MPI (1.1 compliant). An implementation of either the Basic Linear Algebra Subprograms BLAS or the Vector Signal Image Processing Library VSIPL is also needed. Machine-specific as well as generic implementations of MPI, the BLAS and VSIPL are available for a large variety of systems.

Pyvox is a set of software tools for medical image processing, particularly skull stripping and segmentation of MR brain images; tools to support other applications may be added later.
These tools are intended to support researchers who need to prototype new image analysis algorithms or to develop automated image analysis tools for specific image analysis applications. The sequence of processing operations is specified through the scripting language Python, which can be used interactively or in command files; the core image processing algorithms are written in C for efficient processing of volume images.
Important design criteria for Pyvox include: script files and data files are portable across multiple Unix platforms, including Linux and Mac OS X; suitable for rapid prototyping of new algorithms and analysis protocols; suitable for efficient, automated processing of the finished analysis protocols; and easily extensible by programmers outside the original development team.
Pyvox is being distributed under an Open Source license which permits free use, modification, and redistribution provided that proper credit is given.
Main features:
Medical Image Processing
- Pyvox is designed primarily for medical image processing, because that is what the author needs to do most; other applications of volume images are no doubt possible, but their needs come second.
Rapid Prototyping
- Pyvox should be suitable for rapid prototyping of new algorithms and analysis protocols. To do this, Pyvox is implemented as a extension to the Python language. Python is a high-level object-oriented scripting language which can be used interactively or in programmed scripts and which is designed to be easily extensible in C.
Efficient Execution
- Pyvox should also be suitable for efficient, automated processing of the finished analysis protocols. To do this, the core image processing functions are written in C, which is more efficient than Python.
Software Portability
- The script files that define the analysis protocols and the programs that they invoke should be portable across multiple Unix platforms (including Linux and Mac OS X). To meet this requirement, Pyvox is written to comply with the usual standards, including ANSI C, Posix, and the X Window System.
Data Portability
- The image files and other data files should also be portable across multiple Unix platforms. In particular, it should be possible to create an image file on a big-endian machine (e.g. Sparc), copy it to a little-endian machine (e.g. Pentium), and further process that image without needing to do any conversion of the file. This is accomplished through a set of portable C functions that can read and write data in specified external formats, converting as necessary to or from the platform-native format.
Open-Source Development
- Pyvox should also be easily extensible by programmers outside the original development team. This is accomplished by following good software engineering practice in documenting the software for later maintenance and extensions.
Installation:
If all the prerequisites (Python 2.1, X11 Window System, Tcl/Tk, Motif or Lesstif, and optionally LAPACK and BLAS) are present and installed in the right places, the command sequence
./configure
make
make regress
make install
will usually compile, regression test, and install Pyvox. If that doesnt work, see the Installation chapter of the Pyvox Reference Manual (doc/pyvox.pdf or doc/pyvox.tex) for a detailed installation procedure.
Enhancements:
- The interface for constructing convolution kernels has been completely redesigned and now supports the dynamic modification of kernels.
- Internal types now have min and max attributes which contain the minimum and maximum possible finite positive values representable in that type.