[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |

I hope that someday Octave will include more signal processing functions. If you would like to help improve Octave in this area, please contact bug@octave.org.

__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.

__Loadable Function:__**fft***(*`a`,`n`,`dim`)Compute the FFT of

`a`using subroutines from FFTPACK. The FFT is calculated along the first non-singleton dimension of the array. Thus if`a`is a matrix,`fft (`

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

`n`is expected to be an integer specifying the number of elements of`a`to use, or an empty matrix to specify that its value should be ignored. If`n`is larger than the dimension along which the FFT is calculated, then`a`is resized and padded with zeros. Otherwise, if`n`is smaller than the dimension along which the FFT is calculated, then`a`is truncated.If called with three agruments,

`dim`is an integer specifying the dimension of the matrix along which the FFT is performed

__Loadable Function:__**ifft***(*`a`,`n`,`dim`)Compute the inverse FFT of

`a`using subroutines from FFTPACK. The inverse FFT is calculated along the first non-singleton dimension of the array. Thus if`a`is a matrix,`fft (`

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

`n`is expected to be an integer specifying the number of elements of`a`to use, or an empty matrix to specify that its value should be ignored. If`n`is larger than the dimension along which the inverse FFT is calculated, then`a`is resized and padded with zeros. Otherwise, if`n`is smaller than the dimension along which the inverse FFT is calculated, then`a`is truncated.If called with three agruments,

`dim`is an integer specifying the dimension of the matrix along which the inverse FFT is performed

__Loadable Function:__**fft2***(*`a`,`n`,`m`)Compute the two dimensional FFT of

`a`using subroutines from FFTPACK. 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.If

`a`is a multi-dimensional matrix, each two-dimensional sub-matrix of`a`is treated seperately

__Loadable Function:__**fft2***(*`a`,`n`,`m`)Compute the inverse two dimensional FFT of

`a`using subroutines from FFTPACK. 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.If

`a`is a multi-dimensional matrix, each two-dimensional sub-matrix of`a`is treated seperately

__Loadable Function:__**fftn***(*`a`,`size`)Compute the N dimensional FFT of

`a`using subroutines from FFTPACK. The optional vector argument`size`may be used specify the dimensions of the array to be used. If an element of`size`is smaller than the corresponding dimension, then the dimension is truncated prior to performing the FFT. Otherwise if an element of`size`is larger than the corresponding dimension`a`is resized and padded with zeros.

__Loadable Function:__**ifftn***(*`a`,`size`)Compute the invesre N dimensional FFT of

`a`using subroutines from FFTPACK. The optional vector argument`size`may be used specify the dimensions of the array to be used. If an element of`size`is smaller than the corresponding dimension, then the dimension is truncated prior to performing the inverse FFT. Otherwise if an element of`size`is larger than the corresponding dimension`a`is resized and padded with zeros.

__Function File:__**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.If

`x`is a matrix, filter each column of the matrix.

__Loadable Function:__y =**filter***(*`b`,`a`,`x`)__Loadable Function:__[`y`,`sf`] =**filter***(*`b`,`a`,`x`,`si`)__Loadable Function:__[`y`,`sf`] =**filter***(*`b`,`a`,`x`, [],`dim`)__Loadable Function:__[`y`,`sf`] =**filter***(*`b`,`a`,`x`,`si`,`dim`)Return the solution to the following linear, time-invariant difference equation:

where over the first non-singleton dimension of

`x`or over`dim`if supplied. An equivalent form of this equation is:where

If the fourth argument

`si`is provided, it 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 supplied, the initial state vector is set to all zeros.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:

__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 andThe output value

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

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:__`h`=**freqz***(*`b`,`a`,`w`)Evaluate the response at the specific frequencies in the vector

`w`. The values for`w`are measured in radians.__Function File:__[…] =**freqz***(…,*`Fs`)Return frequencies in Hz instead of radians assuming a sampling rate

`Fs`. If you are evaluating the response at specific frequencies`w`, those frequencies should be requested in Hz rather than radians.__Function File:__**freqz***(…)*Plot the pass band, stop band and phase response of

`h`rather than returning them.

__Function File:__**freqz_plot***(*`w`,`h`)Plot the pass band, stop band and phase response of

`h`.

__Function File:__**sinc***(*`x`)Return

__Function File:__`b`=**unwrap***(*`a`,`tol`,`dim`)Unwrap radian phases by adding multiples of 2*pi as appropriate to remove jumps greater than

`tol`.`tol`defaults to pi.Unwrap will unwrap along the first non-singleton dimension of

`a`, unless the optional argument`dim`is given, in which case the data will be unwrapped along this dimension

__Function File:__[`a`,`b`] =**arch_fit***(*`y`,`x`,`p`,`iter`,`gamma`,`a0`,`b0`)Fit an ARCH regression model to the time series

`y`using the scoring algorithm in Engle's original ARCH paper. The model isy(t) = b(1) * x(t,1) + ... + b(k) * x(t,k) + e(t), h(t) = a(1) + a(2) * e(t-1)^2 + ... + a(p+1) * e(t-p)^2

in which

*e(t)*is*N(0, h(t))*, given a time-series vector`y`up to time*t-1*and a matrix of (ordinary) regressors`x`up to*t*. The order of the regression of the residual variance is specified by`p`.If invoked as

`arch_fit (`

with a positive integer`y`,`k`,`p`)`k`, fit an ARCH(`k`,`p`) process, i.e., do the above with the*t*-th row of`x`given by[1, y(t-1), ..., y(t-k)]

