Free isosurface matlab tetrahedra software for linux

Math::MatrixReal is a nifty perl module for doing just about anything you could want with an NxN matrix, or vector of real numbers.
Main features:
- operator overloading, $a * $b multiplies 2 matrices, $a / $b is shorthand for $a * $b ** -1
- create matrices from strings or array references
- inverse
- determinant
- transpose (overloaded to ~)
- normalization
- diagonalization ( symmetric only )
- eigenvalues, eigenvectors ( symmetric only )
- boolean checks for: symmetric,orthogonal,diagonal,tridiagonal,triangular,
- gramian,binary,idempotent,periodic
- norms: p-norms, frobenius norm, 1-norm, 2-norm
- cofactor matrix
- minor matrix
- rank (order)
- Analytic solution of Ax=b with LR decomposition
- 3d vector product
- 3 iterative algorithms to solve Ax=b
- Single Step Method
- Global Step Method
- Relaxation Method
- export matrix to Matlab, Scilab, Yacas or LaTeX

Scilab project is a is a numerical computation system similiar to Matlab or Simulink.

Scilab is an open source numerical computation platform developed by a consortium managed by INRIA (French National Institute for Research in Computer Science and Control) which, to date, gathers 23 industrial companies, research centers and engineer schools. It provides a powerful environment for the development of scientific applications and for engineering. Each month, nearly 20,000 remote downloads of
Scilab are registered from the Internet site of the Consortium, which takes Scilab one of the most valued pieces of open source scientific oftware.

Mandriva, whose membership to the Scilab Consortium is pending, and he Scilab Consortium agreed to integrate Scilab into the new Mandriva Linux 2007 distribution (Discovery, Powerpack and Powerpack+). The development teams of Scilab and Mandriva cooperated in the integration f the latest version of Scilab (v4.0, announced in February 2006 and since downloaded more than 150,000 times) into this new Mandriva release. It is planned to continue this arrangement for future versions of Mandriva Linux and of Scilab. In addition, Scilab will also be integrated into Corporate Desktop 4, the Mandriva Linux workstation for businesses.

About The Scilab Consortium

The Scilab software is, since May 2003, produced by a consortium, managed by INRIA, which, to date, has 23* industrial companies, research centers and engineering schools as members. The creation of the Scilab Consortium reflects a will to produce an open source numerical computation platform of high quality. Scilab is developed by a dedicated and permanent team hosted by INRIA. Moreover, its open source nature allows external contributions and thus a level of know-how in the field of scientific computation can be reached which a single company could otherwise claim only with difficulty. Nearly 20,000 remote downloads of the Scilab software are carried out each month from the official site of the Consortium to the benefit of European and foreign companies, universities and research centers. The
membership of the Scilab Consortium is in constant growth.

JMathLib project is a Java Clone of Octave, SciLab and Matlab. A library of mathematical functions designed to be used in evaluating complex expressions and display the results graphically. It will be used either interactively through a terminal like window or to interpret script files.
It is intended to be a java version of programs such as MatLab, Octave and Scilab.
Enhancements:
- New functions: _class.java, angle.java, bench.m, beta.m, betaln.m, center.m, class.m, cloglog.m, close.java, compan.m, complement.m, cov.m, createnewfile.java, cumprod.java, cumsum.m, create_set.m, conj.java, delete.java, det.m, dot.m, eq.m, false.m, gammaln.m, ge.m, gray2ind.m, gray.m, gt.m, hankel.m, hurst.m, inf.java, int16.java, int32.java, int64.java, int8.java, inv.m, is_leap_year.m, isa.java, isdefinite.m, isdirectory.java, isfile.java, isfinite.java, ishidden.java, islogical.java, isnan.java, isinf.java, issymmetric.m, lastmodified.java, le.m, loadvariables.java, logical.java, logspace.m, lookup.m, mean.m, meansq.java, mkdir.java, nan.java, ne.m, npv.m, nthroot.m, ntsc2rgb.m, nper.m, numel.java, orth.m, pascal.m, perms.m, pmt.m, polyval.m, polyreduce.m, poly.m, print_usage.java, pv.m, pvl.m, qconj.m, qderiv.m, qderivmat.m, qinv.m, qmult.m, qtrans.m, qtransv.m, qtransvmat.m, quaternion.m, randperm.m, rehash.java, repmat.java, rmdir.java, roots.m, save_variables.java, size_equal.m, sort.java, std.m, stril.m, sylvester_matrix.m, toeplitz.m, triangle_lw.m, triangle_sw.m, triu.m, true.m, uint8.java, union.m, var.m, vech.m, wilkinson.m
- Updated functions: col.m, diag.java, ndims.java, imag.java, isempty.java, ones.java, rand.java, real.java, row.m, size.java, tic.java, whos.java, zeros.java All trigonometric functions have been updated

