Free matlab software for linux

QuantLib project is aimed at providing a comprehensive software framework for quantitative finance. QuantLib is a free/open-source library for modeling, trading, and risk management in real-life.

QuantLib is written in C++ with a clean object model, and is then exported to different languages such as C#, Objective Caml, Java, Perl, Python, GNU R, Ruby, and Scheme. The QuantLibAddin/QuantLibXL project uses ObjectHandler to export an object-oriented QuantLib interface to a variety of end-user platforms including Microsoft Excel and OpenOffice.org Calc. Bindings to other languages and porting to Gnumeric, Matlab/Octave, S-PLUS/R, Mathematica, COM/CORBA/SOAP architectures, FpML, are under consideration. See the extensions page for details.

Appreciated by quantitative analysts and developers, it is intended for academics and practitioners alike, eventually promoting a stronger interaction between them. QuantLib offers tools that are useful both for practical implementation and for advanced modeling, with features such as market conventions, yield curve models, solvers, PDEs, Monte Carlo (low-discrepancy included), exotic options, VAR, and so on.

Finance is an area where well-written open-source projects could make a tremendous difference:

any financial institution needs a solid, time-effective, operative implementation of cutting edge pricing models and hedging tools. However, to get there, one is currently forced to re-invent the wheel every time. Even standard decade-old models, such as Black-Scholes, still lack a public robust implementation. As a consequences many good quants are wasting their time writing C++ classes which have been already written thousands of times.
By designing and building these tools in the open, QuantLib will both encourage peer review of the tools themselves, and demonstrate how this ought to be done for scientific and commercial software. Dan Gezelters talk at the first Open Source/Open Science conference discussed how the scientific tradition of peer review fits well with the philosophy of the Open Source movement. Open standards are the only fair way for science and technology to evolve.

The library could be exploited across different research and regulatory institutions, banks, software companies, and so on. Being a free/open-source project, quants contributing to the library would not need to start from scratch every time.

Students could master a library that is actually used in the real world and contribute to it in a meaningful way. This would potentially place them in a privileged position on the job market.
Researchers would have a framework at hand, which vastly reduces the amount of low-level work necessary to build models, so to be able to focus on more complex and interesting problems.
Financial firms could exploit QuantLib as base code and/or benchmark, while being able to engage in creating more innovative solutions that would make them more competitive on the market.
Regulatory institutions may have a tool for standard pricing and risk management practices.

The QuantLib license is a modified BSD license suitable for use in both free software and proprietary applications, imposing no constraints at all on the use of the library.

A few companies have committed significant resources to the development of this library, notably StatPro, a leading international risk-management provider, where the QuantLib project was born.

Aorta project is a load-balancing clustered P2P application.
It executes Tasklets (which have the ability to split themselves into sub tasks that can be executed in pararell).
A typical cluster contains of a LAN with 1-256 computers, each one running aorta.
A Tasklet can be of any type ranging from encoding MP3s, Genomic DNA Alignment, or simply to rendering Web pages for high speed/heavily loaded Web sites.
You can make functions calls to C/C++, applications like Matlab, etc.
Main features:
- PingTasklet simply traversers your net of aortas.
- ImageTasklet , simply rescale imagecolours.
- EncodeTasklet, spreads out mp3 encode in your LAN.
- SimpleSort , Merge sort by Gretsam.
Enhancements:
- Refactored to one base class Moblet,the smalles code and data entity moving around
- Improved Moblet Receiver and executing. Minimizing worker idle time
- startup script aorta.sh improved now can start with remote debug params
- Aorta core can now be used as an API to emit/delegete Moblets from an user created application
- Preferences stuff should work on a MS platform now
- Herve added DocBook to buildsystem
- Gretsam added a MergeSorter Tasklet

SegyMAT is a set of Matlab files for reading and writing SEG-Y files from Matlab.
SegyMAT aims at being both simple to use to read SEG-Y files, and extensive enough to aid in writing complex seismic data.
A Python port of the library has initiated under the name : SegyPY.
Enhancements:
- Urs Boeniger contributed a patch that allows arbitrary SegyTraceHeaders to be specified for WriteSegy.m

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

annie stands for Artificial Neural Network Library and is a C++ API (library) for neural network training and execution.
ersions exist for both Windows and flavours of Unix (tested on Linux).
The library currently has support for training, saving and executing multi-layer perceptron, radial-basis-function, kohonen maps, Hopfield and general recurrent Networks.
Along with a library, also included are some example applications and binary utilities to help you construct training sets, train the network, visualise etc.
In addition to this, annie also interfaces with Matlabs Neural Network toolbox (see January 13, 2003 in Whats New), which allows you to create and train networks in Matlab and then export them to a format understood by the annie library.
This gives you the ability to use the features of Matlabs Neural Network Toolbox to create the best network and then use this network in your C++ application.
Enhancements:
- configure should work without running ./autogen.sh

pfstools project contains a set of command line (and one GUI) programs for reading, writing, manipulating and viewing high-dynamic range (HDR) images and video frames. All programs in the package exchange data using a simple generic file format (pfs) for HDR data. The concept of the pfstools is similar to netpbm package for low-dynamic range images.
pfstools come with a library for reading and writing pfs files. The library can be used for writing custom applications that can integrate with the existing pfstools programs.
pfstools offers also a good integration with a high-level mathematical programming language GNU Octave. pfstools can be used as the extension of Octave for reading and writing HDR images or simply to store effectively large matrices.
Note that pfs in not just another format for storing HDR images (and there are already quite a few of them). It is more an attempt to integrate the existing file formats by providing a simple data format that can be used to exchange data between applications.
Enhancements:
- matlab: pfsview can now display 2D cell arrays
- pfs library: quite serious bug in sRGB transforms fixed
- added: check for GLUT library (unix only)
- added: man page for pfsglview