Optionally, one can specify the number of iterations

`iter`, the updating factor`gamma`, and initial values*a0*and*b0*for the scoring algorithm.

__Function File:__**arch_rnd***(*`a`,`b`,`t`)Simulate an ARCH sequence of length

`t`with AR coefficients`b`and CH coefficients`a`. I.e., the result*y(t)*follows the modely(t) = b(1) + b(2) * y(t-1) + … + b(lb) * y(t-lb+1) + e(t),

where

*e(t)*, given`y`up to time*t-1*, is*N(0, h(t))*, withh(t) = a(1) + a(2) * e(t-1)^2 + … + a(la) * e(t-la+1)^2

__Function File:__[`pval`,`lm`] =**arch_test***(*`y`,`x`,`p`)For a linear regression model

y = x * b + e

perform a Lagrange Multiplier (LM) test of the null hypothesis of no conditional heteroscedascity against the alternative of CH(

`p`).I.e., the model is

y(t) = b(1) * x(t,1) + … + b(k) * x(t,k) + e(t),

given

`y`up to*t-1*and`x`up to*t*,*e*(t) is*N(0, h(t))*withh(t) = v + a(1) * e(t-1)^2 + … + a(p) * e(t-p)^2,

and the null is

*a(1)*== … ==*a(p)*== 0.If the second argument is a scalar integer,

*k*, perform the same test in a linear autoregression model of order*k*, i.e., with[1, y(t-1), …, y(t-

`k`)]as the

*t*-th row of`x`.Under the null, LM approximately has a chisquare distribution with

`p`degrees of freedom and`pval`is the*p*-value (1 minus the CDF of this distribution at LM) of the test.If no output argument is given, the

*p*-value is displayed.

__Function File:__**arma_rnd***(*`a`,`b`,`v`,`t`,`n`)Return a simulation of the ARMA model

x(n) = a(1) * x(n-1) + ... + a(k) * x(n-k) + e(n) + b(1) * e(n-1) + ... + b(l) * e(n-l)

in which

`k`is the length of vector`a`,`l`is the length of vector`b`and`e`is gaussian white noise with variance`v`. The function returns a vector of length`t`.The optional parameter

`n`gives the number of dummy`x`(`i`) used for initialization, i.e., a sequence of length`t`+`n`is generated and`x`(`n`+1:`t`+`n`) is returned. If`n`is omitted,`n`= 100 is used.