MetaC language extends C in a 100% backward compatible way with reflective features and techniques for refactoring, reconfiguring and modifying arbitrary C source code.
Therefore, the extensions provide special metadata types for working with source code information, syntactical structures for the definiton of code templates, and metafunctions to gather information about source code and refactor, modify, delete, or insert code.
Some of the modifications that can be done with MetaC, are also realizable with the C preprocessor. But the C preprocessor suffers certain limitations that can be overcome using MetaC.
The area of applications for MetaC is not limited to specific domains. But its concepts and its motivation has been derived from problems of CASE tools for embedded real-time systems (e.g. Mathworks Matlab, Telelogics Tau, Aonixs STP).
- Source code reconfiguration and refactoring in general.
- Abstraction of APIs and hardware-specific or vendor-specific implementations of well-defined functionallity (ever got locked to a specfic API by a RTOS vendor?).
- Source code instrumentation for WCET-analysis
- Adaption of source code to multiple embedded targets (especially differing native platform APIs) based upon an abstract machine model
- Application specific debug support (e.g. control-flow or data-flow tracing)
- Verification of domain- and application-specific constraints (e.g. MISRAs rules set for C based programs in automotive applicaitons)
Advantages of the Metaprogramming Approach:
- Source code modification is done based upon syntax. In consequence invalid modifications can be detected at the moment they are executed.
- Decision for code modifications can be made upon user parameters and information derived from the source code
- Crosscutting reconfigurations (i.e. reconfigurations concerning multiple functions or modules) of source code are possible.
Enhancements:
- Support for Win32 hosts was added.
- Support for initializer lists was added.
- Some C99 issues were fixed.
- Several more enhancements were made.
- A whole bunch of bugs were fixed.

Shatranj is an bitboard-based, Open-Source, interactive chess programming module which allows manipulation of chess positions and experimentation with search algorithms and evaluation techniques. Shatranjs goal is to write a toolkit to aid in implementing Shannon Type B chess programs.

As such, execution speed becomes less important then code clarity and expressive power of the implementation language. Having been written in an interpreted language, this module allows the chess programmer to manipulate bitboards in a natural, interactive manner much like signal processing toolkits allow communication engineers to manipulate vectors of sounds samples in MATLAB.

The module currenly implements a simple recursive minimax search with alphabeta pruning, iterative deepening, uses short algebraic notation, handles repetition check, and the 50 move rule. Features lacking are quiescent checks, transition tables, negascout and MTD searching.

The chess programming toolkit is available in the form of a Python module called shatranj.py. You will also likely need the opening book as well as some of the pre-built hash tables that are used throughout the module (these will be recalculated if the module cannot find the data file).

Place all three file in the same directory and simply run python on the python module ("python shatranj.py"). As far as requirements, all that is needed is a recent version of the interpreted, high level language called Python (anything after version 2.3 should work fine). If you would like a little bit of a speed boost, shatranj looks for the module Psyco and will use it if it is installed.

Until more documentation becomes available, here is a short sample session:
[Sam-Tannous-Computer:~/shatranj] stannous% python

