# Difference between revisions of "Code"

## Communications Toolbox

OctaveForge now contains a fairly complete implementation of a Matlab R13 compatible communications toolbox http://octave.sourceforge.net/communications/index.html. This includes

• Random signal creation/analysis
• Source coding (Quantization, Compand)
• Block coding (BCH, Reed-Solomon)
• Galois fields of even order [i.e. GF(2^m) ]

```octave:1> comms info
```

There are still functions missing or with limitations, and the documentation is not complete. You are therefore welcome to send patches.

### Data Formats

A collection of various signal data formats can be found here. Many formats are supported by the BIOSIG-toolbox for Octave and Matlab.

### Speech and Signal Processing Links

The following packages contain routines that can be made to work with Octave. Sometimes a little effort is required.

The following used to be available:

Other Software:

## Fixed point toolbox

(initial announcement can be found here, with the corresponding thread)

When implementing algorithms in hardware, it is common to reduce the accuracy of the representation of numbers to a smaller number of bits. This allows much lower complexity in the hardware, at the cost of accuracy and potential overflow problems. Such representations are known as fixed point.

OctaveForge now contains a toolbox to perform such fixed point calculations. This toolbox supplies a fixed point type that allows Octave to model the effects of such a reduction in accuracy of the representation of numbers. The major advantage of this toolbox is that with correctly written Octave scripts, the same code can be used to test both fixed and floating point representations of numbers.

What it does is create several new user types for fixed point scalar, complex scalars, matrices and complex matrices, and the corresponding operators on these types. As this code was first written against 2.1.50 there is no capabilities at this time for NDArray operations with this code, however I'm not sure this is a problem.

A typical use of the toolbox might be something like

```n = 2;
a = rand (n, n);
b = rand (n, n);

## Create fixed-point version with 1 bit before decimal and 5 after.
af = fixed (1, 5, a);
bf = fixed (1, 5, b);

c = myfunc (a, b);
cf = myfunc (af, bf);

function y = myfunc (a, b)
y = a * b;
endfunction
```

where as you can see the underlying function myfunc is unchanged, while it is called with either floating or fixed point types. The case above is for fixed-point values with 1-bit before the decimal point and 5 after, and for me gave a result of

```octave:8> c
c =

0.98105  0.94436
0.82622  0.30831

octave:9> cf
cf =

0.93750  0.90625
0.78125  0.25000
```

which clearly shows the loss of precision of a fixed-point algorithm with only 6-bits of precision in a matrix multiply. One gotcha in this toolbox is the use of the concatenation operator "[ ]" which will implicitly reconvert fixed-point values back to floating-point, with Octave 2.1.57 or earlier. This is due to an internal limitation of octave that was removed in Octave 2.1.58. So for the best experience it is suggested you use this toolbox with octave 2.1.58 or later.

This package is only available with recent versions of OctaveForge (20040707 or later). With the package installed online help is available with the command

```octave:1> fixedpoint info
```

As this package is relatively new, all feedback on its use would be most welcome.

Matlab also recently introduced a Fixed Point Toolbox. The Octave toolbox has been written independently of the Matlab toolbox and doesn't follow the same syntax. This might change in the future, if the author (DavidBateman) can be bothered to put the effort into making the required changes. Mathworks documentation for their fixed point toolbox also includes a generic discussion of fixed point numbers that might be a useful addition to the documentation supplied with Octave itself. Another short introduction to fixed point arithmetics is this.

quadl is an adaptive quadrature function available in MATLAB (from version 6 I think). It is very fast and accurate and surprisingly it's a small m-file. The algorithm is based on works by Prof. Walter Gander.

Prof. Gander has two m files in his web page http://www.inf.ethz.ch/personal/gander/ which implement his algorithm along with a paper describing the algorithm.

I have not delved deeply into the subject, but the adaptlobe.m function looks equivalent to quadl. Compatibility with MATLAB could be achieved by writing a small quadl wrapper function which simply calles adaptlobe, or by changing adabtlobe's name to quadl.

I have contacted Prof. Gander to allow for distribution of his m-files in octave-forge.

quadl, from the above source is now incorporated into octave-forge-2004-02-12.

## Model transformation tools

A set of tools for modelling dynamic physical systems using the bond-graph methodology and transforming these models into representations suitable for analysis, control and simulation. These tools use, and generate m files for, GNU Octave.

## Optimization

There is a variety of code in the octave-forge optimization package http://octave.sourceforge.net/optim/index.html

## Parallelism

Operating Octave remotely and in parallel

## Statistics

### Statistics Functions

• [ http://www.maths.lth.se/matstat/stixbox/ Stixbox] supports Octave. It has a variety of functions not available in octave/octave-forge such as bootstrap and jackknife estimators and a variety of qq plots. GPL.
• Statbox has some regression functions which are not in Octave. Don't know license or Octave compatibility.
• NaN-toolbox A statistic-toolbox for Octave and Matlab®. It handles data with and without MISSING VALUES. More background information is provided in README
• Dynare is a pre-processor and a collection of MATLAB or SCILAB routines which solve non--linear models with forward looking variables. Cannot find any insight about the license terms, but some code is derived work from GPL code, e.g., . The code is adapted from Anders Holtsberg's matlab toolbox (stixbox).

### Multivariate kernel density estimation

• A google search for epanechnikov at the r-project.org site returns several R packages on this subject. They all should be GPL compatible. 
• Weka is written in Java, again, don't know how difficult... look for a file called LWL.java
• LTI-Lib is an object oriented library with algorithms and data structures frequently used in image processing and computer vision. LGPL

## Symbolic

### Symbolic Manipulation

Octave is a matrix algebra tool, not a symbolic algebra tool, so it cannot perform symbolic operations, such as finding the derivative of sine(x) with respect to x

```y = derivative('sin(x)','x'); # Not available in Octave
```

The below mentioned GiNaC will add symbolic functionality to octave.

### Octave interfaces to GiNaC

There are two Octave interfaces to GiNaC available

```octave:1> df = g_diff ( "sin(x)" , "x" )
df = cos(x)
octave:2> x = pi; eval ( df );
ans = -1
```

### Numerical methods

In some instances, Octave can give reasonable results using numerical methods

• Octave supports numerical derivatives:
```t = linspace(0,6,100);
y = sin(t);
dydt = diff(y) ./ diff(t)
```
• OctaveForge has other numerical derivative functions.

### Symbolic algebra systems

Software other than Octave may be more useful for work involving symbolic manipulations

Free software

Non-free software

Note that most of these systems (and Octave!) may be used from within TeXmacs http://www.texmacs.org

A list of some other scientific software is available at http://sal.kachinatech.com/