__Function File:__**autocor***(*`x`,`h`)Return the autocorrelations from lag 0 to

`h`of vector`x`. If`h`is omitted, all autocorrelations are computed. If`x`is a matrix, the autocorrelations of each column are computed.

__Function File:__**autocov***(*`x`,`h`)Return the autocovariances from lag 0 to

`h`of vector`x`. If`h`is omitted, all autocovariances are computed. If`x`is a matrix, the autocovariances of each column are computed.

__Function File:__**autoreg_matrix***(*`y`,`k`)Given a time series (vector)

`y`, return a matrix with ones in the first column and the first`k`lagged values of`y`in the other columns. I.e., for`t`>`k`,`[1,`

is the t-th row of the result. The resulting matrix may be used as a regressor matrix in autoregressions.`y`(`t`-1), ...,`y`(`t`-`k`)]

__Function File:__**bartlett***(*`m`)Return the filter coefficients of a Bartlett (triangular) window of length

`m`.For a definition of the Bartlett window, see e.g. A. V. Oppenheim & R. W. Schafer, "Discrete-Time Signal Processing".

__Function File:__**blackman***(*`m`)Return the filter coefficients of a Blackman window of length

`m`.For a definition of the Blackman window, see e.g. A. V. Oppenheim & R. W. Schafer, "Discrete-Time Signal Processing".

__Function File:__[`d`,`dd`]**=***diffpara (*`x`,`a`,`b`)Return the estimator

`d`for the differencing parameter of an integrated time series.The frequencies from

*[2*pi*a/t, 2*pi*b/T]*are used for the estimation. If`b`is omitted, the interval*[2*pi/T, 2*pi*a/T]*is used. If both`b`and`a`are omitted then*a = 0.5 * sqrt (T)*and*b = 1.5 * sqrt (T)*is used, where*T*is the sample size. If`x`is a matrix, the differencing parameter of each column is estimated.The estimators for all frequencies in the intervals described above is returned in

`dd`. The value of`d`is simply the mean of`dd`.Reference: Brockwell, Peter J. & Davis, Richard A. Time Series: Theory and Methods Springer 1987.

__Function File:__**durbinlevinson***(*`c`,`oldphi`,`oldv`)Perform one step of the Durbin-Levinson algorithm.

The vector

`c`specifies the autocovariances`[gamma_0, ..., gamma_t]`

from lag 0 to`t`,`oldphi`specifies the coefficients based on`c`(`t`-1) and`oldv`specifies the corresponding error.If

`oldphi`and`oldv`are omitted, all steps from 1 to`t`of the algorithm are performed.

__Function File:__**fftshift***(*`v`)__Function File:__**fftshift***(*`v`,`dim`)Perform a shift of the vector

`v`, for use with the`fft`

and`ifft`

functions, in order the move the frequency 0 to the center of the vector or matrix.If

`v`is a vector of*N*elements corresponding to*N*time samples spaced of*Dt*each, then`fftshift (fft (`

corresponds to frequencies`v`))f = ((1:N) - ceil(N/2)) / N / Dt

If

`v`is a matrix, the same holds for rows and columns. If`v`is an array, then the same holds along each dimension.The optional

`dim`argument can be used to limit the dimension along which the permutation occurs.

__Function File:__**fractdiff***(*`x`,`d`)Compute the fractional differences

*(1-L)^d x*where*L*denotes the lag-operator and*d*is greater than -1.

__Function File:__**hamming***(*`m`)Return the filter coefficients of a Hamming window of length

`m`.For a definition of the Hamming window, see e.g. A. V. Oppenheim & R. W. Schafer, "Discrete-Time Signal Processing".

__Function File:__**hanning***(*`m`)Return the filter coefficients of a Hanning window of length

`m`.For a definition of this window type, see e.g. A. V. Oppenheim & R. W. Schafer, "Discrete-Time Signal Processing".