>>> from shatranj import *
...reading startup data
...total time to read data 0.0774528980255
...found opening book shatranj-book.bin with 37848 positions
>>> position = Position("r1bqk2r/pppp1ppp/2n5/5N2/2B1n3/8/PPP1QPPP/R1B1K2R")
>>> all_pieces = position.piece_bb["b_occupied"] | position.piece_bb["w_occupied"]
>>> other_pieces = position.piece_bb["b_occupied"]
>>> from_square = c4
>>> wtm = 1
>>> mask = position.pinned(from_square,wtm)
>>> ne_pieces = diag_mask_ne[from_square] & all_pieces
>>> nw_pieces = diag_mask_nw[from_square] & all_pieces
>>> moves = ((diag_attacks_ne[from_square][ne_pieces] & other_pieces) |
... (diag_attacks_ne[from_square][ne_pieces] & ~all_pieces) |
... (diag_attacks_nw[from_square][nw_pieces] & other_pieces) |
... (diag_attacks_nw[from_square][nw_pieces] & ~all_pieces)) & mask
>>>
>>> moves
1275777090846720L
>>>
>>> tobase(moves,2)
100100010000101000000000000010100000000000000000000
>>> display(moves)

+---+---+---+---+---+---+---+---+
8 | | . | | . | | . | | . |
+---+---+---+---+---+---+---+---+
7 | . | | . | | . | 1 | . | |
+---+---+---+---+---+---+---+---+
6 | 1 | . | | . | 1 | . | | . |
+---+---+---+---+---+---+---+---+
5 | . | 1 | . | 1 | . | | . | |
+---+---+---+---+---+---+---+---+
4 | | . | | . | | . | | . |
+---+---+---+---+---+---+---+---+
3 | . | 1 | . | 1 | . | | . | |
+---+---+---+---+---+---+---+---+
2 | | . | | . | | . | | . |
+---+---+---+---+---+---+---+---+
1 | . | | . | | . | | . | |
+---+---+---+---+---+---+---+---+
a b c d e f g h

>>> position.show_moves(1)
[Rg1, O-O, f3, a3, Rb1, f4, Ba6,
Bh6, Bd3, Qg4, Qe3, Ne7, Be6, Nxg7,
Qxe4, Ne3, b4, Nh4, b3, Be3, Bg5,
g3, Kf1, Rf1, Nh6, a4, Ng3, Qh5,
Kd1, h4, h3, c3, Bxf7, Nd6, Bb5,
Nd4, Qf3, g4, Qf1, Bb3, Qd1, Qd3,
Qd2, Bd5, Bd2, Bf4]
>>>
>>> # now play a game!
>>> play()

Shatranj version 1.10
g: switch sides m: show legal moves
n: new game l: list game record
d: display board b: show book moves
sd: change search depth (2-16) default=5
q: quit

Shatranj: d

+---+---+---+---+---+---+---+---+
8 | r | n | b | q | k | b | n | r |
+---+---+---+---+---+---+---+---+
7 | p | p | p | p | p | p | p | p |
+---+---+---+---+---+---+---+---+
6 | | . | | . | | . | | . |
+---+---+---+---+---+---+---+---+
5 | . | | . | | . | | . | |
+---+---+---+---+---+---+---+---+
4 | | . | | . | | . | | . |
+---+---+---+---+---+---+---+---+
3 | . | | . | | . | | . | |
+---+---+---+---+---+---+---+---+
2 | P | P | P | P | P | P | P | P |
+---+---+---+---+---+---+---+---+
1 | R | N | B | Q | K | B | N | R |
+---+---+---+---+---+---+---+---+
a b c d e f g h


Shatranj:

