Mostly Numerical Analysis and Number Crunching

Last updated and checked on Mar. 24, 2004, only 8 short years since the last update on July 2, 1996.

Go to a specific package or browse the lot.

• Algae
• Basis
• Cactus
• CWP/SU
• Euler
• Fudgit
• Gnans
• Gnatlab
• GNUDL
• GSL
• Guile-numerics
• JNumeric
• Lush
• Maxima
• Numarray
• NumExp
• Octave
• Omega Project
• Ox
• PACT
• PDL
• PETSc
• PsiLAB
• Ptolemy
• R
• RLaB
• ROOT
• SciCraft
• Scilab
• SCIrun
• SLATEC
• Tela
• VisAD
• XLispStat
• Yorick

Algae

Significant/unique Algae features include:

• speed that is generally (and often significantly) faster than MATLAB (at least until recent major improvements in that product), RLaB and Octave;
• the capability of storing arrays in sparse form wherein only the nonzero elements and their locations are stored;
• persistent labels for each dimension of a matrix or vector (i.e. a vector element can have a label such as `mojo rate' to distinguish it from the other 5000 elements);
• scalars, vectors and arrays as distinct data types;
• and a statistical profiling capability that can show, by file and line number, where the code spends most of its time.

Algae is distributed as source code and also in binary form for Linux ELF platforms. Other packages that aren't required but are quite helpful and will be used by the package if available are Gnuplot, BLAS (although the generic version is supplied with the package), LAPACK (with the generic version of this also supplied with the package), and the GNU Readline library. Algae will also recognize the proprietary Boeing BCSLIB package. The documentation is supplied in both HTML and GNU Info formats.

[ http://algae.sourceforge.net/

Basis

Basis programs are steerable applications, that is, applications whose behavior can be greatly modified by their users. Basis also contains optional facilities to help authors do their jobs more easily. A library of Basis packages is available that can be easily added to a program. The progammable nature of the application simplifies testing and debugging.

The Basis Language includes variable and function declarations, graphics, several looping and conditional control structures, array syntax, operators for matrix multiplication, dot product, transpose, array or character concatenation, and a stream I/O facility. Data types include real, double, integer, complex, logical, character, chameleon, and structure. There are more than 100 built-in functions, including all the Fortran intrinsics.

Basis' interaction with compiled routines is particularly powerful. When calling a compiled routine from the interactive language, Basis verifies the number of arguments and coerces the types of the actual arguments to match those expected by the function. A compiled function can also call a user-defined function passing arguments through common.

The Basis system includes many facilities designed to ease porting of Fortran codes among the supported platforms, including a Fortran preprocessor, MPPL, and a system for creating Makefiles for multi-platform, multi-directory development.

Basis runs on UNIX and Linux operating systems. It requires Perl 5.0 or later. Basis can be built with NCAR graphics, PGS graphics or with no graphics. If you build basis with PACT, then you can use the interface to PACT's PDB portable self-describing data files. There's an overview article about this package by the chief author, Paul Dubois, in Computers in Physics, Vol. 8, 1994, pp. 70-73.

[ http://basis.llnl.gov/]

Cactus

The name Cactus comes from the design of a central core (or "flesh") which connects to application modules (or "thorns") through an extensible interface. Thorns can implement custom developed scientific or engineering applications, such as computational fluid dynamics. Other thorns from a standard computational toolkit provide a range of computational capabilities, such as parallel I/O, data distribution, or checkpointing.

Cactus runs on many architectures. Applications, developed on standard workstations or laptops, can be seamlessly run on clusters or supercomputers. Cactus provides easy access to many cutting edge software technologies being developed in the academic research community, including the Globus Metacomputing Toolkit, HDF5 parallel file I/O, the PETSc scientific library, adaptive mesh refinement, web interfaces, and advanced visualization tools.

[ http://www.cactuscode.org/]

CCSE Application Suite

• two application codes for adaptively solving time-dependent partial differential equations (a solver for a Hyperbolic system of Conservation Laws (HyperCLaw) and an incompressible flow solver (IAMR)),
• C++ class libraries (BoxLib,AmrLib, and others),
• a 2- and 3-dimensional visualization system (AmrVis),
• a package for post-processing data generated by the above AMR applications (AmrDerive), and
• a single grid, i.e. non-adaptive, application code for solving incompressible flows (VarDen in serial, pVarDen in parallel).

AMR uses block-structured refinement, so that the solution to an AMR calculation is composed of data in multiple non-intersecting rectangular grids at multiple levels with different resolution. The visualization and post-processing tools are specially constructed to efficiently handle this type of data set.

All components of the CCSE Applications Suite except VarDen are designed to execute in parallel using MPI. However, the user has the option of building executables without MPI to run on serial platforms.

[ http://seesar.lbl.gov/ccse/Software/index.html]

CWP/SU

The package is not necessarily restricted to seismic processing tasks, however. A broad suite of wave-related processing can be done with SU, making it a somewhat more general package than the word ``seismic'' implies. SU is intended as an extension of the Unix operating system, and therefore shares many characteristics of the Unix, including Unix flexibility and expandibility. The fundamental Unix philosophy is that all operating system commands are programs run under that operating system. The idea is that individual tasks be identified, and that small programs be written to do those tasks, and those tasks alone.

The core of the Seismic Unix program set performs a broad collection of tasks, which may be viewed as being common to a large collection of research and processing disciplines. Many, however, are purely seismic in nature. The task categories include:

• input/output issues;
• data format conversion;
• setting, viewing and editing trace header fields;
• viewing SU data;
• windowing, sorting and editing data;
• general operations;
• transforming and filtering operations;
• seismic operations on SU data.

[http://www.cwp.mines.edu/cwpcodes/]

Euler

[ http://mathsrv.ku-eichstaett.de/MGF/homes/grothmann/euler/]

Fudgit

[http://packages.debian.org/stable/math/fudgit]

Gnans

[ftp://ftp.uu.net/pub/math/gnans/]

Gnatlab

[ http://www.osl.iu.edu/research/gnatlab/]
[ http://sourceforge.net/projects/gnatlab/]

GNUDL

The useful features of the aforementioned languages planned for replication include the immediate availability of graphing operations for data viewing with well-designed and extensible defaults, the ease and optimization of array operations, the publication quality of output graphics, and the availability on many platforms. General limitations of such languages that the author wants to circumvent include the special-purpose languages developed for each package. GNUDL will use Guile, a Scheme-based utility, as its language. This will allow the use of Scheme as well as a variety of other languages that can be run on top of Scheme to be used for programming applications. Guile also incorporates the Tk toolkit, allowing GUI applications to be custom built. It is planned to used the TeXinfo system for documentation, which will allows several types of documentation formats to be produced from a single source file. GNUDL will provide X Window and PostScript rendering of all plots (perhaps via Ghostview) to provide publication quality graphical output.

GNUDL is in the prototype stage (with alpha version 0.3 released in 2/96). The source code for the prototype version is available and is known to compile on Linux, IRIS and SunOS platforms. Installing GNUDL requires the prior installation of the aforementioned Guile distribution. The documentation is currently available online in hypertext format, having been translated from a TeXinfo source file which is presumably also available. Binaries are available for Win NT/95 platforms.

This project was last updated in June 1996. The author says that the GNUDL prototype 4 was as far as he got before he switched to starting and maintaining the GSL (GNU Scientific Library) project.

[ftp://nis-ftp.lanl.gov/pub/users/rosalia/]
[ http://nis-www.lanl.gov/~rosalia/gnudl-doc/gnudl_toc.html]

GSL

[ http://www.gnu.org/software/gsl/]

• pygsl

  This project provides a python interface for the GNU scientific library (gsl).

  [ http://pygsl.sourceforge.net/]

Guile-numerics

[ http://www.nongnu.org/guile-num/]

JNumeric

In effect, Numerical Python is a free alternative to commercial solutions such as Matlab with the added bonus of the Python language which can be argue to be much better than what can be found in most commercial solution. You have to try Python to understand!

Why Java? Using Python inside a JVM has advantages because you can embed Python programs inside Java software or vice versa. Whereas mixing C and Python must be done with care by people wide awake, mixing Java and Jython is a no brainer. As far as performances are concerned, expect Jython to be as fast or faster than Python.

[ http://jnumerical.sourceforge.net/]

Lush

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.

The features of Lush include:

• 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).
• libraries for computer vision (OpenCV, Intel's open source Vision Library), and 3D scene rendering (OpenInventor).
• bindings to the JavaVM API and to the Python C API.

Maxima

Maxima itself is reasonably feature complete at this stage, with abilities such as symbolic integration, 3D plotting, and an ODE solver, but there is a lot of work yet to be done in terms of bug fixing, cleanup, and documentation. This is not to say there will be no new features, but there is much work to be done before that stage will be reached, and for now new features are not likely to be our focus.

[ http://maxima.sourceforge.net/

NCL

NCL has many features common to modern programming languages, including types, variables, operators, expressions, conditional statements, loops, and functions and procedures. In addition to common programming features, NCL also has features that are not found in other programming languages, including features that handle the manipulation of metadata, the configuration of the output graphics, the import of data from a variety of data formats, and an algebra that supports array operations.

NCL comes with many useful built-in functions and procedures for processing and manipulating data. There are over 400 functions and procedures that include routines for:

• use specifically with climate and model data
• computing empirical orthogonal functions, Fourier coefficients, singular value decomposition, averages, standard deviations, sin, cosine, log, min, max, etc.
• retrieving and converting date information
• drawing primitives (lines, filled areas, and markers), wind barbs, weather map symbols, isosurfaces, and graphical objects
• file handling
• 1-dimensional, 2-dimensional, and 3-dimensional interpolation, approximation, and regridding
• facilitating computer analysis of scalar and vector global geophysical quantities (most are based on the package known as Spherepack)
• retrieving environment variables and executing system commands
• calling C and Fortran external routines, which makes NCL infinitely configurable

• HDF, HDF-EOS and NetCDF, libraries and formats for storing scientific data;
• LAPACK, a library for solving linear algebra problems;
• ngmath - a collection of routines for random data interpolation;
• Spherepack - a library for the computer modeling of geophysical processes on spheres;
• UDUNITS, a library for manipulating units of physical quantities.

[ http://ngwww.ucar.edu/ncl/]

Numarray

Numarray is a re-implementation of an older Python array module called Numeric. In general its interface is very similar. It is mostly backward compatible and will be becoming more so in future releases. Numarray offers more capability than numeric though there are some aspects of numarray which are still behind Numeric, namely:

• numarray is efficient for large arrays (>20,000 elements) but is slower than Numeric for small arrays by a factor of 2 to 4.
• numarray lacks a plotting module. A scientific plotting module is under development (chaco) and a basic version should be available in a few months (as well as basic image display capability).
• numarray currently has ports of Numeric packages for linear algebra, random numbers, and fourier transforms. numarray has native packages for convolution and multi-dimensional image processing.

[ http://www.stsci.edu/resources/software_hardware/numarray

• NumPy Addons

  [ http://starship.python.net/crew/jhauser/numpyadds.html]

NumExp

It is based on a server with the NumExp core functionalities. This server comunicates with potencial clients using a simple Corba interface.

[ http://numexp.sourceforge.net/]

Octave

Octave supports 2- and 3-D plotting. The underlying numerical solvers are currently standard Fortran ones like Lapack, Linpack, Odepack, the Blas, etc., packaged in a library of C++ classes. If possible, the Fortran subroutines are compiled with the system's Fortran compiler, and called directly from the C++ functions. If that's not possible, you can still compile Octave if you have the free Fortran to C translator f2c.

Further Octave features include:

• support for organizing data in structures, e.g. associative arrays with indices limited to strings;
• variable-length argument and return lists;
• built-in ODE and DAE solvers.

[ http://www.octave.org/]

• GNU Octave Repository

  The GNU Octave Repository is intended to be a central location for custom scripts, functions and extensions for GNU Octave. There is an alphabetized list of the over 600 functions in the repository.

  [ http://octave.sourceforge.net/]

Omega Project

[ http://www.omegahat.org/]

Ox

The console versions of Ox may be used free of charge for educational and research purposes.

[http://www.nuff.ox.ac.uk/Users/Doornik/]

PACT

PACT is an effort to implement a software development environment which is itself portable and promotes the design and construction of portable applications. PACT does not include such important tools as editors and compilers. Well built tools of that kind are readily available across virtually all computer platforms. The areas that PACT addresses are at a higher level involving issues such as data portability, portable inter-process communication, and graphics.

In its current conception, PACT is a set of nine tools. Eight of these are implemented as libraries, and two of them provide both libraries and executable applications. PACT is entirely coded in C but was designed with a view toward support of other languages, notably FORTRAN. The design of PACT was and is functionally driven. The main idea is to identify generic blocks of functionality independent of considerations of language and specific applications. When that has been done, the application program interface (API) for a particular block of functionality, e.g. inter-process communication, naturally emerges. With the API specified, the implementation proceeds fairly naturally. The most important concept in making this approach work is that of abstraction barriers. The API defines an abstraction barrier between the general purpose functionality and the applications built on top of it. The underlying implementation can be changed without necessitating changes to the applications using it. This goal has not always been achieved, but the fact is that it remains as a goal and PACT is always evolving toward that goal.

PACT includes the following software libraries and applications:

• SCORE, a low-level environment balancing library;
• PML, a math library;
• PPC, a process control library;
• PDB, a portable binary database management library;
• SCHEME, an interpreter for the Scheme dialect of the LISP language;
• PGS, a graphics library;
• PANACEA, a simulation code development system;
• ULTRA, a 1-D data representation, analysis and manipulation tool; and
• SX, Scheme with extensions.

Here's some further detail on the particularly interesting/useful components.

• PANACEA

  PANACEA provides a collection of services to facilitate the production of numerical simulation codes and to increase the reusability and shareability of simulation packages. By attempting to provide services to do everything that is generic to ?all? simulation codes, PANACEA also provides some standards of data exchange, management, and visualization.

  Although coded in C, PANACEA is coded in an object-oriented style. The most important ramification of this is that abstract objects (e.g., packages, variables, and mappings) have a relatively faithful concrete representation. This puts PANACEA on a sound conceptual basis and helps to delineate the generic from the specific in simulation code systems.

  As an additional benefit, the modularization that follows from this style lends itself to natural coarse-grained parallelization of code systems. In practice, packages can also be organized so as to make fine grained parallelization possible because the controlling structures and the data objects of PANACEA do not really intrude into the detailed workings of the simulation algorithms. Therefore, while PANACEA helps modularize a code system so that packages or large parts of packages might be run in parallel, it does not interfere with parallelizing individual routines which permit it.

  The encapsulation of abstract objects in concrete representations facilitates the process of manipulating these objects symbolically. I have used PANACEA with the PACT SCHEME interpreter to give users of one PANACEA code the ability to manipulate the code in very broad and general ways.

  This technique allows the manipulation of the packages? execution sequences, the examination of the state of the running code, and the changes in the state of the code. When carried to its logical conclusion, this method will also permit the prototyping of algorithms at the LISP level before investing the effort in writing more efficient code at a lower level.

  Finally, PANACEA can bind simulation packages generated by a tool, such as ALPAL, into entire code systems. PANACEA complements ALPAL very neatly by attending to large control and data flow issues, while ALPAL uses the PANACEA services rather than getting loaded down with these issues.

[ http://pact.llnl.gov/]

PDL

PDL turns perl into a free, array-oriented, numerical language similar to such commerical packages as IDL and MatLab. One can write simple perl expressions to manipulate entire numerical arrays all at once.

The PDL distribution for Perl is free Software and provides extensive numerical and semi-numerical functionality with support for two- and three-dimensional visualisation as well as a variety of I/O formats. The goal is to allow PDL to interact with a variety of external numerical packages, graphics and visualisation systems. Easy interfacing to such systems is one of the core design features of PDL.

[ http://pdl.perl.org/]

PETSc

PETSc is easy to use for beginners. Moreover, its careful design allows advanced users to have detailed control over the solution process. PETSc includes an expanding suite of parallel linear and nonlinear equation solvers that are easily used in application codes written in C, C++, and Fortran. PETSc provides many of the mechanisms needed within parallel application codes, such as simple parallel matrix and vector assembly routines that allow the overlap of communication and computation. In addition, PETSc includes growing support for distributed arrays.

The features of PETSc include:

• Parallel vector scatters and gathers;
• Parallel matrices, including several sparse storage formats and easy, efficient assembly;
• Scalable parallel preconditioners;
• Krylov subspace methods;
• Parallel Newton-based nonlinear solvers;
• Parallel timestepping (ODE) solvers;
• Automatic profiling of floating point and memory usage;
• Consistent interface;
• Intensive error checking;
• Over one hundred examples;
• Complete documentation;
• Portable to UNIX and Windows.

[ http://www-unix.mcs.anl.gov/petsc/petsc-2/

PsiLAB

• An interpreter, of course O'CaML itself
• Libraries written in O'CaML
• External libraries written in Fortran and C

• support for all O'CaML functions and data types;
• an extensive matrix package;
• a 2- and 3-D plot package with interactive or PostScript output;
• various generic and special mathematical functions;
• a linear algebra package;
• linear regression;
• nonlinear least squares fit routines;
• FFTs;
• image processing functions; and
• an online help system.

[ http://psilab.sourceforge.net/]

Ptolemy

Ptolemy II is a set of Java packages supporting heterogeneous, concurrent modeling and design. Its kernel package supports clustered hierarchical graphs, which are collections of entities and relations between those entities. Its actor package extends the kernel so that entities have functionality and can communicate via the relations. Its domains extend the actor package by imposing models of computation on the interaction between entities. Examples of models of computation include discrete-event systems, dataflow, process networks, synchronous/reactive systems, and communicating sequential processes. Ptolemy II includes a number of support packages, such as graph, providing graph-theoretic manipulations, math, providing matrix and vector math and signal processing functions, plot, providing visual display of data, data, providing a type system, data encapsulation and an expression parser, etc.

Ptolemy Classic is a heterogeneous simulation and design environment supporting multiple models of computation. It is written in C++, and has a (now rather old) graphical user interface for constructing models visually as block diagrams. It supports dataflow, discrete-event, process networks, synchronous/reactive, and finite-state machine models of computation. It can generate implementations in C and assembly code for at least two programmable DSPs from certain dataflow descriptions of systems.

[ http://ptolemy.eecs.berkeley.edu/]

Quantian

However, Quantian differs from Knoppix by adding a set of programs of interest to applied or theoretical workers in quantitative or data-driven fields. The added quantitative, numerical or scientific programs comprise:

• R, including several add-on packages (such as tseries, RODBC, coda, mcmcpack, gtkdevice, rgtk, rquantlib, qtl, dbi, rmysql), out-of-the box support for the powerful ESS modes for XEmacs as well as the Ggobi visualisation program;
• Octave, with add-on packages octave-forge, octave-sp, octave-epstk, matwrap and Inline::Octave;
• Computer-algebra systems Maxima (including the X11 front-end and emacs support), Pari/GP, GAP, GiNaC and YaCaS;
• GSL, the Gnu Scientific Library (GSL) including example binaries;
• the QuantLib quantitative finance library including its Python interface;
• the Grass geographic information system;
• the OpenDX and Mayavi data visualisation systems;
• TeXmacs for wysiwyg scientific editing as well as LyX and kile for wysiwyg (La)TeX editing;
• various Python modules including Scientific and Numeric Python;
• and various other programs such as apcalc, aplus, aribas, autoclass, euler, evolver, freefem, gambit, geg, geomview, ghemical, glpk, gnuplot, gperiodic, gri, gmt, gretl, lp-solve, mcl, mpqc, multimix, rasmol, plotutils, pgapack, pspp, pdl, rcalc, yorick, XLisp-Stat and xppaut.

[ http://dirk.eddelbuettel.com/quantian.html]

R

R provides a wide variety of statistical (linear and nonlinear modelling, classical statistical tests, time-series analysis, classification, clustering, ...) and graphical techniques, and is highly extensible. The S language is often the vehicle of choice for research in statistical methodology, and R provides an Open Source route to participation in that activity.

One of R's strengths is the ease with which well-designed publication-quality plots can be produced, including mathematical symbols and formulae where needed. Great care has been taken over the defaults for the minor design choices in graphics, but the user retains full control.

R is an integrated suite of software facilities for data manipulation, calculation and graphical display. It includes:

• an effective data handling and storage facility,
• a suite of operators for calculations on arrays, in particular matrices,
• a large, coherent, integrated collection of intermediate tools for data analysis,
• graphical facilities for data analysis and display either on-screen or on hardcopy, and
• a well-developed, simple and effective programming language which includes conditionals, loops, user-defined recursive functions and input and output facilities.

R, like S, is designed around a true computer language, and it allows users to add additional functionality by defining new functions. Much of the system is itself written in the R dialect of S, which makes it easy for users to follow the algorithmic choices made. For computationally-intensive tasks, C, C++ and Fortran code can be linked and called at run time. Advanced users can write C code to manipulate R objects directly.

[ http://www.r-project.org/]

• RPy

  RPy is a very simple, yet robust, Python interface to the R Programming Language. It can manage all kinds of R objects and can execute arbitrary R functions (including the graphic functions). All errors from the R language are converted to Python exceptions. Any module installed for the R system can be used from within Python.

  [ http://rpy.sourceforge.net/]

RLaB

RLaB is called a high level language because typing and dimensioning of variables aren't performed by the user but rather are inferred by the program from usage context. It is also high level due to its interactivity which allows the user to set up, perform, and visualize experiments in real time in the context of a single environment. The structured language in RLaB is similar to C in that a program is sequence of functions acting on variables, with the functions being either built-in or user defined. It also features strongly typed objects in classes. The classes are numeric, string, function, and list with the numeric class encompassing scalars, vectors and matrices. Functions are also objects and as such can call or be called by other functions, including themselves.

The build-in functions generally are those that operate on either scalars, vectors or matrices. Scalar functions include trig functions, rounding, absolute values, square roots, etc. Vector functions include sum, products, means, max/min, FFT, sort, etc. Matrix functions include Cholesky decomposition, eigenvalue determination, determinants, inverses, norms, and much more. Plotting is performed using either the PLplot library or Gnuplot. This allows the creation, viewing and printing of the usual range of 2- and 3-D and histogram plots.

The source code for RLaB is available as well as binaries for Linux, DOS, OS/2, Mac and Acorn platforms. Installation from source requires other packages such as BLAS, LAPACK, FFTPACK, RANLIB, and either PLplot or Gnuplot as mentioned above. The documentation includes a tutorial and a manual for the built-in functions in both HTML and PostScript format. The June 1996 issue of the Linux Journal has an article about RLaB written by its creator, Ian Searle.

[ http://rlab.sourceforge.net/]

ROOT

Thanks to the builtin CINT C++ interpreter the command language, the scripting, or macro, language and the programming language are all C++. The interpreter allows for fast prototyping of the macros since it removes the time consuming compile/link cycle. It also provides a good environment to learn C++. If more performance is needed the interactively developed macros can be compiled using a C++ compiler.

The system has been designed in such a way that it can query its databases in parallel on MPP machines or on clusters of workstations or high-end PC's. ROOT is an open system that can be dynamically extended by linking external libraries. This makes ROOT a premier platform on which to build data acquisition, simulation and data analysis systems.

The backbone of the ROOT architecture is a layered class hierarchy with, currently, around 310 classes grouped in about 24 frameworks divided in 14 categories. This hierarchy is organized in a mostly single-rooted class library, that is, most of the classes inherit from a common base class. The class categories include:

• the basic ROOT classes containing the low-level building blocks;
• container classes for general purpose data structures;
• physics classes;
• matrix and vector classes;
• histogram and minimization classes;
• tree and ntuple classes containing the tree system;
• 2-D graphics classes;
• 3-D graphics classes;
• image processing classes;
• detector geometry classes;
• graphical user interface (GUI) classes;
• interactive interface classes with a C++ interpreter;
• operating system interface classes;
• networking classes;
• interface to MySQL classes; and
• documentation classes.

[ http://root.cern.ch/]

SciCraft

Many scientific fields experience an enormous increase in produced data and thus need the availability of effective data analysis software.

Commercial data analysis software packages exist that can be used, however they are often expensive, have a limited number of methods available and are very restrictive with their licenses. Combining the methods with external software usually requires time-consuming data format and interface handling that hinders the investigator.

SciCraft is an open source data analysis software which solves these problems through an intuitive and user friendly framework where existing methods written in any programming language can easily be combined. It provides integration of a large number of methods from multiple sources such that the user does not need to be concered with problems related to data imports/exports, file formats and automation. The user can concentrate on the scientific aspects of data analysis without technical distractions.

Even though SciCraft can communicate in principle with any type of computer language, we have found it useful to concentrate on high level languages that are suited for rapid development of data analysis algorithms. Examples of such languages are Octave, SciLab (Matlab clones) and R (S-PLUS clone). Currently, SciCraft supports Octave, R and Python.

[ http://www.scicraft.org/]

Scilab

Scilab includes hundreds of mathematical functions with the possibility to add interactively programs from various languages (C, Fortran...). It has sophisticated data structures (including lists, polynomials, rational functions, linear systems...), an interpreter and a high level programming language.

Scilab has been designed to be an open system where the user can define new data types and operations on these data types by using overloading.

The toolboxes available with Scilab include:

• 2-D and 3-D graphics, animation
• Linear algebra, sparse matrices
• Polynomials and rational functions
• Simulation: ODE solver and DAE solver
• Scicos: a hybrid dynamic systems modeler and simulator
• Classic and robust control, LMI optimization
• Differentiable and non-differentiable optimization
• Signal processing
• Metanet: graphs and networks
• Parallel Scilab using PVM
• Statistics
• Interface with Computer Algebra (Maple, MuPAD)
• Interface with Tcl/Tk

[ http://scilabsoft.inria.fr/]

SCIrun

SCIrun provides a component model, based on generalized dataflow programming, that allows different computational components and visualization components to be connected together in a tightly integrated fashion. SCIrun facilitates the interactive construction, debugging and steering of large-scale, typically parallel, scientific computations. It can be envisioned as a computational workbench, in which a scientist can design and modify simulations interactively via a component-based visual programming model. It allows scientists to modify geometric models and interactively change numerical parameters and boundary conditions, as well as to modify the level of mesh adaptation needed for an accurate numerical solution.

[ http://software.sci.utah.edu/scirun.html]

SLATEC

[http://www.netlib.org/slatec/]

Tela

The features of Tela include a copmlete Fortran 90 style array language, fast execution in interpreted mode (with a translator to C++ in the works), a full suite of linear algebra tools, a full set of fast Fourier transform routines, the capability of running UNIX system commands from within Tela, the capability of working with files in HDF, netCDF, ASCII, MATLAB, and PBM formats, and several built-in numerical analysis routines, e.g. linear interpolation, integration, root finding, nonlinear fitting, etc. The graphics capabilities, accomplished via a linkage with a separate program PlotMTV, included 2-D and 3-D line and curve, contour, density, vector field, and surface plots as well as bar charts and histograms. Plots and be overlaid and stacked and saved in PostScript or GIF format.

Tela is written in C++ and has been compiled on SGI, Linux, Sun, Cray, IBM, HP, Sun and DEC platforms. The available source code can be compiled usingGCC/G++ and also with some native C++ compilers. Binaries are available for Cray, HP, IBM, Linux, SGI and Sun machines. Documentation includes a user's guide in PostScript format as well as online help files, man pages and some selected PlotMTV documentation.

[http://sumppu.fmi.fi/prog/tela.html]

VisAD

• The use of pure Java for platform independence and to support data sharing and real-time collaboration among geographically distributed users. Support for distributed computing is integrated at the lowest levels of the system using Java RMI distributed objects.
• A general mathematical data model that can be adapted to virtually any numerical data, that supports data sharing among different users, different data sources and different scientific disciplines, and that provides transparent access to data independent of storage format and location (i.e., memory, disk or remote). The data model has been adapted to netCDF, HDF-5, FITS, HDF-EOS, McIDAS, Vis5D, GIF, JPEG, TIFF, QuickTime, ASCII and many other file formats.
• A general display model that supports interactive 3-D, data fusion, multiple data views, direct manipulation, collaboration, and virtual reality. The display model has been adapted to Java3D and Java2D and used in an ImmersaDesk virtual reality display.
• Data analysis and computation integrated with visualization to support computational steering and other complex interaction modes.
• Support for two distinct communities: developers who create domain- specific systems based on VisAD, and users of those domain-specific systems. VisAD is designed to support a wide variety of user interfaces, ranging from simple data browser applets to complex applications that allow groups of scientists to collaboratively develop data analysis algorithms.
• Developer extensibility in as many ways as possible.

[ http://www.ssec.wisc.edu/~billh/visad.html]

XLispStat

The prototype object-oriented programming system is used to implement the graphics system as well as to implement statistical model representations such as linear and nonlinear regression and generalized linear models. The statistical modeling features were enhanced by adding extensions to standard Lisp arithmetic operations to perform element-wise operations on lists and vectors and also by adding a variety of basic statistical and linear algebra functions. The statistical functions include functions to return the density and quantiles for a number of types of distributions, to compute means and medians, to perform max/min tasks, to compute lists of random numbers, and many more. Plotting functions include those to create boxplots, histograms, x-y plots, scatter plots, probability and contour plots, and to rotate plots in 3-D space.

Implementations of XLispStat are available for Macintosh, Ms Windows and UNIX/X11 systems, with the first two available in binary and the latter in source form. I had no problems compiling and installing it on my Linux platform. The available documentation includes a somewhat dated book, a more up-to-date tutorial introduction and several technical reports. All but the book are available in both HTML and PostScript format. The XLisp language implementation is included in the XLispStat package but is also available separately.

[ http://www.stat.uiowa.edu/~luke/xls/xlsinfo/xlsinfo.html]

Yorick

The features of Yorick include C-like syntax for the interpreted language with declarative statements, explicit array operations that don't require creating explicit loops, an X Window system interactive graphics package that concentrates on x-y plots and filling and contouring quadrilateral meshes, hardcopy output to binary CGM or PostScript files (with a separate CGM browser), a binary file package that can read or write floating point formats foreign to the machine on which it is running, a growing library of functions written in the native language (e.g. Bessel and gamma functions; fitting by least squares, spline or rational functions; reading and writing NetCDF files, etc.), and provisions for embedding compiled subroutines and functions within the Yorick interpeter (for which an example package is provided).

The source code (written in ANSI C) is available with a configure script that recognizes Sun, HP, SGI, Cray, IBM, DEC Alpha and Linux platforms, and a Mac port is available in binary form. The documentation available includes PostScript and HTML versions of a user's manual as well as some flat ASCII files containing descriptions of the available functions and the graphics package.

[ http://wuarchive.wustl.edu/languages/yorick/doc/]