I hope that someday Octave will include more signal processing functions. If you would like to help improve Octave in this area, please contact @email{bug-octave@bevo.che.wisc.edu}.

__Function File:__**detrend***(*`x`,`p`)-
If
`x`is a vector,`detrend (`

removes the best fit of a polynomial of order`x`,`p`)`p`from the data`x`.If

`x`is a matrix,`detrend (`

does the same for each column in`x`,`p`)`x`.The second argument is optional. If it is not specified, a value of 1 is assumed. This corresponds to removing a linear trend.

__Function:__**fft***(*`a`,`n`)-
Compute the FFT of
`a`using subroutines from FFTPACK. If`a`is a matrix,`fft`

computes the FFT for each column of`a`.If called with two arguments,

`n`is expected to be an integer specifying the number of elements of`a`to use. If`a`is a matrix,`n`specifies the number of rows of`a`to use. If`n`is larger than the size of`a`,`a`is resized and padded with zeros.

__Loadable Function:__**ifft***(*`a`,`n`)-
Compute the inverse FFT of
`a`using subroutines from FFTPACK. If`a`is a matrix,`fft`

computes the inverse FFT for each column of`a`.If called with two arguments,

`n`is expected to be an integer specifying the number of elements of`a`to use. If`a`is a matrix,`n`specifies the number of rows of`a`to use. If`n`is larger than the size of`a`,`a`is resized and padded with zeros.

__Loadable Function:__**fft2***(*`a`,`n`,`m`)-
Compute the two dimensional FFT of
`a`.The optional arguments

`n`and`m`may be used specify the number of rows and columns of`a`to use. If either of these is larger than the size of`a`,`a`is resized and padded with zeros.

__Loadable Function:__**ifft2***(*`a`,`n`,`m`)-
Compute the two dimensional inverse FFT of
`a`.The optional arguments

`n`and`m`may be used specify the number of rows and columns of`a`to use. If either of these is larger than the size of`a`,`a`is resized and padded with zeros.

__Built-in Function:__**fftconv***(*`a`,`b`,`n`)-
Return the convolution of the vectors
`a`and`b`, as a vector with length equal to the`length (a) + length (b) - 1`

. If`a`and`b`are the coefficient vectors of two polynomials, the returned value is the coefficient vector of the product polynomial.The computation uses the FFT by calling the function

`fftfilt`

. If the optional argument`n`is specified, an N-point FFT is used.

__Function File:__**fftfilt***(*`b`,`x`,`n`)-
With two arguments,

`fftfilt`

filters`x`with the FIR filter`b`using the FFT.Given the optional third argument,

`n`,`fftfilt`

uses the overlap-add method to filter`x`with`b`using an N-point FFT.

__Loadable Function:__y =**filter***(*`b`,`a`,`x`)-
Return the solution to the following linear, time-invariant difference
equation:
N M SUM a(k+1) y(n-k) = SUM b(k+1) x(n-k) for 1<=n<=length(x) k=0 k=0

where N=length(a)-1 and M=length(b)-1. An equivalent form of this equation is:

N M y(n) = - SUM c(k+1) y(n-k) + SUM d(k+1) x(n-k) for 1<=n<=length(x) k=1 k=0

where c = a/a(1) and d = b/a(1).

In terms of the z-transform, y is the result of passing the discrete- time signal x through a system characterized by the following rational system function:

M SUM d(k+1) z^(-k) k=0 H(z) = ---------------------- N 1 + SUM c(k+1) z(-k) k=1

__Loadable Function:__[`y`,`sf`] =**filter***(*`b`,`a`,`x`,`si`)-
This is the same as the
`filter`

function described above, except that`si`is taken as the initial state of the system and the final state is returned as`sf`. The state vector is a column vector whose length is equal to the length of the longest coefficient vector minus one. If`si`is not set, the initial state vector is set to all zeros.

__Function File:__[`h`,`w`] =**freqz***(*`b`,`a`,`n`, "whole")-
Return the complex frequency response
`h`of the rational IIR filter whose numerator and denominator coefficients are`b`and`a`, respectively. The response is evaluated at`n`angular frequencies between 0 and 2*pi.The output value

`w`is a vector of the frequencies.If the fourth argument is omitted, the response is evaluated at frequencies between 0 and pi.

If

`n`is omitted, a value of 512 is assumed.If

`a`is omitted, the denominator is assumed to be 1 (this corresponds to a simple FIR filter).For fastest computation,

`n`should factor into a small number of small primes.

__Function File:__**sinc***(*`x`)- Return sin(pi*x)/(pi*x).

Go to the first, previous, next, last section, table of contents.