Numarray provides array manipulation and computational capabilities similar to those found in IDL, Matlab, or Octave. Using numarray, it is possible to write many efficient numerical data processing applications directly in Python without using any C, C++ or Fortran code (as well as doing such analysis interactively within Python or PyRAF).
For algorithms that are not well suited for efficient computation using array facilities it is possible to write C functions (and eventually Fortran) that can read and write numarray arrays that can be called from Python.
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 but is still behind Numeric in some areas:
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 has a smaller selection of addon packages. 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. Most Numeric extensions (C or Fortran) can be ported to numarray with minimal effort.
numarray is sufficiently developed to be useful for a number of applications, and is being used in the Hubble Space Telescope data processing pipeline (for the Advanced Camera for Surveys) and to develop the Cosmic Origins Spectrograph pipeline. PyFITS is also based on it. Most of STScIs future astronomical data processing applications will be built using its capabilities.
Numarray is being developed as an Open Source project on SourceForge from which the current development source code may be obtained. The Science Software Branch at STScI is leading this development effort.
STScI has settled on the matplotlib plotting package as the recommended 2-d data visualization tool for numarray data. While its support for numarray and Tkinter is now present, we are holding off a bit before recommending its use for all users. If you dont mind possible problems with installation or some holes in functionality it can be used now. We are in the process of improving the installation documentation for use with numarray.
Although matplotlib has its heritage in trying to emulate matlab plotting capabilities from Python, it does not require matlab. Currently the documentation is geared towards those more familiar with matlab, though many users will have no problem generating simple plots with it. It is still undergoing considerable development (by the original author, John Hunter, and with contributions by STScI and others) and we hope to fill the holes in functionality in the coming months. Nevertheless, it is capable of doing many things now.
Enhancements:
ENHANCEMENTS
- Speed improvement for numarray operators. The Python level hook mapping numarray operators onto universal functions has been moved down to C.
- Speed improvement for string-array comparisons, any(), all(). String correlation is ~10x faster.
- Better operation with py2exe to help it automatically detect the core numarray extensions to include in an installer.
- scipy newcore compatible lower case type names (e.g. int32 not Int32)
- scipy newcore dtype keyword and .dtypechar attribute.
BUGS FIXED / CLOSED
- 1323355 Apps fail with import_libnumarray
- 1315212 Infinite loop converting some scalar strings into a list
- 1298916 rank-0 tostring() broken
- 1297948 records.array fails to create empty fields
- 1286291 import sys missing from array_persist.py
- 1286168 Generic sequences in ``strings.array()``
- 1236392 Outdated web link in announcements
- 1235219 LinearAlgebraError not imported in linear_algebra

The Spider project is a complete object-oriented environment for machine learning in Matlab.
Aside from ease of use for base learning algorithms, algorithms can be plugged together and can be compared with, for example, model selection, statistical tests, and visual plots.
This gives all the power of objects (reusability, the ability to plug together, sharing of code), but also all the power of Matlab for machine learning research.
Enhancements:
- A WEKA interface was added, supporting decision trees.
- Additional code, documentation, and demos were added.

- An interface to the Java programming language
- interfaces Java with a small programming language (same name, FrAid) so mathematical equations, formulas, etc. could be used within your Java code. This could be applied to large number of problems where symbolyc mathematical data needs to be processed - numerical computations, symbolic computations, graphic visualization, imaging, CAD, ... From this prospective the FrAid stand alone system could be viewed as an example of what could be done using FrAid as an interface to Java. The rest is up to your needs and imagination...
- A standalone application
- it is a completely selfsufficient system which provides flexible and extensible programming environment utilizing the FrAid programming language. You can use the existing scripts, functions and environments for mathematical computations, vizualization, batch processing and more. It is not meant to be a general scripting tool but in certain contexts it can be used as one.
- The FrAid programing language
- could be used independently (main programming language, like the in FrAid the standalone system) or as an interface to a larger system (even outside the Java context);
Components:
- a parser/interpreter for the FrAid programming language;
- a dynamic symbol table used by the interpreter - could be loaded/unloaded/changed in run time;
- a GraphicsPanel for visualizing graphics - 2D, double precision "infinite" zooming and scrolling, saves to JPEG and PNG in any resolution/size;
- a SettingsEditor for editing serialized Java classes (XML or regular) - maintains all FrAid settings, could be used for (almost) anything Java serialized;
- a simple MIDI panel for converting numeric sequences to MIDI + play/record capability;
- highly flexible IO subsystem, providing run time redirection and various logging options.