You understand that I cannot post on internet any SLR software, as they are propriety of General Electric.

But the SLR algorithm per se is very simple (some tens lines of C code), so you should be able to rewrite it by yourself in any language.

The difficult part is the FIR filter design (Remez:Park-McClellan) algorithm. Here are some links which may help you.

Matpulse from G. Matson. For MATLAB users.

Catalog of freely available FIR filter design programs. For C, Java, Scheme ... and Fortran programmers.

Scilab a general Numerical Array language, similar to Matlab (but free); it contains Park-McClellan (among many others).

As we are on fast Mathematical languages, you may be interested by:

PDL (based on Perl, that I personally hate, but theSyntax of PDL itself is very nice)

Or by: PYTHON

Numpy**,** Numeric extension of Python. But my preferred site on Numpy is Oliphant Travis' (where inside signaltools, you will find Remez).

Here is an example of code using remez from signaltools:

from Numeric import *

import sigtools

import Gnuplot

bands=array((0,0.1,0.15,0.5))

weight = array((100,1))

des=array((1.0,0.0))

n = 41

maxiter=16

grid_density=16

type=sigtools.BANDPASS

Hz=1.0

h=sigtools.remez(n,bands,des,weight,Hz,type,maxiter,grid_density)

g=Gnuplot.Gnuplot()

g.reset

time=arange(n)

d=Gnuplot.Data(time,h)

g.plot(d)

raw_input('Please press return to continue...\n')

#get the frequency response by an fft (power of 2, although fftpack handle any length)

#with a frequency resolution at least grid_density higher than necessary

nfft=1

while nfft < (grid_density * n): nfft = nfft *2

l=zeros((nfft),Complex)

l[(nfft/2-n/2):((nfft/2-n/2)+n):].real = h

from FFT import fft, inverse_fft

# the fft (as usual) is perfomed with time=0,frquency=0 at index 0 of the array

# we prefer it centered at time = n/2, freq = n/2

def cntrdfft(a):

n = a.shape[-1]

shift = ones((n))

half = -ones((n+1)/2)

shift[::2]=half

a = a * shift

A=fft(a)

A= A * shift

return A

L=cntrdfft(l)

R=L.real

I=L.imag

fr=arange(nfft)

g('set data style lines')

g.plot(Gnuplot.Data(fr,R),Gnuplot.Data(fr,I))

raw_input('Please press return to continue...\n')

#et voila!

I have used Gnuplot.py which can be found at http://monsoon.harvard.edu/~mhagger/Gnuplot/Gnuplot.html

All this is cross platform.. and free: Linux, SGI (well, all unixes I suppose), MS Windows (grab compile.py, and have

a cheap version of VC++5.0 or 6.0), …you name it. You can save the plots in plenty of formats (on Windows

right click on the canvas and copy to clipboard, if you want to interface with MS tools).

Other Python links: O'Reilly, pointers to ressources Vault of Parnassus. And one of my preferred (interface to Opengl):