__Function File:__**hurst***(*`x`)Estimate the Hurst parameter of sample

`x`via the rescaled range statistic. If`x`is a matrix, the parameter is estimated for every single column.

__Function File:__**periodogram***(*`x`)For a data matrix

`x`from a sample of size`n`, return the periodogram.

__Function File:__**rectangle_lw***(*`n`,`b`)Rectangular lag window. Subfunction used for spectral density estimation.

__Function File:__**rectangle_sw***(*`n`,`b`)Rectangular spectral window. Subfunction used for spectral density estimation.

__Function File:__**sinetone***(*`freq`,`rate`,`sec`,`ampl`)Return a sinetone of frequency

`freq`with length of`sec`seconds at sampling rate`rate`and with amplitude`ampl`. The arguments`freq`and`ampl`may be vectors of common size.Defaults are

`rate`= 8000,`sec`= 1 and`ampl`= 64.

__Function File:__**sinewave***(*`m`,`n`,`d`)Return an

`m`-element vector with`i`-th element given by`sin (2 * pi * (`

.`i`+`d`-1) /`n`)The default value for

`d`is 0 and the default value for`n`is`m`.

__Function File:__**spectral_adf***(*`c`,`win`,`b`)Return the spectral density estimator given a vector of autocovariances

`c`, window name`win`, and bandwidth,`b`.The window name, e.g.,

`"triangle"`

or`"rectangle"`

is used to search for a function called

.`win`_swIf

`win`is omitted, the triangle window is used. If`b`is omitted,`1 / sqrt (length (`

is used.`x`))

__Function File:__**spectral_xdf***(*`x`,`win`,`b`)Return the spectral density estimator given a data vector

`x`, window name`win`, and bandwidth,`b`.The window name, e.g.,

`"triangle"`

or`"rectangle"`

is used to search for a function called

.`win`_swIf

`win`is omitted, the triangle window is used. If`b`is omitted,`1 / sqrt (length (`

is used.`x`))

__Function File:__**spencer***(*`x`)Return Spencer's 15 point moving average of every single column of

`x`.

__Function File:__[`y`,`c`]**=***stft (*`x`,`win_size`,`inc`,`num_coef`,`w_type`)Compute the short-term Fourier transform of the vector

`x`with`num_coef`coefficients by applying a window of`win_size`data points and an increment of`inc`points.Before computing the Fourier transform, one of the following windows is applied:

- hanning
w_type = 1

- hamming
w_type = 2

- rectangle
w_type = 3

The window names can be passed as strings or by the

`w_type`number.If not all arguments are specified, the following defaults are used:

`win_size`= 80,`inc`= 24,`num_coef`= 64, and`w_type`= 1.

returns the absolute values of the Fourier coefficients according to the`y`= stft (`x`, …)`num_coef`positive frequencies.`[`

returns the entire STFT-matrix`y`,`c`] = stft (`x`

, …)`y`and a 3-element vector`c`containing the window size, increment, and window type, which is needed by the synthesis function.

__Function File:__**synthesis***(*`y`,`c`)Compute a signal from its short-time Fourier transform

`y`and a 3-element vector`c`specifying window size, increment, and window type.The values

`y`and`c`can be derived by[

`y`,`c`] = stft (`x`, …)

__Function File:__**triangle_lw***(*`n`,`b`)Triangular lag window. Subfunction used for spectral density estimation.

__Function File:__**triangle_sw***(*`n`,`b`)Triangular spectral window. Subfunction used for spectral density estimation.

__Function File:__[`a`,`v`] =**yulewalker***(*`c`)Fit an AR (p)-model with Yule-Walker estimates given a vector

`c`of autocovariances`[gamma_0, ..., gamma_p]`

.Returns the AR coefficients,

`a`, and the variance of white noise,`v`.

[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] |

This document was generated on *July, 20 2006* using *texi2html 1.76*.