--- /dev/null
+# Created by Octave 3.6.1, Thu May 17 20:38:50 2012 UTC <root@brouzouf>
+# name: cache
+# type: cell
+# rows: 3
+# columns: 130
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 6
+ar_psd
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 4320
+ Usage:
+ [psd,f_out] = ar_psd(a,v,freq,Fs,range,method,plot_type)
+
+ Calculate the power spectrum of the autoregressive model
+
+ M
+ x(n) = sqrt(v).e(n) + SUM a(k).x(n-k)
+ k=1
+ where x(n) is the output of the model and e(n) is white noise.
+ This function is intended for use with
+ [a,v,k] = arburg(x,poles,criterion)
+ which use the Burg (1968) method to calculate a "maximum entropy"
+ autoregressive model of "x". This function runs on octave and matlab.
+
+ If the "freq" argument is a vector (of frequencies) the spectrum is
+ calculated using the polynomial method and the "method" argument is
+ ignored. For scalar "freq", an integer power of 2, or "method='FFT'",
+ causes the spectrum to be calculated by FFT. Otherwise, the spectrum
+ is calculated as a polynomial. It may be computationally more
+ efficient to use the FFT method if length of the model is not much
+ smaller than the number of frequency values. The spectrum is scaled so
+ that spectral energy (area under spectrum) is the same as the
+ time-domain energy (mean square of the signal).
+
+ ARGUMENTS:
+ All but the first two arguments are optional and may be empty.
+
+ a %% [vector] list of M=(order+1) autoregressive model
+ %% coefficients. The first element of "ar_coeffs" is the
+ %% zero-lag coefficient, which always has a value of 1.
+
+ v %% [real scalar] square of the moving-average coefficient of
+ %% the AR model.
+
+ freq %% [real vector] frequencies at which power spectral density
+ %% is calculated
+ %% [integer scalar] number of uniformly distributed frequency
+ %% values at which spectral density is calculated.
+ %% [default=256]
+
+ Fs %% [real scalar] sampling frequency (Hertz) [default=1]
+
+ CONTROL-STRING ARGUMENTS -- each of these arguments is a character string.
+ Control-string arguments can be in any order after the other arguments.
+
+ range %% 'half', 'onesided' : frequency range of the spectrum is
+ %% from zero up to but not including sample_f/2. Power
+ %% from negative frequencies is added to the positive
+ %% side of the spectrum.
+ %% 'whole', 'twosided' : frequency range of the spectrum is
+ %% -sample_f/2 to sample_f/2, with negative frequencies
+ %% stored in "wrap around" order after the positive
+ %% frequencies; e.g. frequencies for a 10-point 'twosided'
+ %% spectrum are 0 0.1 0.2 0.3 0.4 0.5 -0.4 -0.3 -0.2 -0.1
+ %% 'shift', 'centerdc' : same as 'whole' but with the first half
+ %% of the spectrum swapped with second half to put the
+ %% zero-frequency value in the middle. (See "help
+ %% fftshift". If "freq" is vector, 'shift' is ignored.
+ %% If model coefficients "ar_coeffs" are real, the default
+ %% range is 'half', otherwise default range is 'whole'.
+
+ method %% 'fft': use FFT to calculate power spectrum.
+ %% 'poly': calculate power spectrum as a polynomial of 1/z
+ %% N.B. this argument is ignored if the "freq" argument is a
+ %% vector. The default is 'poly' unless the "freq"
+ %% argument is an integer power of 2.
+
+ plot_type%% 'plot', 'semilogx', 'semilogy', 'loglog', 'squared' or 'db':
+ %% specifies the type of plot. The default is 'plot', which
+ %% means linear-linear axes. 'squared' is the same as 'plot'.
+ %% 'dB' plots "10*log10(psd)". This argument is ignored and a
+ %% spectrum is not plotted if the caller requires a returned
+ %% value.
+
+ RETURNED VALUES:
+ If returned values are not required by the caller, the spectrum
+ is plotted and nothing is returned.
+ psd %% [real vector] estimate of power-spectral density
+ f_out %% [real vector] frequency values
+
+ N.B. arburg runs in octave and matlab, and does not depend on octave-forge
+ or signal-processing-toolbox functions.
+
+ REFERENCE
+ [1] Equation 2.28 from Steven M. Kay and Stanley Lawrence Marple Jr.:
+ "Spectrum analysis -- a modern perspective",
+ Proceedings of the IEEE, Vol 69, pp 1380-1419, Nov., 1981
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 68
+ Usage:
+ [psd,f_out] = ar_psd(a,v,freq,Fs,range,method,plot_type)
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 6
+arburg
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 4080
+ [a,v,k] = arburg(x,poles,criterion)
+
+ Calculate coefficients of an autoregressive (AR) model of complex data
+ "x" using the whitening lattice-filter method of Burg (1968). The inverse
+ of the model is a moving-average filter which reduces "x" to white noise.
+ The power spectrum of the AR model is an estimate of the maximum
+ entropy power spectrum of the data. The function "ar_psd" calculates the
+ power spectrum of the AR model.
+
+ ARGUMENTS:
+ x %% [vector] sampled data
+
+ poles %% [integer scalar] number of poles in the AR model or
+ %% limit to the number of poles if a
+ %% valid "stop_crit" is provided.
+
+ criterion %% [optional string arg] model-selection criterion. Limits
+ %% the number of poles so that spurious poles are not
+ %% added when the whitened data has no more information
+ %% in it (see Kay & Marple, 1981). Recognised values are
+ %% 'AKICc' -- approximate corrected Kullback information
+ %% criterion (recommended),
+ %% 'KIC' -- Kullback information criterion
+ %% 'AICc' -- corrected Akaike information criterion
+ %% 'AIC' -- Akaike information criterion
+ %% 'FPE' -- final prediction error" criterion
+ %% The default is to NOT use a model-selection criterion
+
+ RETURNED VALUES:
+ a %% [polynomial/vector] list of (P+1) autoregression coeffic-
+ %% ients; for data input x(n) and white noise e(n),
+ %% the model is
+ %% P+1
+ %% x(n) = sqrt(v).e(n) + SUM a(k).x(n-k)
+ %% k=1
+
+ v %% [real scalar] mean square of residual noise from the
+ %% whitening operation of the Burg lattice filter.
+
+ k %% [column vector] reflection coefficients defining the
+ %% lattice-filter embodiment of the model
+
+ HINTS:
+ (1) arburg does not remove the mean from the data. You should remove
+ the mean from the data if you want a power spectrum. A non-zero mean
+ can produce large errors in a power-spectrum estimate. See
+ "help detrend".
+ (2) If you don't know what the value of "poles" should be, choose the
+ largest (reasonable) value you could want and use the recommended
+ value, criterion='AKICc', so that arburg can find it.
+ E.g. arburg(x,64,'AKICc')
+ The AKICc has the least bias and best resolution of the available
+ model-selection criteria.
+ (3) arburg runs in octave and matlab, does not depend on octave forge
+ or signal-processing-toolbox functions.
+ (4) Autoregressive and moving-average filters are stored as polynomials
+ which, in matlab, are row vectors.
+
+ NOTE ON SELECTION CRITERION
+ AIC, AICc, KIC and AKICc are based on information theory. They attempt
+ to balance the complexity (or length) of the model against how well the
+ model fits the data. AIC and KIC are biassed estimates of the asymmetric
+ and the symmetric Kullback-Leibler divergence respectively. AICc and
+ AKICc attempt to correct the bias. See reference [4].
+
+
+ REFERENCES
+ [1] John Parker Burg (1968)
+ "A new analysis technique for time series data",
+ NATO advanced study Institute on Signal Processing with Emphasis on
+ Underwater Acoustics, Enschede, Netherlands, Aug. 12-23, 1968.
+
+ [2] Steven M. Kay and Stanley Lawrence Marple Jr.:
+ "Spectrum analysis -- a modern perspective",
+ Proceedings of the IEEE, Vol 69, pp 1380-1419, Nov., 1981
+
+ [3] William H. Press and Saul A. Teukolsky and William T. Vetterling and
+ Brian P. Flannery
+ "Numerical recipes in C, The art of scientific computing", 2nd edition,
+ Cambridge University Press, 2002 --- Section 13.7.
+
+ [4] Abd-Krim Seghouane and Maiza Bekara
+ "A small sample model selection criterion based on Kullback's symmetric
+ divergence", IEEE Transactions on Signal Processing,
+ Vol. 52(12), pp 3314-3323, Dec. 2004
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 37
+ [a,v,k] = arburg(x,poles,criterion)
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 6
+aryule
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 799
+ usage: [a, v, k] = aryule (x, p)
+
+ fits an AR (p)-model with Yule-Walker estimates.
+ x = data vector to estimate
+ a: AR coefficients
+ v: variance of white noise
+ k: reflection coeffients for use in lattice filter
+
+ The power spectrum of the resulting filter can be plotted with
+ pyulear(x, p), or you can plot it directly with ar_psd(a,v,...).
+
+ See also:
+ pyulear, power, freqz, impz -- for observing characteristics of the model
+ arburg -- for alternative spectral estimators
+
+ Example: Use example from arburg, but substitute aryule for arburg.
+
+ Note: Orphanidis '85 claims lattice filters are more tolerant of
+ truncation errors, which is why you might want to use them. However,
+ lacking a lattice filter processor, I haven't tested that the lattice
+ filter coefficients are reasonable.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 80
+ usage: [a, v, k] = aryule (x, p)
+
+ fits an AR (p)-model with Yule-Walker esti
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 11
+barthannwin
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 136
+ -- Function File: [W] = barthannwin(L)
+ Compute the modified Bartlett-Hann window of lenght L.
+
+ See also: rectwin, bartlett
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 54
+Compute the modified Bartlett-Hann window of lenght L.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 8
+besselap
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 105
+ Return bessel analog filter prototype.
+
+ References:
+
+ http://en.wikipedia.org/wiki/Bessel_polynomials
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 39
+ Return bessel analog filter prototype.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 7
+besself
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 804
+ Generate a bessel filter.
+ Default is a Laplace space (s) filter.
+
+ [b,a] = besself(n, Wc)
+ low pass filter with cutoff pi*Wc radians
+
+ [b,a] = besself(n, Wc, 'high')
+ high pass filter with cutoff pi*Wc radians
+
+ [b,a] = besself(n, [Wl, Wh])
+ band pass filter with edges pi*Wl and pi*Wh radians
+
+ [b,a] = besself(n, [Wl, Wh], 'stop')
+ band reject filter with edges pi*Wl and pi*Wh radians
+
+ [z,p,g] = besself(...)
+ return filter as zero-pole-gain rather than coefficients of the
+ numerator and denominator polynomials.
+
+ [...] = besself(...,'z')
+ return a discrete space (Z) filter, W must be less than 1.
+
+ [a,b,c,d] = besself(...)
+ return state-space matrices
+
+ References:
+
+ Proakis & Manolakis (1992). Digital Signal Processing. New York:
+ Macmillan Publishing Company.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 26
+ Generate a bessel filter.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 8
+bilinear
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 2658
+ usage: [Zz, Zp, Zg] = bilinear(Sz, Sp, Sg, T)
+ [Zb, Za] = bilinear(Sb, Sa, T)
+
+ Transform a s-plane filter specification into a z-plane
+ specification. Filters can be specified in either zero-pole-gain or
+ transfer function form. The input form does not have to match the
+ output form. 1/T is the sampling frequency represented in the z plane.
+
+ Note: this differs from the bilinear function in the signal processing
+ toolbox, which uses 1/T rather than T.
+
+ Theory: Given a piecewise flat filter design, you can transform it
+ from the s-plane to the z-plane while maintaining the band edges by
+ means of the bilinear transform. This maps the left hand side of the
+ s-plane into the interior of the unit circle. The mapping is highly
+ non-linear, so you must design your filter with band edges in the
+ s-plane positioned at 2/T tan(w*T/2) so that they will be positioned
+ at w after the bilinear transform is complete.
+
+ The following table summarizes the transformation:
+
+ +---------------+-----------------------+----------------------+
+ | Transform | Zero at x | Pole at x |
+ | H(S) | H(S) = S-x | H(S)=1/(S-x) |
+ +---------------+-----------------------+----------------------+
+ | 2 z-1 | zero: (2+xT)/(2-xT) | zero: -1 |
+ | S -> - --- | pole: -1 | pole: (2+xT)/(2-xT) |
+ | T z+1 | gain: (2-xT)/T | gain: (2-xT)/T |
+ +---------------+-----------------------+----------------------+
+
+ With tedious algebra, you can derive the above formulae yourself by
+ substituting the transform for S into H(S)=S-x for a zero at x or
+ H(S)=1/(S-x) for a pole at x, and converting the result into the
+ form:
+
+ H(Z)=g prod(Z-Xi)/prod(Z-Xj)
+
+ Please note that a pole and a zero at the same place exactly cancel.
+ This is significant since the bilinear transform creates numerous
+ extra poles and zeros, most of which cancel. Those which do not
+ cancel have a "fill-in" effect, extending the shorter of the sets to
+ have the same number of as the longer of the sets of poles and zeros
+ (or at least split the difference in the case of the band pass
+ filter). There may be other opportunistic cancellations but I will
+ not check for them.
+
+ Also note that any pole on the unit circle or beyond will result in
+ an unstable filter. Because of cancellation, this will only happen
+ if the number of poles is smaller than the number of zeros. The
+ analytic design methods all yield more poles than zeros, so this will
+ not be a problem.
+
+ References:
+
+ Proakis & Manolakis (1992). Digital Signal Processing. New York:
+ Macmillan Publishing Company.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 80
+ usage: [Zz, Zp, Zg] = bilinear(Sz, Sp, Sg, T)
+ [Zb, Za] = bilinear(Sb, S
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 11
+bitrevorder
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 111
+ -- Function File: [Y I] = bitrevorder(X)
+ Reorder x in the bit reversed order
+
+ See also: fft, ifft
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 36
+Reorder x in the bit reversed order
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 14
+blackmanharris
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 120
+ -- Function File: [W] = blackmanharris(L)
+ Compute the Blackman-Harris window.
+
+ See also: rectwin, bartlett
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 35
+Compute the Blackman-Harris window.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 15
+blackmannuttall
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 123
+ -- Function File: [W] = blackmannuttall(L)
+ Compute the Blackman-Nuttall window.
+
+ See also: nuttallwin, kaiser
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 36
+Compute the Blackman-Nuttall window.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 9
+bohmanwin
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 118
+ -- Function File: [W] = bohmanwin(L)
+ Compute the Bohman window of lenght L.
+
+ See also: rectwin, bartlett
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 38
+Compute the Bohman window of lenght L.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 6
+boxcar
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 95
+ usage: w = boxcar (n)
+
+ Returns the filter coefficients of a rectangular window of length n.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 24
+ usage: w = boxcar (n)
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 6
+buffer
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 1473
+ -- Function File: Y = buffer (X, N, P, OPT)
+ -- Function File: [Y, Z, OPT] = buffer (...)
+ Buffer a signal into a data frame. The arguments to `buffer' are
+
+ X
+ The data to be buffered.
+
+ N
+ The number of rows in the produced data buffer. This is an
+ positive integer value and must be supplied.
+
+ P
+ An integer less than N that specifies the under- or overlap
+ between column in the data frame. The default value of P is 0.
+
+ OPT
+ In the case of an overlap, OPT can be either a vector of
+ length P or the string 'nodelay'. If OPT is a vector, then the
+ first P entries in Y will be filled with these values. If OPT
+ is the string 'nodelay', then the first value of Y
+ corresponds to the first value of X.
+
+ In the can of an underlap, OPT must be an integer between 0
+ and `-P'. The represents the initial underlap of the first
+ column of Y.
+
+ The default value for OPT the vector `zeros (1, P)' in the
+ case of an overlap, or 0 otherwise.
+
+ In the case of a single output argument, Y will be padded with
+ zeros to fill the missing values in the data frame. With two output
+ arguments Z is the remaining data that has not been used in the
+ current data frame.
+
+ Likewise, the output OPT is the overlap, or underlap that might be
+ used for a future call to `code' to allow continuous buffering.
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 34
+Buffer a signal into a data frame.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 6
+butter
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 799
+ Generate a butterworth filter.
+ Default is a discrete space (Z) filter.
+
+ [b,a] = butter(n, Wc)
+ low pass filter with cutoff pi*Wc radians
+
+ [b,a] = butter(n, Wc, 'high')
+ high pass filter with cutoff pi*Wc radians
+
+ [b,a] = butter(n, [Wl, Wh])
+ band pass filter with edges pi*Wl and pi*Wh radians
+
+ [b,a] = butter(n, [Wl, Wh], 'stop')
+ band reject filter with edges pi*Wl and pi*Wh radians
+
+ [z,p,g] = butter(...)
+ return filter as zero-pole-gain rather than coefficients of the
+ numerator and denominator polynomials.
+
+ [...] = butter(...,'s')
+ return a Laplace space filter, W can be larger than 1.
+
+ [a,b,c,d] = butter(...)
+ return state-space matrices
+
+ References:
+
+ Proakis & Manolakis (1992). Digital Signal Processing. New York:
+ Macmillan Publishing Company.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 31
+ Generate a butterworth filter.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 7
+buttord
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 1107
+ Compute butterworth filter order and cutoff for the desired response
+ characteristics. Rp is the allowable decibels of ripple in the pass
+ band. Rs is the minimum attenuation in the stop band.
+
+ [n, Wc] = buttord(Wp, Ws, Rp, Rs)
+ Low pass (Wp<Ws) or high pass (Wp>Ws) filter design. Wp is the
+ pass band edge and Ws is the stop band edge. Frequencies are
+ normalized to [0,1], corresponding to the range [0,Fs/2].
+
+ [n, Wc] = buttord([Wp1, Wp2], [Ws1, Ws2], Rp, Rs)
+ Band pass (Ws1<Wp1<Wp2<Ws2) or band reject (Wp1<Ws1<Ws2<Wp2)
+ filter design. Wp gives the edges of the pass band, and Ws gives
+ the edges of the stop band.
+
+ Theory: |H(W)|^2 = 1/[1+(W/Wc)^(2N)] = 10^(-R/10)
+ With some algebra, you can solve simultaneously for Wc and N given
+ Ws,Rs and Wp,Rp. For high pass filters, subtracting the band edges
+ from Fs/2, performing the test, and swapping the resulting Wc back
+ works beautifully. For bandpass and bandstop filters this process
+ significantly overdesigns. Artificially dividing N by 2 in this case
+ helps a lot, but it still overdesigns.
+
+ See also: butter
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 80
+ Compute butterworth filter order and cutoff for the desired response
+ character
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 5
+cceps
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 195
+ usage: cceps (x [, correct])
+
+ Returns the complex cepstrum of the vector x.
+ If the optional argument correct has the value 1, a correction
+ method is applied. The default is not to do this.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 31
+ usage: cceps (x [, correct])
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 4
+cheb
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 371
+ Usage: cheb (n, x)
+
+ Returns the value of the nth-order Chebyshev polynomial calculated at
+ the point x. The Chebyshev polynomials are defined by the equations:
+
+ / cos(n acos(x), |x| <= 1
+ Tn(x) = |
+ \ cosh(n acosh(x), |x| > 1
+
+ If x is a vector, the output is a vector of the same size, where each
+ element is calculated as y(i) = Tn(x(i)).
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 21
+ Usage: cheb (n, x)
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 8
+cheb1ord
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 678
+ Compute chebyshev type I filter order and cutoff for the desired response
+ characteristics. Rp is the allowable decibels of ripple in the pass
+ band. Rs is the minimum attenuation in the stop band.
+
+ [n, Wc] = cheb1ord(Wp, Ws, Rp, Rs)
+ Low pass (Wp<Ws) or high pass (Wp>Ws) filter design. Wp is the
+ pass band edge and Ws is the stop band edge. Frequencies are
+ normalized to [0,1], corresponding to the range [0,Fs/2].
+
+ [n, Wc] = cheb1ord([Wp1, Wp2], [Ws1, Ws2], Rp, Rs)
+ Band pass (Ws1<Wp1<Wp2<Ws2) or band reject (Wp1<Ws1<Ws2<Wp2)
+ filter design. Wp gives the edges of the pass band, and Ws gives
+ the edges of the stop band.
+
+ See also: cheby1
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 80
+ Compute chebyshev type I filter order and cutoff for the desired response
+ char
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 8
+cheb2ord
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 690
+ Compute chebyshev type II filter order and cutoff for the desired response
+ characteristics. Rp is the allowable decibels of ripple in the pass
+ band. Rs is the minimum attenuation in the stop band.
+
+ [n, Wc] = cheb2ord(Wp, Ws, Rp, Rs)
+ Low pass (Wp<Ws) or high pass (Wp>Ws) filter design. Wp is the
+ pass band edge and Ws is the stop band edge. Frequencies are
+ normalized to [0,1], corresponding to the range [0,Fs/2].
+
+ [n, Wc] = cheb2ord([Wp1, Wp2], [Ws1, Ws2], Rp, Rs)
+ Band pass (Ws1<Wp1<Wp2<Ws2) or band reject (Wp1<Ws1<Ws2<Wp2)
+ filter design. Wp gives the edges of the pass band, and Ws gives
+ the edges of the stop band.
+
+ Theory:
+
+ See also: cheby2
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 80
+ Compute chebyshev type II filter order and cutoff for the desired response
+ cha
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 7
+chebwin
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 1095
+ Usage: chebwin (L, at)
+
+ Returns the filter coefficients of the L-point Dolph-Chebyshev window
+ with at dB of attenuation in the stop-band of the corresponding
+ Fourier transform.
+
+ For the definition of the Chebyshev window, see
+
+ * Peter Lynch, "The Dolph-Chebyshev Window: A Simple Optimal Filter",
+ Monthly Weather Review, Vol. 125, pp. 655-660, April 1997.
+ (http://www.maths.tcd.ie/~plynch/Publications/Dolph.pdf)
+
+ * C. Dolph, "A current distribution for broadside arrays which
+ optimizes the relationship between beam width and side-lobe level",
+ Proc. IEEE, 34, pp. 335-348.
+
+ The window is described in frequency domain by the expression:
+
+ Cheb(L-1, beta * cos(pi * k/L))
+ W(k) = -------------------------------
+ Cheb(L-1, beta)
+
+ with
+
+ beta = cosh(1/(L-1) * acosh(10^(at/20))
+
+ and Cheb(m,x) denoting the m-th order Chebyshev polynomial calculated
+ at the point x.
+
+ Note that the denominator in W(k) above is not computed, and after
+ the inverse Fourier transform the window is scaled by making its
+ maximum value unitary.
+
+ See also: kaiser
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 25
+ Usage: chebwin (L, at)
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 6
+cheby1
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 802
+ Generate an Chebyshev type I filter with Rp dB of pass band ripple.
+
+ [b, a] = cheby1(n, Rp, Wc)
+ low pass filter with cutoff pi*Wc radians
+
+ [b, a] = cheby1(n, Rp, Wc, 'high')
+ high pass filter with cutoff pi*Wc radians
+
+ [b, a] = cheby1(n, Rp, [Wl, Wh])
+ band pass filter with edges pi*Wl and pi*Wh radians
+
+ [b, a] = cheby1(n, Rp, [Wl, Wh], 'stop')
+ band reject filter with edges pi*Wl and pi*Wh radians
+
+ [z, p, g] = cheby1(...)
+ return filter as zero-pole-gain rather than coefficients of the
+ numerator and denominator polynomials.
+
+ [...] = cheby1(...,'s')
+ return a Laplace space filter, W can be larger than 1.
+
+ [a,b,c,d] = cheby1(...)
+ return state-space matrices
+
+ References:
+
+ Parks & Burrus (1987). Digital Filter Design. New York:
+ John Wiley & Sons, Inc.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 68
+ Generate an Chebyshev type I filter with Rp dB of pass band ripple.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 6
+cheby2
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 808
+ Generate an Chebyshev type II filter with Rs dB of stop band attenuation.
+
+ [b, a] = cheby2(n, Rs, Wc)
+ low pass filter with cutoff pi*Wc radians
+
+ [b, a] = cheby2(n, Rs, Wc, 'high')
+ high pass filter with cutoff pi*Wc radians
+
+ [b, a] = cheby2(n, Rs, [Wl, Wh])
+ band pass filter with edges pi*Wl and pi*Wh radians
+
+ [b, a] = cheby2(n, Rs, [Wl, Wh], 'stop')
+ band reject filter with edges pi*Wl and pi*Wh radians
+
+ [z, p, g] = cheby2(...)
+ return filter as zero-pole-gain rather than coefficients of the
+ numerator and denominator polynomials.
+
+ [...] = cheby2(...,'s')
+ return a Laplace space filter, W can be larger than 1.
+
+ [a,b,c,d] = cheby2(...)
+ return state-space matrices
+
+ References:
+
+ Parks & Burrus (1987). Digital Filter Design. New York:
+ John Wiley & Sons, Inc.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 74
+ Generate an Chebyshev type II filter with Rs dB of stop band attenuation.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 5
+chirp
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 811
+ usage: y = chirp(t [, f0 [, t1 [, f1 [, form [, phase]]]]])
+
+ Evaluate a chirp signal at time t. A chirp signal is a frequency
+ swept cosine wave.
+
+ t: vector of times to evaluate the chirp signal
+ f0: frequency at time t=0 [ 0 Hz ]
+ t1: time t1 [ 1 sec ]
+ f1: frequency at time t=t1 [ 100 Hz ]
+ form: shape of frequency sweep
+ 'linear' f(t) = (f1-f0)*(t/t1) + f0
+ 'quadratic' f(t) = (f1-f0)*(t/t1)^2 + f0
+ 'logarithmic' f(t) = (f1-f0)^(t/t1) + f0
+ phase: phase shift at t=0
+
+ Example
+ specgram(chirp([0:0.001:5])); # linear, 0-100Hz in 1 sec
+ specgram(chirp([-2:0.001:15], 400, 10, 100, 'quadratic'));
+ soundsc(chirp([0:1/8000:5], 200, 2, 500, "logarithmic"),8000);
+
+ If you want a different sweep shape f(t), use the following:
+ y = cos(2*pi*integral(f(t)) + 2*pi*f0*t + phase);
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 61
+ usage: y = chirp(t [, f0 [, t1 [, f1 [, form [, phase]]]]])
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 8
+cmorwavf
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 96
+ -- Function File: [PSI,X] = cmorwavf (LB,UB,N,FB,FC)
+ Compute the Complex Morlet wavelet.
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 35
+Compute the Complex Morlet wavelet.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 6
+cohere
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 377
+ Usage:
+ [Pxx,freq] = cohere(x,y,Nfft,Fs,window,overlap,range,plot_type,detrend)
+
+ Estimate (mean square) coherence of signals "x" and "y".
+ Use the Welch (1967) periodogram/FFT method.
+ Compatible with Matlab R11 cohere and earlier.
+ See "help pwelch" for description of arguments, hints and references
+ --- especially hint (7) for Matlab R11 defaults.
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 80
+ Usage:
+ [Pxx,freq] = cohere(x,y,Nfft,Fs,window,overlap,range,plot_type,detren
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 7
+convmtx
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 498
+ -- Function File: convmtx (A, N)
+ If A is a column vector and X is a column vector of length N, then
+
+ `convmtx(A, N) * X'
+
+ gives the convolution of of A and X and is the same as `conv(A,
+ X)'. The difference is if many vectors are to be convolved with
+ the same vector, then this technique is possibly faster.
+
+ Similarly, if A is a row vector and X is a row vector of length N,
+ then
+
+ `X * convmtx(A, N)'
+
+ is the same as `conv(X, A)'.
+
+ See also: conv
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 67
+If A is a column vector and X is a column vector of length N, then
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 8
+cplxreal
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 710
+ -- Function File: [ZC, ZR] = cplxreal (Z, THRESH)
+ Split the vector z into its complex (ZC) and real (ZR) elements,
+ eliminating one of each complex-conjugate pair.
+
+ INPUTS:
+ * Z = row- or column-vector of complex numbers
+ * THRESH = tolerance threshold for numerical comparisons
+ (default = 100*eps)
+
+ RETURNED:
+ * ZC = elements of Z having positive imaginary parts
+ * ZR = elements of Z having zero imaginary part
+
+ Each complex element of Z is assumed to have a complex-conjugate
+ counterpart elsewhere in Z as well. Elements are declared real if
+ their imaginary parts have magnitude less than THRESH.
+
+ See also: cplxpair
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 80
+Split the vector z into its complex (ZC) and real (ZR) elements,
+eliminating one
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 4
+cpsd
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 260
+ Usage:
+ [Pxx,freq] = cpsd(x,y,Nfft,Fs,window,overlap,range,plot_type,detrend)
+
+ Estimate cross power spectrum of data "x" and "y" by the Welch (1967)
+ periodogram/FFT method.
+ See "help pwelch" for description of arguments, hints and references
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 80
+ Usage:
+ [Pxx,freq] = cpsd(x,y,Nfft,Fs,window,overlap,range,plot_type,detrend)
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 3
+csd
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 358
+ Usage:
+ [Pxx,freq] = csd(x,y,Nfft,Fs,window,overlap,range,plot_type,detrend)
+
+ Estimate cross power spectrum of data "x" and "y" by the Welch (1967)
+ periodogram/FFT method. Compatible with Matlab R11 csd and earlier.
+ See "help pwelch" for description of arguments, hints and references
+ --- especially hint (7) for Matlab R11 defaults.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 80
+ Usage:
+ [Pxx,freq] = csd(x,y,Nfft,Fs,window,overlap,range,plot_type,detrend)
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 3
+czt
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 828
+ usage y=czt(x, m, w, a)
+
+ Chirp z-transform. Compute the frequency response starting at a and
+ stepping by w for m steps. a is a point in the complex plane, and
+ w is the ratio between points in each step (i.e., radius increases
+ exponentially, and angle increases linearly).
+
+ To evaluate the frequency response for the range f1 to f2 in a signal
+ with sampling frequency Fs, use the following:
+ m = 32; ## number of points desired
+ w = exp(-j*2*pi*(f2-f1)/((m-1)*Fs)); ## freq. step of f2-f1/m
+ a = exp(j*2*pi*f1/Fs); ## starting at frequency f1
+ y = czt(x, m, w, a);
+
+ If you don't specify them, then the parameters default to a fourier
+ transform:
+ m=length(x), w=exp(-j*2*pi/m), a=1
+
+ If x is a matrix, the transform will be performed column-by-column.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 25
+ usage y=czt(x, m, w, a)
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 8
+data2fun
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 1111
+ -- Function File: [FHANDLE, FULLNAME] = data2fun (TI, YI)
+ -- Function File: [ ... ] = data2fun (TI, YI,PROPERTY,VALUE)
+ Creates a vectorized function based on data samples using
+ interpolation.
+
+ The values given in YI (N-by-k matrix) correspond to evaluations
+ of the function y(t) at the points TI (N-by-1 matrix). The data
+ is interpolated and the function handle to the generated
+ interpolant is returned.
+
+ The function accepts property-value pairs described below.
+
+ `file'
+ Code is generated and .m file is created. The VALUE contains
+ the name of the function. The returned function handle is a
+ handle to that file. If VALUE is empty, then a name is
+ automatically generated using `tmpnam' and the file is
+ created in the current directory. VALUE must not have an
+ extension, since .m will be appended. Numerical value used
+ in the function are stored in a .mat file with the same name
+ as the function.
+
+ `interp'
+ Type of interpolation. See `interp1'.
+
+
+ See also: interp1
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 72
+Creates a vectorized function based on data samples using interpolation.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 3
+dct
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 687
+ y = dct (x, n)
+ Computes the discrete cosine transform of x. If n is given, then
+ x is padded or trimmed to length n before computing the transform.
+ If x is a matrix, compute the transform along the columns of the
+ the matrix. The transform is faster if x is real-valued and even
+ length.
+
+ The discrete cosine transform X of x can be defined as follows:
+
+ N-1
+ X[k] = w(k) sum x[n] cos (pi (2n+1) k / 2N ), k = 0, ..., N-1
+ n=0
+
+ with w(0) = sqrt(1/N) and w(k) = sqrt(2/N), k = 1, ..., N-1. There
+ are other definitions with different scaling of X[k], but this form
+ is common in image processing.
+
+ See also: idct, dct2, idct2, dctmtx
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 64
+ y = dct (x, n)
+ Computes the discrete cosine transform of x.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 4
+dct2
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 202
+ y = dct2 (x)
+ Computes the 2-D discrete cosine transform of matrix x
+
+ y = dct2 (x, m, n) or y = dct2 (x, [m n])
+ Computes the 2-D DCT of x after padding or trimming rows to m and
+ columns to n.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 72
+ y = dct2 (x)
+ Computes the 2-D discrete cosine transform of matrix x
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 6
+dctmtx
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 599
+ T = dctmtx (n)
+ Return the DCT transformation matrix of size n x n.
+
+ If A is an n x n matrix, then the following are true:
+ T*A == dct(A), T'*A == idct(A)
+ T*A*T' == dct2(A), T'*A*T == idct2(A)
+
+ A dct transformation matrix is useful for doing things like jpeg
+ image compression, in which an 8x8 dct matrix is applied to
+ non-overlapping blocks throughout an image and only a subblock on the
+ top left of each block is kept. During restoration, the remainder of
+ the block is filled with zeros and the inverse transform is applied
+ to the block.
+
+ See also: dct, idct, dct2, idct2
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 68
+ T = dctmtx (n)
+ Return the DCT transformation matrix of size n x n.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 8
+decimate
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 1021
+ usage: y = decimate(x, q [, n] [, ftype])
+
+ Downsample the signal x by a factor of q, using an order n filter
+ of ftype 'fir' or 'iir'. By default, an order 8 Chebyshev type I
+ filter is used or a 30 point FIR filter if ftype is 'fir'. Note
+ that q must be an integer for this rate change method.
+
+ Example
+ ## Generate a signal that starts away from zero, is slowly varying
+ ## at the start and quickly varying at the end, decimate and plot.
+ ## Since it starts away from zero, you will see the boundary
+ ## effects of the antialiasing filter clearly. Next you will see
+ ## how it follows the curve nicely in the slowly varying early
+ ## part of the signal, but averages the curve in the quickly
+ ## varying late part of the signal.
+ t=0:0.01:2; x=chirp(t,2,.5,10,'quadratic')+sin(2*pi*t*0.4);
+ y = decimate(x,4); # factor of 4 decimation
+ stem(t(1:121)*1000,x(1:121),"-g;Original;"); hold on; # plot original
+ stem(t(1:4:121)*1000,y(1:31),"-r;Decimated;"); hold off; # decimated
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 43
+ usage: y = decimate(x, q [, n] [, ftype])
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 6
+dftmtx
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 343
+ -- Function File: D = dftmtx (N)
+ If N is a scalar, produces a N-by-N matrix D such that the Fourier
+ transform of a column vector of length N is given by `dftmtx(N) *
+ x' and the inverse Fourier transform is given by `inv(dftmtx(N)) *
+ x'. In general this is less efficient than calling the "fft" and
+ "ifft" directly.
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 80
+If N is a scalar, produces a N-by-N matrix D such that the Fourier
+transform of
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 5
+diric
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 116
+ -- Function File: [Y] = diric(X,N)
+ Compute the dirichlet function.
+
+ See also: sinc, gauspuls, sawtooth
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 31
+Compute the dirichlet function.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 10
+downsample
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 511
+ -- Function File: Y = downsample (X, N)
+ -- Function File: Y = downsample (X, N, OFFSET)
+ Downsample the signal, selecting every nth element. If X is a
+ matrix, downsample every column.
+
+ For most signals you will want to use `decimate' instead since it
+ prefilters the high frequency components of the signal and avoids
+ aliasing effects.
+
+ If OFFSET is defined, select every nth element starting at sample
+ OFFSET.
+
+ See also: decimate, interp, resample, upfirdn, upsample
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 51
+Downsample the signal, selecting every nth element.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 3
+dst
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 482
+ -- Function File: Y = dst (X)
+ -- Function File: Y = dst (X, N)
+ Computes the type I discrete sine transform of X. If N is given,
+ then X is padded or trimmed to length N before computing the
+ transform. If X is a matrix, compute the transform along the
+ columns of the the matrix.
+
+ The discrete sine transform X of x can be defined as follows:
+
+ N
+ X[k] = sum x[n] sin (pi n k / (N+1) ), k = 1, ..., N
+ n=1
+
+ See also: idst
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 49
+Computes the type I discrete sine transform of X.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 3
+dwt
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 111
+ -- Function File: [CA CD] = dwt(X,LO_D,HI_D)
+ Comupte de discrete wavelet transform of x with one level.
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 58
+Comupte de discrete wavelet transform of x with one level.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 5
+ellip
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 1050
+ N-ellip 0.2.1
+usage: [Zz, Zp, Zg] = ellip(n, Rp, Rs, Wp, stype,'s')
+
+ Generate an Elliptic or Cauer filter (discrete and contnuious).
+
+ [b,a] = ellip(n, Rp, Rs, Wp)
+ low pass filter with order n, cutoff pi*Wp radians, Rp decibels
+ of ripple in the passband and a stopband Rs decibels down.
+
+ [b,a] = ellip(n, Rp, Rs, Wp, 'high')
+ high pass filter with cutoff pi*Wp...
+
+ [b,a] = ellip(n, Rp, Rs, [Wl, Wh])
+ band pass filter with band pass edges pi*Wl and pi*Wh ...
+
+ [b,a] = ellip(n, Rp, Rs, [Wl, Wh], 'stop')
+ band reject filter with edges pi*Wl and pi*Wh, ...
+
+ [z,p,g] = ellip(...)
+ return filter as zero-pole-gain.
+
+ [...] = ellip(...,'s')
+ return a Laplace space filter, W can be larger than 1.
+
+ [a,b,c,d] = ellip(...)
+ return state-space matrices
+
+ References:
+
+ - Oppenheim, Alan V., Discrete Time Signal Processing, Hardcover, 1999.
+ - Parente Ribeiro, E., Notas de aula da disciplina TE498 - Processamento
+ Digital de Sinais, UFPR, 2001/2002.
+ - Kienzle, Paul, functions from Octave-Forge, 1999 (http://octave.sf.net).
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 11
+ N-ellip 0.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 8
+ellipord
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 346
+ usage: [n,wp] = ellipord(wp,ws, rp,rs)
+
+ Calculate the order for the elliptic filter (discrete)
+ wp: Cutoff frequency
+ ws: Stopband edge
+ rp: decibels of ripple in the passband.
+ rs: decibels of ripple in the stopband.
+
+ References:
+
+ - Lamar, Marcus Vinicius, Notas de aula da disciplina TE 456 - Circuitos
+ Analogicos II, UFPR, 2001/2002.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 40
+ usage: [n,wp] = ellipord(wp,ws, rp,rs)
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 3
+fht
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 788
+ -- Function File: m = fht ( d, n, dim )
+ The function fht calculates Fast Hartley Transform where D is
+ the real input vector (matrix), and M is the real-transform
+ vector. For matrices the hartley transform is calculated along the
+ columns by default. The options N,and DIM are similar to the
+ options of FFT function.
+
+ The forward and inverse hartley transforms are the same (except
+ for a scale factor of 1/N for the inverse hartley transform), but
+ implemented using different functions .
+
+ The definition of the forward hartley transform for vector d,
+
+ m[K] = \sum_i=0^N-1 d[i]*(cos[K*2*pi*i/N] + sin[K*2*pi*i/N]), for
+ 0 <= K < N. m[K] = \sum_i=0^N-1 d[i]*CAS[K*i], for 0 <= K < N.
+
+ fht(1:4)
+
+ See also: ifht, fft
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 80
+The function fht calculates Fast Hartley Transform where D is the
+real input v
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 8
+filtfilt
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 673
+ usage: y = filtfilt(b, a, x)
+
+ Forward and reverse filter the signal. This corrects for phase
+ distortion introduced by a one-pass filter, though it does square the
+ magnitude response in the process. That's the theory at least. In
+ practice the phase correction is not perfect, and magnitude response
+ is distorted, particularly in the stop band.
+
+ Example
+ [b, a]=butter(3, 0.1); % 10 Hz low-pass filter
+ t = 0:0.01:1.0; % 1 second sample
+ x=sin(2*pi*t*2.3)+0.25*randn(size(t)); % 2.3 Hz sinusoid+noise
+ y = filtfilt(b,a,x); z = filter(b,a,x); % apply filter
+ plot(t,x,';data;',t,y,';filtfilt;',t,z,';filter;')
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 30
+ usage: y = filtfilt(b, a, x)
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 6
+filtic
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 718
+ Set initial condition vector for filter function
+ The vector zf has the same values that would be obtained
+ from function filter given past inputs x and outputs y
+
+ The vectors x and y contain the most recent inputs and outputs
+ respectively, with the newest values first:
+
+ x = [x(-1) x(-2) ... x(-nb)], nb = length(b)-1
+ y = [y(-1) y(-2) ... y(-na)], na = length(a)-a
+
+ If length(x)<nb then it is zero padded
+ If length(y)<na then it is zero padded
+
+ zf = filtic(b, a, y)
+ Initial conditions for filter with coefficients a and b
+ and output vector y, assuming input vector x is zero
+
+ zf = filtic(b, a, y, x)
+ Initial conditions for filter with coefficients a and b
+ input vector x and output vector y
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 80
+ Set initial condition vector for filter function
+ The vector zf has the same va
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 4
+fir1
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 1180
+ usage: b = fir1(n, w [, type] [, window] [, noscale])
+
+ Produce an order n FIR filter with the given frequency cutoff,
+ returning the n+1 filter coefficients in b.
+
+ n: order of the filter (1 less than the length of the filter)
+ w: band edges
+ strictly increasing vector in range [0, 1]
+ singleton for highpass or lowpass, vector pair for bandpass or
+ bandstop, or vector for alternating pass/stop filter.
+ type: choose between pass and stop bands
+ 'high' for highpass filter, cutoff at w
+ 'stop' for bandstop filter, edges at w = [lo, hi]
+ 'DC-0' for bandstop as first band of multiband filter
+ 'DC-1' for bandpass as first band of multiband filter
+ window: smoothing window
+ defaults to hamming(n+1) row vector
+ returned filter is the same shape as the smoothing window
+ noscale: choose whether to normalize or not
+ 'scale': set the magnitude of the center of the first passband to 1
+ 'noscale': don't normalize
+
+ To apply the filter, use the return vector b:
+ y=filter(b,1,x);
+
+ Examples:
+ freqz(fir1(40,0.3));
+ freqz(fir1(15,[0.2, 0.5], 'stop')); # note the zero-crossing at 0.1
+ freqz(fir1(15,[0.2, 0.5], 'stop', 'noscale'));
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 55
+ usage: b = fir1(n, w [, type] [, window] [, noscale])
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 4
+fir2
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 1197
+ usage: b = fir2(n, f, m [, grid_n [, ramp_n]] [, window])
+
+ Produce an FIR filter of order n with arbitrary frequency response,
+ returning the n+1 filter coefficients in b.
+
+ n: order of the filter (1 less than the length of the filter)
+ f: frequency at band edges
+ f is a vector of nondecreasing elements in [0,1]
+ the first element must be 0 and the last element must be 1
+ if elements are identical, it indicates a jump in freq. response
+ m: magnitude at band edges
+ m is a vector of length(f)
+ grid_n: length of ideal frequency response function
+ defaults to 512, should be a power of 2 bigger than n
+ ramp_n: transition width for jumps in filter response
+ defaults to grid_n/20; a wider ramp gives wider transitions
+ but has better stopband characteristics.
+ window: smoothing window
+ defaults to hamming(n+1) row vector
+ returned filter is the same shape as the smoothing window
+
+ To apply the filter, use the return vector b:
+ y=filter(b,1,x);
+ Note that plot(f,m) shows target response.
+
+ Example:
+ f=[0, 0.3, 0.3, 0.6, 0.6, 1]; m=[0, 0, 1, 1/2, 0, 0];
+ [h, w] = freqz(fir2(100,f,m));
+ plot(f,m,';target response;',w/pi,abs(h),';filter response;');
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 59
+ usage: b = fir2(n, f, m [, grid_n [, ramp_n]] [, window])
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 5
+firls
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 908
+ b = firls(N, F, A);
+ b = firls(N, F, A, W);
+
+ FIR filter design using least squares method. Returns a length N+1
+ linear phase filter such that the integral of the weighted mean
+ squared error in the specified bands is minimized.
+
+ F specifies the frequencies of the band edges, normalized so that
+ half the sample frequency is equal to 1. Each band is specified by
+ two frequencies, to the vector must have an even length.
+
+ A specifies the amplitude of the desired response at each band edge.
+
+ W is an optional weighting function that contains one value for each
+ band that weights the mean squared error in that band. A must be the
+ same length as F, and W must be half the length of F.
+
+ The least squares optimization algorithm for computing FIR filter
+ coefficients is derived in detail in:
+
+ I. Selesnick, "Linear-Phase FIR Filter Design by Least Squares,"
+ http://cnx.org/content/m10577
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 45
+ b = firls(N, F, A);
+ b = firls(N, F, A, W);
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 10
+flattopwin
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 679
+ flattopwin(L, [periodic|symmetric])
+
+ Return the window f(w):
+
+ f(w) = 1 - 1.93 cos(2 pi w) + 1.29 cos(4 pi w)
+ - 0.388 cos(6 pi w) + 0.0322cos(8 pi w)
+
+ where w = i/(L-1) for i=0:L-1 for a symmetric window, or
+ w = i/L for i=0:L-1 for a periodic window. The default
+ is symmetric. The returned window is normalized to a peak
+ of 1 at w = 0.5.
+
+ This window has low pass-band ripple, but high bandwidth.
+
+ According to [1]:
+
+ The main use for the Flat Top window is for calibration, due
+ to its negligible amplitude errors.
+
+ [1] Gade, S; Herlufsen, H; (1987) "Use of weighting functions in DFT/FFT
+ analysis (Part I)", Bruel & Kjaer Technical Review No.3.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 37
+ flattopwin(L, [periodic|symmetric])
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 9
+fracshift
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 279
+ -- Function File: [Y H]= fracshift(X,D)
+ -- Function File: Y = fracshift(X,D,H)
+ Shift the series X by a (possibly fractional) number of samples D.
+ The interpolator H is either specified or either designed with a
+ Kaiser-windowed sinecard.
+
+ See also: circshift
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 66
+Shift the series X by a (possibly fractional) number of samples D.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 5
+freqs
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 300
+ Usage: H = freqs(B,A,W);
+
+ Compute the s-plane frequency response of the IIR filter B(s)/A(s) as
+ H = polyval(B,j*W)./polyval(A,j*W). If called with no output
+ argument, a plot of magnitude and phase are displayed.
+
+ Example:
+ B = [1 2]; A = [1 1];
+ w = linspace(0,4,128);
+ freqs(B,A,w);
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 26
+ Usage: H = freqs(B,A,W);
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 10
+freqs_plot
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 90
+ -- Function File: freqs_plot (W, H)
+ Plot the amplitude and phase of the vector H.
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 45
+Plot the amplitude and phase of the vector H.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 4
+fwhm
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 1318
+ Compute peak full-width at half maximum (FWHM) or at another level of peak
+ maximum for vector or matrix data y, optionally sampled as y(x). If y is
+ a matrix, return FWHM for each column as a row vector.
+ Syntax:
+ f = fwhm({x, } y {, 'zero'|'min' {, 'rlevel', rlevel}})
+ f = fwhm({x, } y {, 'alevel', alevel})
+ Examples:
+ f = fwhm(y)
+ f = fwhm(x, y)
+ f = fwhm(x, y, 'zero')
+ f = fwhm(x, y, 'min')
+ f = fwhm(x, y, 'alevel', 15.3)
+ f = fwhm(x, y, 'zero', 'rlevel', 0.5)
+ f = fwhm(x, y, 'min', 'rlevel', 0.1)
+
+ The default option 'zero' computes fwhm at half maximum, i.e. 0.5*max(y).
+ The option 'min' computes fwhm at the middle curve, i.e. 0.5*(min(y)+max(y)).
+
+ The option 'rlevel' computes full-width at the given relative level of peak
+ profile, i.e. at rlevel*max(y) or rlevel*(min(y)+max(y)), respectively.
+ For example, fwhm(..., 'rlevel', 0.1) computes full width at 10 % of peak
+ maximum with respect to zero or minimum; FWHM is equivalent to
+ fwhm(..., 'rlevel', 0.5).
+
+ The option 'alevel' computes full-width at the given absolute level of y.
+
+ Return 0 if FWHM does not exist (e.g. monotonous function or the function
+ does not cut horizontal line at rlevel*max(y) or rlevel*(max(y)+min(y)) or
+ alevel, respectively).
+
+ Compatibility: Octave 3.x, Matlab
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 80
+ Compute peak full-width at half maximum (FWHM) or at another level of peak
+ max
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 8
+gauspuls
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 97
+ -- Function File: [Y] = gauspuls(T,FC,BW)
+ Return the Gaussian modulated sinusoidal pulse.
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 47
+Return the Gaussian modulated sinusoidal pulse.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 8
+gaussian
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 442
+ usage: w = gaussian(n, a)
+
+ Generate an n-point gaussian convolution window of the given
+ width. Use larger a for a narrower window. Use larger n for
+ longer tails.
+
+ w = exp ( -(a*x)^2/2 )
+
+ for x = linspace ( -(n-1)/2, (n-1)/2, n ).
+
+ Width a is measured in frequency units (sample rate/num samples).
+ It should be f when multiplying in the time domain, but 1/f when
+ multiplying in the frequency domain (for use in convolutions).
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 27
+ usage: w = gaussian(n, a)
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 8
+gausswin
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 227
+ usage: w = gausswin(L, a)
+
+ Generate an L-point gaussian window of the given width. Use larger a
+ for a narrow window. Use larger L for a smoother curve.
+
+ w = exp ( -(a*x)^2/2 )
+
+ for x = linspace(-(L-1)/L, (L-1)/L, L)
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 27
+ usage: w = gausswin(L, a)
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 9
+gmonopuls
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 78
+ -- Function File: [Y] = gmonopuls(T,FC)
+ Return the gaussian monopulse.
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 30
+Return the gaussian monopulse.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 8
+grpdelay
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 2463
+ Compute the group delay of a filter.
+
+ [g, w] = grpdelay(b)
+ returns the group delay g of the FIR filter with coefficients b.
+ The response is evaluated at 512 angular frequencies between 0 and
+ pi. w is a vector containing the 512 frequencies.
+ The group delay is in units of samples. It can be converted
+ to seconds by multiplying by the sampling period (or dividing by
+ the sampling rate fs).
+
+ [g, w] = grpdelay(b,a)
+ returns the group delay of the rational IIR filter whose numerator
+ has coefficients b and denominator coefficients a.
+
+ [g, w] = grpdelay(b,a,n)
+ returns the group delay evaluated at n angular frequencies. For fastest
+ computation n should factor into a small number of small primes.
+
+ [g, w] = grpdelay(b,a,n,'whole')
+ evaluates the group delay at n frequencies between 0 and 2*pi.
+
+ [g, f] = grpdelay(b,a,n,Fs)
+ evaluates the group delay at n frequencies between 0 and Fs/2.
+
+ [g, f] = grpdelay(b,a,n,'whole',Fs)
+ evaluates the group delay at n frequencies between 0 and Fs.
+
+ [g, w] = grpdelay(b,a,w)
+ evaluates the group delay at frequencies w (radians per sample).
+
+ [g, f] = grpdelay(b,a,f,Fs)
+ evaluates the group delay at frequencies f (in Hz).
+
+ grpdelay(...)
+ plots the group delay vs. frequency.
+
+ If the denominator of the computation becomes too small, the group delay
+ is set to zero. (The group delay approaches infinity when
+ there are poles or zeros very close to the unit circle in the z plane.)
+
+ Theory: group delay, g(w) = -d/dw [arg{H(e^jw)}], is the rate of change of
+ phase with respect to frequency. It can be computed as:
+
+ d/dw H(e^-jw)
+ g(w) = -------------
+ H(e^-jw)
+
+ where
+ H(z) = B(z)/A(z) = sum(b_k z^k)/sum(a_k z^k).
+
+ By the quotient rule,
+ A(z) d/dw B(z) - B(z) d/dw A(z)
+ d/dw H(z) = -------------------------------
+ A(z) A(z)
+ Substituting into the expression above yields:
+ A dB - B dA
+ g(w) = ----------- = dB/B - dA/A
+ A B
+
+ Note that,
+ d/dw B(e^-jw) = sum(k b_k e^-jwk)
+ d/dw A(e^-jw) = sum(k a_k e^-jwk)
+ which is just the FFT of the coefficients multiplied by a ramp.
+
+ As a further optimization when nfft>>length(a), the IIR filter (b,a)
+ is converted to the FIR filter conv(b,fliplr(conj(a))).
+ For further details, see
+ http://ccrma.stanford.edu/~jos/filters/Numerical_Computation_Group_Delay.html
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 37
+ Compute the group delay of a filter.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 4
+hann
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 28
+ w = hann(n)
+ see hanning
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 28
+ w = hann(n)
+ see hanning
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 7
+hilbert
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 647
+ -- Function File: H = hilbert (F,N,DIM)
+ Analytic extension of real valued signal
+
+ `H=hilbert(F)' computes the extension of the real valued signal F
+ to an analytic signal. If F is a matrix, the transformation is
+ applied to each column. For N-D arrays, the transformation is
+ applied to the first non-singleton dimension.
+
+ `real(H)' contains the original signal F. `imag(H)' contains the
+ Hilbert transform of F.
+
+ `hilbert(F,N)' does the same using a length N Hilbert transform.
+ The result will also have length N.
+
+ `hilbert(F,[],DIM)' or `hilbert(F,N,DIM)' does the same along
+ dimension dim.
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 41
+Analytic extension of real valued signal
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 4
+idct
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 584
+ y = dct (x, n)
+ Computes the inverse discrete cosine transform of x. If n is
+ given, then x is padded or trimmed to length n before computing
+ the transform. If x is a matrix, compute the transform along the
+ columns of the the matrix. The transform is faster if x is
+ real-valued and even length.
+
+ The inverse discrete cosine transform x of X can be defined as follows:
+
+ N-1
+ x[n] = sum w(k) X[k] cos (pi (2n+1) k / 2N ), n = 0, ..., N-1
+ k=0
+
+ with w(0) = sqrt(1/N) and w(k) = sqrt(2/N), k = 1, ..., N-1
+
+ See also: idct, dct2, idct2, dctmtx
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 72
+ y = dct (x, n)
+ Computes the inverse discrete cosine transform of x.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 5
+idct2
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 221
+ y = idct2 (x)
+ Computes the inverse 2-D discrete cosine transform of matrix x
+
+ y = idct2 (x, m, n) or y = idct2 (x, [m n])
+ Computes the 2-D inverse DCT of x after padding or trimming rows to m and
+ columns to n.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 80
+ y = idct2 (x)
+ Computes the inverse 2-D discrete cosine transform of matrix x
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 4
+idst
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 333
+ -- Function File: Y = idst (X)
+ -- Function File: Y = idst (X, N)
+ Computes the inverse type I discrete sine transform of Y. If N is
+ given, then Y is padded or trimmed to length N before computing
+ the transform. If Y is a matrix, compute the transform along the
+ columns of the the matrix.
+
+ See also: dst
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 57
+Computes the inverse type I discrete sine transform of Y.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 4
+ifht
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 805
+ -- Function File: m = ifht ( d, n, dim )
+ The function ifht calculates Fast Hartley Transform where D is
+ the real input vector (matrix), and M is the real-transform
+ vector. For matrices the hartley transform is calculated along the
+ columns by default. The options N, and DIM are similar to the
+ options of FFT function.
+
+ The forward and inverse hartley transforms are the same (except
+ for a scale factor of 1/N for the inverse hartley transform), but
+ implemented using different functions .
+
+ The definition of the forward hartley transform for vector d,
+
+ m[K] = 1/N \sum_i=0^N-1 d[i]*(cos[K*2*pi*i/N] + sin[K*2*pi*i/N]),
+ for 0 <= K < N. m[K] = 1/N \sum_i=0^N-1 d[i]*CAS[K*i], for 0 <=
+ K < N.
+
+ ifht(1:4)
+
+ See also: fht, fft
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 80
+The function ifht calculates Fast Hartley Transform where D is the
+real input
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 8
+iirlp2mb
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 1305
+ IIR Low Pass Filter to Multiband Filter Transformation
+
+ [Num,Den,AllpassNum,AllpassDen] = iirlp2mb(B,A,Wo,Wt)
+ [Num,Den,AllpassNum,AllpassDen] = iirlp2mb(B,A,Wo,Wt,Pass)
+
+ Num,Den: numerator,denominator of the transformed filter
+ AllpassNum,AllpassDen: numerator,denominator of allpass transform,
+ B,A: numerator,denominator of prototype low pass filter
+ Wo: normalized_angular_frequency/pi to be transformed
+ Wt: [phi=normalized_angular_frequencies]/pi target vector
+ Pass: This parameter may have values 'pass' or 'stop'. If
+ not given, it defaults to the value of 'pass'.
+
+ With normalized ang. freq. targets 0 < phi(1) < ... < phi(n) < pi radians
+
+ for Pass == 'pass', the target multiband magnitude will be:
+ -------- ---------- -----------...
+ / \ / \ / .
+ 0 phi(1) phi(2) phi(3) phi(4) phi(5) (phi(6)) pi
+
+ for Pass == 'stop', the target multiband magnitude will be:
+ ------- --------- ----------...
+ \ / \ / .
+ 0 phi(1) phi(2) phi(3) phi(4) (phi(5)) pi
+
+ Example of use:
+ [B, A] = butter(6, 0.5);
+ [Num, Den] = iirlp2mb(B, A, 0.5, [.2 .4 .6 .8]);
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 56
+ IIR Low Pass Filter to Multiband Filter Transformation
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 8
+impinvar
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 877
+ -- Function File: [B_OUT, A_OUT] = impinvar (B, A, FS, TOL)
+ -- Function File: [B_OUT, A_OUT] = impinvar (B, A, FS)
+ -- Function File: [B_OUT, A_OUT] = impinvar (B, A)
+ Converts analog filter with coefficients B and A to digital,
+ conserving impulse response.
+
+ If FS is not specificied, or is an empty vector, it defaults to
+ 1Hz.
+
+ If TOL is not specified, it defaults to 0.0001 (0.1%) This
+ function does the inverse of impinvar so that the following
+ example should restore the original values of A and B.
+
+ `invimpinvar' implements the reverse of this function.
+ [b, a] = impinvar (b, a);
+ [b, a] = invimpinvar (b, a);
+
+ Reference: Thomas J. Cavicchi (1996) "Impulse invariance and
+ multiple-order poles". IEEE transactions on signal processing, Vol
+ 40 (9): 2344-2347
+
+ See also: bilinear, invimpinvar
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 80
+Converts analog filter with coefficients B and A to digital, conserving
+impulse
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 4
+impz
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 545
+ usage: [x, t] = impz(b [, a, n, fs])
+
+ Generate impulse-response characteristics of the filter. The filter
+ coefficients correspond to the the z-plane rational function with
+ numerator b and denominator a. If a is not specified, it defaults to
+ 1. If n is not specified, or specified as [], it will be chosen such
+ that the signal has a chance to die down to -120dB, or to not explode
+ beyond 120dB, or to show five periods if there is no significant
+ damping. If no return arguments are requested, plot the results.
+
+ See also: freqz, zplane
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 38
+ usage: [x, t] = impz(b [, a, n, fs])
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 6
+interp
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 631
+ usage: y = interp(x, q [, n [, Wc]])
+
+ Upsample the signal x by a factor of q, using an order 2*q*n+1 FIR
+ filter. Note that q must be an integer for this rate change method.
+ n defaults to 4 and Wc defaults to 0.5.
+
+ Example
+ # Generate a signal.
+ t=0:0.01:2; x=chirp(t,2,.5,10,'quadratic')+sin(2*pi*t*0.4);
+ y = interp(x(1:4:length(x)),4,4,1); # interpolate a sub-sample
+ stem(t(1:121)*1000,x(1:121),"-g;Original;"); hold on;
+ stem(t(1:121)*1000,y(1:121),"-r;Interpolated;");
+ stem(t(1:4:121)*1000,x(1:4:121),"-b;Subsampled;"); hold off;
+
+ See also: decimate, resample
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 38
+ usage: y = interp(x, q [, n [, Wc]])
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 7
+invfreq
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 1687
+ usage: [B,A] = invfreq(H,F,nB,nA)
+ [B,A] = invfreq(H,F,nB,nA,W)
+ [B,A] = invfreq(H,F,nB,nA,W,[],[],plane)
+ [B,A] = invfreq(H,F,nB,nA,W,iter,tol,plane)
+
+ Fit filter B(z)/A(z) or B(s)/A(s) to complex frequency response at
+ frequency points F. A and B are real polynomial coefficients of order
+ nA and nB respectively. Optionally, the fit-errors can be weighted vs
+ frequency according to the weights W. Also, the transform plane can be
+ specified as either 's' for continuous time or 'z' for discrete time. 'z'
+ is chosen by default. Eventually, Steiglitz-McBride iterations will be
+ specified by iter and tol.
+
+ H: desired complex frequency response
+ It is assumed that A and B are real polynomials, hence H is one-sided.
+ F: vector of frequency samples in radians
+ nA: order of denominator polynomial A
+ nB: order of numerator polynomial B
+ plane='z': F on unit circle (discrete-time spectra, z-plane design)
+ plane='s': F on jw axis (continuous-time spectra, s-plane design)
+ H(k) = spectral samples of filter frequency response at points zk,
+ where zk=exp(sqrt(-1)*F(k)) when plane='z' (F(k) in [0,.5])
+ and zk=(sqrt(-1)*F(k)) when plane='s' (F(k) nonnegative)
+ Example:
+ [B,A] = butter(12,1/4);
+ [H,w] = freqz(B,A,128);
+ [Bh,Ah] = invfreq(H,F,4,4);
+ Hh = freqz(Bh,Ah);
+ disp(sprintf('||frequency response error|| = %f',norm(H-Hh)));
+
+ References: J. O. Smith, "Techniques for Digital Filter Design and System
+ Identification with Application to the Violin, Ph.D. Dissertation,
+ Elec. Eng. Dept., Stanford University, June 1983, page 50; or,
+
+ http://ccrma.stanford.edu/~jos/filters/FFT_Based_Equation_Error_Method.html
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 80
+ usage: [B,A] = invfreq(H,F,nB,nA)
+ [B,A] = invfreq(H,F,nB,nA,W)
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 8
+invfreqs
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 943
+ Usage: [B,A] = invfreqs(H,F,nB,nA)
+ [B,A] = invfreqs(H,F,nB,nA,W)
+ [B,A] = invfreqs(H,F,nB,nA,W,iter,tol,'trace')
+
+ Fit filter B(s)/A(s)to the complex frequency response H at frequency
+ points F. A and B are real polynomial coefficients of order nA and nB.
+ Optionally, the fit-errors can be weighted vs frequency according to
+ the weights W.
+ Note: all the guts are in invfreq.m
+
+ H: desired complex frequency response
+ F: frequency (must be same length as H)
+ nA: order of the denominator polynomial A
+ nB: order of the numerator polynomial B
+ W: vector of weights (must be same length as F)
+
+ Example:
+ B = [1/2 1];
+ A = [1 1];
+ w = linspace(0,4,128);
+ H = freqs(B,A,w);
+ [Bh,Ah] = invfreqs(H,w,1,1);
+ Hh = freqs(Bh,Ah,w);
+ plot(w,[abs(H);abs(Hh)])
+ legend('Original','Measured');
+ err = norm(H-Hh);
+ disp(sprintf('L2 norm of frequency response error = %f',err));
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 80
+ Usage: [B,A] = invfreqs(H,F,nB,nA)
+ [B,A] = invfreqs(H,F,nB,nA,W)
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 8
+invfreqz
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 819
+ usage: [B,A] = invfreqz(H,F,nB,nA)
+ [B,A] = invfreqz(H,F,nB,nA,W)
+ [B,A] = invfreqz(H,F,nB,nA,W,iter,tol,'trace')
+
+ Fit filter B(z)/A(z)to the complex frequency response H at frequency
+ points F. A and B are real polynomial coefficients of order nA and nB.
+ Optionally, the fit-errors can be weighted vs frequency according to
+ the weights W.
+ Note: all the guts are in invfreq.m
+
+ H: desired complex frequency response
+ F: normalized frequncy (0 to pi) (must be same length as H)
+ nA: order of the denominator polynomial A
+ nB: order of the numerator polynomial B
+ W: vector of weights (must be same length as F)
+
+ Example:
+ [B,A] = butter(4,1/4);
+ [H,F] = freqz(B,A);
+ [Bh,Ah] = invfreq(H,F,4,4);
+ Hh = freqz(Bh,Ah);
+ disp(sprintf('||frequency response error|| = %f',norm(H-Hh)));
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 80
+ usage: [B,A] = invfreqz(H,F,nB,nA)
+ [B,A] = invfreqz(H,F,nB,nA,W)
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 11
+invimpinvar
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 823
+ -- Function File: [B_OUT, A_OUT] = invimpinvar (B, A, FS, TOL)
+ -- Function File: [B_OUT, A_OUT] = invimpinvar (B, A, FS)
+ -- Function File: [B_OUT, A_OUT] = invimpinvar (B, A)
+ Converts digital filter with coefficients B and A to analog,
+ conserving impulse response.
+
+ This function does the inverse of impinvar so that the following
+ example should restore the original values of A and B.
+ [b, a] = impinvar (b, a);
+ [b, a] = invimpinvar (b, a);
+
+ If FS is not specificied, or is an empty vector, it defaults to
+ 1Hz.
+
+ If TOL is not specified, it defaults to 0.0001 (0.1%)
+
+ Reference: Thomas J. Cavicchi (1996) "Impulse invariance and
+ multiple-order poles". IEEE transactions on signal processing, Vol
+ 40 (9): 2344-2347
+
+ See also: bilinear, impinvar
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 80
+Converts digital filter with coefficients B and A to analog, conserving
+impulse
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 6
+kaiser
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 454
+ usage: kaiser (L, beta)
+
+ Returns the filter coefficients of the L-point Kaiser window with
+ parameter beta.
+
+ For the definition of the Kaiser window, see A. V. Oppenheim &
+ R. W. Schafer, "Discrete-Time Signal Processing".
+
+ The continuous version of width L centered about x=0 is:
+
+ besseli(0, beta * sqrt(1-(2*x/L).^2))
+ k(x) = -------------------------------------, L/2 <= x <= L/2
+ besseli(0, beta)
+
+ See also: kaiserord
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 26
+ usage: kaiser (L, beta)
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 9
+kaiserord
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 1809
+ usage: [n, Wn, beta, ftype] = kaiserord(f, m, dev [, fs])
+
+ Returns the parameters needed for fir1 to produce a filter of the
+ desired specification from a kaiser window:
+ n: order of the filter (length of filter minus 1)
+ Wn: band edges for use in fir1
+ beta: parameter for kaiser window of length n+1
+ ftype: choose between pass and stop bands
+ b = fir1(n,Wn,kaiser(n+1,beta),ftype,'noscale');
+
+ f: frequency bands, given as pairs, with the first half of the
+ first pair assumed to start at 0 and the last half of the last
+ pair assumed to end at 1. It is important to separate the
+ band edges, since narrow transition regions require large order
+ filters.
+ m: magnitude within each band. Should be non-zero for pass band
+ and zero for stop band. All passbands must have the same
+ magnitude, or you will get the error that pass and stop bands
+ must be strictly alternating.
+ dev: deviation within each band. Since all bands in the resulting
+ filter have the same deviation, only the minimum deviation is
+ used. In this version, a single scalar will work just as well.
+ fs: sampling rate. Used to convert the frequency specification into
+ the [0, 1], where 1 corresponds to the Nyquist frequency, fs/2.
+
+ The Kaiser window parameters n and beta are computed from the
+ relation between ripple (A=-20*log10(dev)) and transition width
+ (dw in radians) discovered empirically by Kaiser:
+
+ / 0.1102(A-8.7) A > 50
+ beta = | 0.5842(A-21)^0.4 + 0.07886(A-21) 21 <= A <= 50
+ \ 0.0 A < 21
+
+ n = (A-8)/(2.285 dw)
+
+ Example
+ [n, w, beta, ftype] = kaiserord([1000,1200], [1,0], [0.05,0.05], 11025);
+ freqz(fir1(n,w,kaiser(n+1,beta),ftype,'noscale'),1,[],11025);
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 59
+ usage: [n, Wn, beta, ftype] = kaiserord(f, m, dev [, fs])
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 8
+levinson
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 818
+ usage: [a, v, ref] = levinson (acf [, p])
+
+ Use the Durbin-Levinson algorithm to solve:
+ toeplitz(acf(1:p)) * x = -acf(2:p+1).
+ The solution [1, x'] is the denominator of an all pole filter
+ approximation to the signal x which generated the autocorrelation
+ function acf.
+
+ acf is the autocorrelation function for lags 0 to p.
+ p defaults to length(acf)-1.
+ Returns
+ a=[1, x'] the denominator filter coefficients.
+ v= variance of the white noise = square of the numerator constant
+ ref = reflection coefficients = coefficients of the lattice
+ implementation of the filter
+ Use freqz(sqrt(v),a) to plot the power spectrum.
+
+ REFERENCE
+ [1] Steven M. Kay and Stanley Lawrence Marple Jr.:
+ "Spectrum analysis -- a modern perspective",
+ Proceedings of the IEEE, Vol 69, pp 1380-1419, Nov., 1981
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 44
+ usage: [a, v, ref] = levinson (acf [, p])
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 7
+marcumq
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 963
+ -- Function File: Q = marcumq (A, B)
+ -- Function File: Q = marcumq (A, B, M)
+ -- Function File: Q = marcumq (A, B, M, TOL)
+ Compute the generalized Marcum Q function of order M with
+ noncentrality parameter A and argument B. If the order M is
+ omitted it defaults to 1. An optional relative tolerance TOL may
+ be included, the default is `eps'.
+
+ If the input arguments are commensurate vectors, this function
+ will produce a table of values.
+
+ This function computes Marcum's Q function using the infinite
+ Bessel series, truncated when the relative error is less than the
+ specified tolerance. The accuracy is limited by that of the
+ Bessel functions, so reducing the tolerance is probably not useful.
+
+ Reference: Marcum, "Tables of Q Functions", Rand Corporation.
+
+ Reference: R.T. Short, "Computation of Noncentral Chi-squared and
+ Rice Random Variables", www.phaselockedsystems.com/publications
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 80
+Compute the generalized Marcum Q function of order M with noncentrality
+paramete
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 7
+mexihat
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 85
+ -- Function File: [PSI,X] = mexihat(LB,UB,N)
+ Compute the Mexican hat wavelet.
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 32
+Compute the Mexican hat wavelet.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 8
+meyeraux
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 89
+ -- Function File: [Y] = meyeraux(X)
+ Compute the Meyer wavelet auxiliary function.
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 45
+Compute the Meyer wavelet auxiliary function.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 6
+morlet
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 79
+ -- Function File: [PSI,X] = morlet(LB,UB,N)
+ Compute the Morlet wavelet.
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 27
+Compute the Morlet wavelet.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 8
+mscohere
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 270
+ Usage:
+ [Pxx,freq]=mscohere(x,y,Nfft,Fs,window,overlap,range,plot_type,detrend)
+
+ Estimate (mean square) coherence of signals "x" and "y".
+ Use the Welch (1967) periodogram/FFT method.
+ See "help pwelch" for description of arguments, hints and references
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 80
+ Usage:
+ [Pxx,freq]=mscohere(x,y,Nfft,Fs,window,overlap,range,plot_type,detren
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 6
+ncauer
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 383
+ usage: [Zz, Zp, Zg] = ncauer(Rp, Rs, n)
+
+ Analog prototype for Cauer filter.
+ [z, p, g]=ncauer(Rp, Rs, ws)
+ Rp = Passband ripple
+ Rs = Stopband ripple
+ Ws = Desired order
+
+ References:
+
+ - Serra, Celso Penteado, Teoria e Projeto de Filtros, Campinas: CARTGRAF,
+ 1983.
+ - Lamar, Marcus Vinicius, Notas de aula da disciplina TE 456 - Circuitos
+ Analogicos II, UFPR, 2001/2002.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 41
+ usage: [Zz, Zp, Zg] = ncauer(Rp, Rs, n)
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 10
+nuttallwin
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 154
+ -- Function File: [W] = nuttallwin(L)
+ Compute the Blackman-Harris window defined by Nuttall of length L.
+
+ See also: blackman, blackmanharris
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 66
+Compute the Blackman-Harris window defined by Nuttall of length L.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 9
+parzenwin
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 118
+ -- Function File: [W] = parzenwin(L)
+ Compute the Parzen window of lenght L.
+
+ See also: rectwin, bartlett
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 38
+Compute the Parzen window of lenght L.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 5
+pburg
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 3783
+ usage:
+ [psd,f_out] = pburg(x,poles,freq,Fs,range,method,plot_type,criterion)
+
+ Calculate Burg maximum-entropy power spectral density.
+ The functions "arburg" and "ar_psd" do all the work.
+ See "help arburg" and "help ar_psd" for further details.
+
+ ARGUMENTS:
+ All but the first two arguments are optional and may be empty.
+ x %% [vector] sampled data
+
+ poles %% [integer scalar] required number of poles of the AR model
+
+ freq %% [real vector] frequencies at which power spectral density
+ %% is calculated
+ %% [integer scalar] number of uniformly distributed frequency
+ %% values at which spectral density is calculated.
+ %% [default=256]
+
+ Fs %% [real scalar] sampling frequency (Hertz) [default=1]
+
+
+ CONTROL-STRING ARGUMENTS -- each of these arguments is a character string.
+ Control-string arguments can be in any order after the other arguments.
+
+
+ range %% 'half', 'onesided' : frequency range of the spectrum is
+ %% from zero up to but not including sample_f/2. Power
+ %% from negative frequencies is added to the positive
+ %% side of the spectrum.
+ %% 'whole', 'twosided' : frequency range of the spectrum is
+ %% -sample_f/2 to sample_f/2, with negative frequencies
+ %% stored in "wrap around" order after the positive
+ %% frequencies; e.g. frequencies for a 10-point 'twosided'
+ %% spectrum are 0 0.1 0.2 0.3 0.4 0.5 -0.4 -0.3 -0.2 -0.1
+ %% 'shift', 'centerdc' : same as 'whole' but with the first half
+ %% of the spectrum swapped with second half to put the
+ %% zero-frequency value in the middle. (See "help
+ %% fftshift". If "freq" is vector, 'shift' is ignored.
+ %% If model coefficients "ar_coeffs" are real, the default
+ %% range is 'half', otherwise default range is 'whole'.
+
+ method %% 'fft': use FFT to calculate power spectral density.
+ %% 'poly': calculate spectral density as a polynomial of 1/z
+ %% N.B. this argument is ignored if the "freq" argument is a
+ %% vector. The default is 'poly' unless the "freq"
+ %% argument is an integer power of 2.
+
+ plot_type %% 'plot', 'semilogx', 'semilogy', 'loglog', 'squared' or 'db':
+ %% specifies the type of plot. The default is 'plot', which
+ %% means linear-linear axes. 'squared' is the same as 'plot'.
+ %% 'dB' plots "10*log10(psd)". This argument is ignored and a
+ %% spectrum is not plotted if the caller requires a returned
+ %% value.
+
+ criterion %% [optional string arg] model-selection criterion. Limits
+ %% the number of poles so that spurious poles are not
+ %% added when the whitened data has no more information
+ %% in it (see Kay & Marple, 1981). Recognised values are
+ %% 'AKICc' -- approximate corrected Kullback information
+ %% criterion (recommended),
+ %% 'KIC' -- Kullback information criterion
+ %% 'AICc' -- corrected Akaike information criterion
+ %% 'AIC' -- Akaike information criterion
+ %% 'FPE' -- final prediction error" criterion
+ %% The default is to NOT use a model-selection criterion
+
+ RETURNED VALUES:
+ If return values are not required by the caller, the spectrum
+ is plotted and nothing is returned.
+ psd %% [real vector] power-spectral density estimate
+ f_out %% [real vector] frequency values
+
+ HINTS
+ This function is a wrapper for arburg and ar_psd.
+ See "help arburg", "help ar_psd".
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 80
+ usage:
+ [psd,f_out] = pburg(x,poles,freq,Fs,range,method,plot_type,criterion
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 15
+pei_tseng_notch
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 707
+ -- Function File: [ B, A ] = pei_tseng_notch ( FREQUENCIES,
+ BANDWIDTHS
+ Return coefficients for an IIR notch-filter with one or more
+ filter frequencies and according (very narrow) bandwidths to be
+ used with `filter' or `filtfilt'. The filter construction is
+ based on an allpass which performs a reversal of phase at the
+ filter frequencies. Thus, the mean of the phase-distorted and the
+ original signal has the respective frequencies removed. See the
+ demo for an illustration.
+
+ Original source: Pei, Soo-Chang, and Chien-Cheng Tseng "IIR
+ Multiple Notch Filter Design Based on Allpass Filter" 1996 IEEE
+ Tencon doi: 10.1109/TENCON.1996.608814)
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 80
+Return coefficients for an IIR notch-filter with one or more filter
+frequencies
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 8
+polystab
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 156
+ b = polystab(a)
+
+ Stabalize the polynomial transfer function by replacing all roots
+ outside the unit circle with their reflection inside the unit circle.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 17
+ b = polystab(a)
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 8
+pulstran
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 1187
+ usage: y=pulstran(t,d,'func',...)
+ y=pulstran(t,d,p,Fs,'interp')
+
+ Generate the signal y=sum(func(t+d,...)) for each d. If d is a
+ matrix of two columns, the first column is the delay d and the second
+ column is the amplitude a, and y=sum(a*func(t+d)) for each d,a.
+ Clearly, func must be a function which accepts a vector of times.
+ Any extra arguments needed for the function must be tagged on the end.
+
+ Example
+ fs = 11025; # arbitrary sample rate
+ f0 = 100; # pulse train sample rate
+ w = 0.001; # pulse width of 1 millisecond
+ auplot(pulstran(0:1/fs:0.1, 0:1/f0:0.1, 'rectpuls', w), fs);
+
+ If instead of a function name you supply a pulse shape sampled at
+ frequency Fs (default 1 Hz), an interpolated version of the pulse
+ is added at each delay d. The interpolation stays within the the
+ time range of the delayed pulse. The interpolation method defaults
+ to linear, but it can be any interpolation method accepted by the
+ function interp1.
+
+ Example
+ fs = 11025; # arbitrary sample rate
+ f0 = 100; # pulse train sample rate
+ w = boxcar(10); # pulse width of 1 millisecond at 10 kHz
+ auplot(pulstran(0:1/fs:0.1, 0:1/f0:0.1, w, 10000), fs);
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 31
+ usage: y=pulstran(t,d,'func',.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 6
+pwelch
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 7140
+ USAGE:
+ [spectra,freq] = pwelch(x,window,overlap,Nfft,Fs,
+ range,plot_type,detrend,sloppy)
+ Estimate power spectral density of data "x" by the Welch (1967)
+ periodogram/FFT method. All arguments except "x" are optional.
+ The data is divided into segments. If "window" is a vector, each
+ segment has the same length as "window" and is multiplied by "window"
+ before (optional) zero-padding and calculation of its periodogram. If
+ "window" is a scalar, each segment has a length of "window" and a
+ Hamming window is used.
+ The spectral density is the mean of the periodograms, scaled so that
+ area under the spectrum is the same as the mean square of the
+ data. This equivalence is supposed to be exact, but in practice there
+ is a mismatch of up to 0.5% when comparing area under a periodogram
+ with the mean square of the data.
+
+ [spectra,freq] = pwelch(x,y,window,overlap,Nfft,Fs,
+ range,plot_type,detrend,sloppy,results)
+ Two-channel spectrum analyser. Estimate power spectral density, cross-
+ spectral density, transfer function and/or coherence functions of time-
+ series input data "x" and output data "y" by the Welch (1967)
+ periodogram/FFT method.
+ pwelch treats the second argument as "y" if there is a control-string
+ argument "cross", "trans", "coher" or "ypower"; "power" does not force
+ the 2nd argument to be treated as "y". All other arguments are
+ optional. All spectra are returned in matrix "spectra".
+
+ [spectra,Pxx_ci,freq] = pwelch(x,window,overlap,Nfft,Fs,conf,
+ range,plot_type,detrend,sloppy)
+ [spectra,Pxx_ci,freq] = pwelch(x,y,window,overlap,Nfft,Fs,conf,
+ range,plot_type,detrend,sloppy,results)
+ Estimates confidence intervals for the spectral density.
+ See Hint (7) below for compatibility options. Confidence level "conf"
+ is the 6th or 7th numeric argument. If "results" control-string
+ arguments are used, one of them must be "power" when the "conf"
+ argument is present; pwelch can estimate confidence intervals only for
+ the power spectrum of the "x" data. It does not know how to estimate
+ confidence intervals of the cross-power spectrum, transfer function or
+ coherence; if you can suggest a good method, please send a bug report.
+
+ ARGUMENTS
+ All but the first argument are optional and may be empty, except that
+ the "results" argument may require the second argument to be "y".
+
+ x %% [non-empty vector] system-input time-series data
+ y %% [non-empty vector] system-output time-series data
+
+ window %% [real vector] of window-function values between 0 and 1; the
+ %% data segment has the same length as the window.
+ %% Default window shape is Hamming.
+ %% [integer scalar] length of each data segment. The default
+ %% value is window=sqrt(length(x)) rounded up to the
+ %% nearest integer power of 2; see 'sloppy' argument.
+
+ overlap %% [real scalar] segment overlap expressed as a multiple of
+ %% window or segment length. 0 <= overlap < 1,
+ %% The default is overlap=0.5 .
+
+ Nfft %% [integer scalar] Length of FFT. The default is the length
+ %% of the "window" vector or has the same value as the
+ %% scalar "window" argument. If Nfft is larger than the
+ %% segment length, "seg_len", the data segment is padded
+ %% with "Nfft-seg_len" zeros. The default is no padding.
+ %% Nfft values smaller than the length of the data
+ %% segment (or window) are ignored silently.
+
+ Fs %% [real scalar] sampling frequency (Hertz); default=1.0
+
+ conf %% [real scalar] confidence level between 0 and 1. Confidence
+ %% intervals of the spectral density are estimated from
+ %% scatter in the periodograms and are returned as Pxx_ci.
+ %% Pxx_ci(:,1) is the lower bound of the confidence
+ %% interval and Pxx_ci(:,2) is the upper bound. If there
+ %% are three return values, or conf is an empty matrix,
+ %% confidence intervals are calculated for conf=0.95 .
+ %% If conf is zero or is not given, confidence intervals
+ %% are not calculated. Confidence intervals can be
+ %% obtained only for the power spectral density of x;
+ %% nothing else.
+
+ CONTROL-STRING ARGUMENTS -- each of these arguments is a character string.
+ Control-string arguments must be after the other arguments but can be in
+ any order.
+
+ range %% 'half', 'onesided' : frequency range of the spectrum is
+ %% zero up to but not including Fs/2. Power from
+ %% negative frequencies is added to the positive side of
+ %% the spectrum, but not at zero or Nyquist (Fs/2)
+ %% frequencies. This keeps power equal in time and
+ %% spectral domains. See reference [2].
+ %% 'whole', 'twosided' : frequency range of the spectrum is
+ %% -Fs/2 to Fs/2, with negative frequencies
+ %% stored in "wrap around" order after the positive
+ %% frequencies; e.g. frequencies for a 10-point 'twosided'
+ %% spectrum are 0 0.1 0.2 0.3 0.4 0.5 -0.4 -0.3 -0.2 -0.1
+ %% 'shift', 'centerdc' : same as 'whole' but with the first half
+ %% of the spectrum swapped with second half to put the
+ %% zero-frequency value in the middle. (See "help
+ %% fftshift".
+ %% If data (x and y) are real, the default range is 'half',
+ %% otherwise default range is 'whole'.
+
+ plot_type %% 'plot', 'semilogx', 'semilogy', 'loglog', 'squared' or 'db':
+ %% specifies the type of plot. The default is 'plot', which
+ %% means linear-linear axes. 'squared' is the same as 'plot'.
+ %% 'dB' plots "10*log10(psd)". This argument is ignored and a
+ %% spectrum is not plotted if the caller requires a returned
+ %% value.
+
+ detrend %% 'no-strip', 'none' -- do NOT remove mean value from the data
+ %% 'short', 'mean' -- remove the mean value of each segment from
+ %% each segment of the data.
+ %% 'linear', -- remove linear trend from each segment of
+ %% the data.
+ %% 'long-mean' -- remove the mean value from the data before
+ %% splitting it into segments. This is the default.
+
+ sloppy %% 'sloppy': FFT length is rounded up to the nearest integer
+ %% power of 2 by zero padding. FFT length is adjusted
+ %% after addition of padding by explicit Nfft argument.
+ %% The default is to use exactly the FFT and window/
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 80
+ USAGE:
+ [spectra,freq] = pwelch(x,window,overlap,Nfft,Fs,
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 7
+pyulear
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 3140
+ usage:
+ [psd,f_out] = pyulear(x,poles,freq,Fs,range,method,plot_type)
+
+ Calculates a Yule-Walker autoregressive (all-pole) model of the data "x"
+ and computes the power spectrum of the model. This is a wrapper for
+ functions "aryule" and "ar_psd" which perform the argument checking.
+ See "help aryule" and "help ar_psd" for further details.
+
+ ARGUMENTS:
+ All but the first two arguments are optional and may be empty.
+ x %% [vector] sampled data
+
+ poles %% [integer scalar] required number of poles of the AR model
+
+ freq %% [real vector] frequencies at which power spectral density
+ %% is calculated
+ %% [integer scalar] number of uniformly distributed frequency
+ %% values at which spectral density is calculated.
+ %% [default=256]
+
+ Fs %% [real scalar] sampling frequency (Hertz) [default=1]
+
+
+ CONTROL-STRING ARGUMENTS -- each of these arguments is a character string.
+ Control-string arguments can be in any order after the other arguments.
+
+
+ range %% 'half', 'onesided' : frequency range of the spectrum is
+ %% from zero up to but not including sample_f/2. Power
+ %% from negative frequencies is added to the positive
+ %% side of the spectrum.
+ %% 'whole', 'twosided' : frequency range of the spectrum is
+ %% -sample_f/2 to sample_f/2, with negative frequencies
+ %% stored in "wrap around" order after the positive
+ %% frequencies; e.g. frequencies for a 10-point 'twosided'
+ %% spectrum are 0 0.1 0.2 0.3 0.4 0.5 -0.4 -0.3 -0.2 -0.1
+ %% 'shift', 'centerdc' : same as 'whole' but with the first half
+ %% of the spectrum swapped with second half to put the
+ %% zero-frequency value in the middle. (See "help
+ %% fftshift". If "freq" is vector, 'shift' is ignored.
+ %% If model coefficients "ar_coeffs" are real, the default
+ %% range is 'half', otherwise default range is 'whole'.
+
+ method %% 'fft': use FFT to calculate power spectrum.
+ %% 'poly': calculate power spectrum as a polynomial of 1/z
+ %% N.B. this argument is ignored if the "freq" argument is a
+ %% vector. The default is 'poly' unless the "freq"
+ %% argument is an integer power of 2.
+
+ plot_type %% 'plot', 'semilogx', 'semilogy', 'loglog', 'squared' or 'db':
+ %% specifies the type of plot. The default is 'plot', which
+ %% means linear-linear axes. 'squared' is the same as 'plot'.
+ %% 'dB' plots "10*log10(psd)". This argument is ignored and a
+ %% spectrum is not plotted if the caller requires a returned
+ %% value.
+
+ RETURNED VALUES:
+ If return values are not required by the caller, the spectrum
+ is plotted and nothing is returned.
+ psd %% [real vector] power-spectrum estimate
+ f_out %% [real vector] frequency values
+
+ HINTS
+ This function is a wrapper for aryule and ar_psd.
+ See "help aryule", "help ar_psd".
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 74
+ usage:
+ [psd,f_out] = pyulear(x,poles,freq,Fs,range,method,plot_type)
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 9
+qp_kaiser
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 602
+ Usage: qp_kaiser (nb, at, linear)
+
+ Computes a finite impulse response (FIR) filter for use with a
+ quasi-perfect reconstruction polyphase-network filter bank. This
+ version utilizes a Kaiser window to shape the frequency response of
+ the designed filter. Tha number nb of bands and the desired
+ attenuation at in the stop-band are given as parameters.
+
+ The Kaiser window is multiplied by the ideal impulse response
+ h(n)=a.sinc(a.n) and converted to its minimum-phase version by means
+ of a Hilbert transform.
+
+ By using a third non-null argument, the minimum-phase calculation is
+ ommited at all.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 36
+ Usage: qp_kaiser (nb, at, linear)
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 5
+rceps
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 693
+ usage: [y, xm] = rceps(x)
+ Produce the cepstrum of the signal x, and if desired, the minimum
+ phase reconstruction of the signal x. If x is a matrix, do so
+ for each column of the matrix.
+
+ Example
+ f0=70; Fs=10000; # 100 Hz fundamental, 10kHz sampling rate
+ a=poly(0.985*exp(1i*pi*[0.1, -0.1, 0.3, -0.3])); # two formants
+ s=0.005*randn(1024,1); # Noise excitation signal
+ s(1:Fs/f0:length(s)) = 1; # Impulse glottal wave
+ x=filter(1,a,s); # Speech signal in x
+ [y, xm] = rceps(x.*hanning(1024)); # cepstrum and min phase reconstruction
+
+ Reference
+ Programs for digital signal processing. IEEE Press.
+ New York: John Wiley & Sons. 1979.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 80
+ usage: [y, xm] = rceps(x)
+ Produce the cepstrum of the signal x, and if desir
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 8
+rectpuls
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 429
+ usage: y = rectpuls(t, w)
+
+ Generate a rectangular pulse over the interval [-w/2,w/2), sampled at
+ times t. This is useful with the function pulstran for generating a
+ series pulses.
+
+ Example
+ fs = 11025; # arbitrary sample rate
+ f0 = 100; # pulse train sample rate
+ w = 0.3/f0; # pulse width 3/10th the distance between pulses
+ auplot(pulstran(0:1/fs:4/f0, 0:1/f0:4/f0, 'rectpuls', w), fs);
+
+ See also: pulstran
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 27
+ usage: y = rectpuls(t, w)
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 7
+rectwin
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 142
+ -- Function File: [W] = rectwin(L)
+ Return the filter coefficients of a rectangle window of length L.
+
+ See also: hamming, hanning
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 65
+Return the filter coefficients of a rectangle window of length L.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 8
+resample
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 637
+ -- Function File: [Y H]= resample(X,P,Q)
+ -- Function File: Y = resample(X,P,Q,H)
+ Change the sample rate of X by a factor of P/Q. This is performed
+ using a polyphase algorithm. The impulse response H of the
+ antialiasing filter is either specified or either designed with a
+ Kaiser-windowed sinecard.
+
+ Ref [1] J. G. Proakis and D. G. Manolakis, Digital Signal
+ Processing: Principles, Algorithms, and Applications, 4th ed.,
+ Prentice Hall, 2007. Chap. 6
+
+ Ref [2] A. V. Oppenheim, R. W. Schafer and J. R. Buck,
+ Discrete-time signal processing, Signal processing series,
+ Prentice-Hall, 1999
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 47
+Change the sample rate of X by a factor of P/Q.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 8
+residued
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 1061
+ -- Function File: [R, P, F, M] = residued (B, A)
+ Compute the partial fraction expansion (PFE) of filter H(z) =
+ B(z)/A(z). In the usual PFE function `residuez', the IIR part
+ (poles P and residues R) is driven _in parallel_ with the FIR part
+ (F). In this variant (`residued') the IIR part is driven by the
+ _output_ of the FIR part. This structure can be more accurate in
+ signal modeling applications.
+
+ INPUTS: B and A are vectors specifying the digital filter H(z) =
+ B(z)/A(z). Say `help filter' for documentation of the B and A
+ filter coefficients.
+
+ RETURNED:
+ * R = column vector containing the filter-pole residues
+ * P = column vector containing the filter poles
+ * F = row vector containing the FIR part, if any
+ * M = column vector of pole multiplicities
+
+ EXAMPLES:
+ Say `test residued verbose' to see a number of examples.
+
+ For the theory of operation, see
+ <http://ccrma.stanford.edu/~jos/filters/residued.html>
+
+ See also: residue residued
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 72
+Compute the partial fraction expansion (PFE) of filter H(z) = B(z)/A(z).
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 8
+residuez
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 750
+ -- Function File: [R, P, F, M] = residuez (B, A)
+ Compute the partial fraction expansion of filter H(z) = B(z)/A(z).
+
+ INPUTS: B and A are vectors specifying the digital filter H(z) =
+ B(z)/A(z). Say `help filter' for documentation of the B and A
+ filter coefficients.
+
+ RETURNED:
+ * R = column vector containing the filter-pole residues
+ * P = column vector containing the filter poles
+ * F = row vector containing the FIR part, if any
+ * M = column vector of pole multiplicities
+
+ EXAMPLES:
+ Say `test residuez verbose' to see a number of examples.
+
+ For the theory of operation, see
+ <http://ccrma.stanford.edu/~jos/filters/residuez.html>
+
+ See also: residue residued
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 66
+Compute the partial fraction expansion of filter H(z) = B(z)/A(z).
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 18
+sampled2continuous
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 402
+ Usage:
+
+ xt = sampled2continuous( xn , T, t )
+
+ Calculate the x(t) reconstructed
+ from samples x[n] sampled at a rate 1/T samples
+ per unit time.
+
+ t is all the instants of time when you need x(t)
+ from x[n]; this time is relative to x[0] and not
+ an absolute time.
+
+ This function can be used to calculate sampling rate
+ effects on aliasing, actual signal reconstruction
+ from discrete samples.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 80
+ Usage:
+
+ xt = sampled2continuous( xn , T, t )
+
+ Calculate the x(t) reconstruc
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 8
+sawtooth
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 664
+ -- Function File: [Y] = sawtooth(T)
+ -- Function File: [Y] = sawtooth(T,WIDTH)
+ Generates a sawtooth wave of period `2 * pi' with limits `+1/-1'
+ for the elements of T.
+
+ WIDTH is a real number between `0' and `1' which specifies the
+ point between `0' and `2 * pi' where the maximum is. The function
+ increases linearly from `-1' to `1' in `[0, 2 * pi * WIDTH]'
+ interval, and decreases linearly from `1' to `-1' in the interval
+ `[2 * pi * WIDTH, 2 * pi]'.
+
+ If WIDTH is 0.5, the function generates a standard triangular wave.
+
+ If WIDTH is not specified, it takes a value of 1, which is a
+ standard sawtooth function.
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 80
+Generates a sawtooth wave of period `2 * pi' with limits `+1/-1' for
+the elemen
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 7
+sftrans
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 3640
+ usage: [Sz, Sp, Sg] = sftrans(Sz, Sp, Sg, W, stop)
+
+ Transform band edges of a generic lowpass filter (cutoff at W=1)
+ represented in splane zero-pole-gain form. W is the edge of the
+ target filter (or edges if band pass or band stop). Stop is true for
+ high pass and band stop filters or false for low pass and band pass
+ filters. Filter edges are specified in radians, from 0 to pi (the
+ nyquist frequency).
+
+ Theory: Given a low pass filter represented by poles and zeros in the
+ splane, you can convert it to a low pass, high pass, band pass or
+ band stop by transforming each of the poles and zeros individually.
+ The following table summarizes the transformation:
+
+ Transform Zero at x Pole at x
+ ---------------- ------------------------- ------------------------
+ Low Pass zero: Fc x/C pole: Fc x/C
+ S -> C S/Fc gain: C/Fc gain: Fc/C
+ ---------------- ------------------------- ------------------------
+ High Pass zero: Fc C/x pole: Fc C/x
+ S -> C Fc/S pole: 0 zero: 0
+ gain: -x gain: -1/x
+ ---------------- ------------------------- ------------------------
+ Band Pass zero: b ± sqrt(b^2-FhFl) pole: b ± sqrt(b^2-FhFl)
+ S^2+FhFl pole: 0 zero: 0
+ S -> C -------- gain: C/(Fh-Fl) gain: (Fh-Fl)/C
+ S(Fh-Fl) b=x/C (Fh-Fl)/2 b=x/C (Fh-Fl)/2
+ ---------------- ------------------------- ------------------------
+ Band Stop zero: b ± sqrt(b^2-FhFl) pole: b ± sqrt(b^2-FhFl)
+ S(Fh-Fl) pole: ±sqrt(-FhFl) zero: ±sqrt(-FhFl)
+ S -> C -------- gain: -x gain: -1/x
+ S^2+FhFl b=C/x (Fh-Fl)/2 b=C/x (Fh-Fl)/2
+ ---------------- ------------------------- ------------------------
+ Bilinear zero: (2+xT)/(2-xT) pole: (2+xT)/(2-xT)
+ 2 z-1 pole: -1 zero: -1
+ S -> - --- gain: (2-xT)/T gain: (2-xT)/T
+ T z+1
+ ---------------- ------------------------- ------------------------
+
+ where C is the cutoff frequency of the initial lowpass filter, Fc is
+ the edge of the target low/high pass filter and [Fl,Fh] are the edges
+ of the target band pass/stop filter. With abundant tedious algebra,
+ you can derive the above formulae yourself by substituting the
+ transform for S into H(S)=S-x for a zero at x or H(S)=1/(S-x) for a
+ pole at x, and converting the result into the form:
+
+ H(S)=g prod(S-Xi)/prod(S-Xj)
+
+ The transforms are from the references. The actual pole-zero-gain
+ changes I derived myself.
+
+ Please note that a pole and a zero at the same place exactly cancel.
+ This is significant for High Pass, Band Pass and Band Stop filters
+ which create numerous extra poles and zeros, most of which cancel.
+ Those which do not cancel have a "fill-in" effect, extending the
+ shorter of the sets to have the same number of as the longer of the
+ sets of poles and zeros (or at least split the difference in the case
+ of the band pass filter). There may be other opportunistic
+ cancellations but I will not check for them.
+
+ Also note that any pole on the unit circle or beyond will result in
+ an unstable filter. Because of cancellation, this will only happen
+ if the number of poles is smaller than the number of zeros and the
+ filter is high pass or band pass. The analytic design methods all
+ yield more poles than zeros, so this will not be a problem.
+
+ References:
+
+ Proakis & Manolakis (1992). Digital Signal Processing. New York:
+ Macmillan Publishing Company.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 52
+ usage: [Sz, Sp, Sg] = sftrans(Sz, Sp, Sg, W, stop)
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 6
+sgolay
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 1079
+ F = sgolay (p, n [, m [, ts]])
+ Computes the filter coefficients for all Savitzsky-Golay smoothing
+ filters of order p for length n (odd). m can be used in order to
+ get directly the mth derivative. In this case, ts is a scaling factor.
+
+ The early rows of F smooth based on future values and later rows
+ smooth based on past values, with the middle row using half future
+ and half past. In particular, you can use row i to estimate x(k)
+ based on the i-1 preceding values and the n-i following values of x
+ values as y(k) = F(i,:) * x(k-i+1:k+n-i).
+
+ Normally, you would apply the first (n-1)/2 rows to the first k
+ points of the vector, the last k rows to the last k points of the
+ vector and middle row to the remainder, but for example if you were
+ running on a realtime system where you wanted to smooth based on the
+ all the data collected up to the current time, with a lag of five
+ samples, you could apply just the filter on row n-5 to your window
+ of length n each time you added a new sample.
+
+ Reference: Numerical recipes in C. p 650
+
+ See also: sgolayfilt
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 80
+ F = sgolay (p, n [, m [, ts]])
+ Computes the filter coefficients for all Savi
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 10
+sgolayfilt
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 857
+ y = sgolayfilt (x, p, n [, m [, ts]])
+ Smooth the data in x with a Savitsky-Golay smoothing filter of
+ polynomial order p and length n, n odd, n > p. By default, p=3
+ and n=p+2 or n=p+3 if p is even.
+
+ y = sgolayfilt (x, F)
+ Smooth the data in x with smoothing filter F computed by sgolay.
+
+ These filters are particularly good at preserving lineshape while
+ removing high frequency squiggles. Particularly, compare a 5 sample
+ averager, an order 5 butterworth lowpass filter (cutoff 1/3) and
+ sgolayfilt(x, 3, 5), the best cubic estimated from 5 points:
+
+ [b, a] = butter(5,1/3);
+ x=[zeros(1,15), 10*ones(1,10), zeros(1,15)];
+ plot(sgolayfilt(x),"r;sgolayfilt;",...
+ filtfilt(ones(1,5)/5,1,x),"g;5 sample average;",...
+ filtfilt(b,a,x),"c;order 5 butterworth;",...
+ x,"+b;original data;");
+
+ See also: sgolay
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 80
+ y = sgolayfilt (x, p, n [, m [, ts]])
+ Smooth the data in x with a Savitsky-
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 8
+shanwavf
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 97
+ -- Function File: [PSI,X] = shanwavf (LB,UB,N,FB,FC)
+ Compute the Complex Shannon wavelet.
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 36
+Compute the Complex Shannon wavelet.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 13
+sigmoid_train
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 555
+ -- Function File: Y = sigmoid_train(T, RANGES, RC)
+ Evaluates a train of sigmoid functions at T.
+
+ The number and duration of each sigmoid is determined from RANGES.
+ Each row of RANGES represents a real interval, e.g. if sigmod `i'
+ starts at `t=0.1' and ends at `t=0.5', then `RANGES(i,:) = [0.1
+ 0.5]'. The input RC is a array that defines the rising and
+ falling time constants of each sigmoids. Its size must equal the
+ size of RANGES.
+
+ Run `demo sigmoid_train' to some examples of the use of this
+ function.
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 44
+Evaluates a train of sigmoid functions at T.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 6
+sos2tf
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 808
+ -- Function File: [B, A] = sos2tf (SOS, BSCALE)
+ Convert series second-order sections to direct form H(z) =
+ B(z)/A(z).
+
+ INPUTS:
+ * SOS = matrix of series second-order sections, one per row:
+ SOS = [B1.' A1.'; ...; BN.' AN.'], where
+ `B1.'==[b0 b1 b2] and A1.'==[1 a1 a2]' for section 1, etc.
+ b0 must be nonzero for each section.
+ See `filter()' for documentation of the second-order
+ direct-form filter coefficients Bi and Ai.
+
+ * BSCALE is an overall gain factor that effectively scales the
+ output B vector (or any one of the input Bi vectors).
+
+ RETURNED: B and A are vectors specifying the digital filter H(z) =
+ B(z)/A(z). See `filter()' for further details.
+
+ See also: tf2sos zp2sos sos2pz zp2tf tf2zp
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 69
+Convert series second-order sections to direct form H(z) = B(z)/A(z).
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 6
+sos2zp
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 1009
+ -- Function File: [Z, P, G] = sos2zp (SOS, BSCALE)
+ Convert series second-order sections to zeros, poles, and gains
+ (pole residues).
+
+ INPUTS:
+ * SOS = matrix of series second-order sections, one per row:
+ SOS = [B1.' A1.'; ...; BN.' AN.'], where
+ `B1.'==[b0 b1 b2] and A1.'==[1 a1 a2]' for section 1, etc.
+ b0 must be nonzero for each section. See `filter()' for
+ documentation of the second-order direct-form filter
+ coefficients Bi and Ai.
+
+ * BSCALE is an overall gain factor that effectively scales any
+ one of the input Bi vectors.
+
+ RETURNED:
+ * Z = column-vector containing all zeros (roots of B(z))
+ * P = column-vector containing all poles (roots of A(z))
+ * G = overall gain = B(Inf)
+
+ EXAMPLE:
+ [z,p,g] = sos2zp([1 0 1, 1 0 -0.81; 1 0 0, 1 0 0.49])
+ => z = [i; -i; 0; 0], p = [0.9, -0.9, 0.7i, -0.7i], g=1
+
+ See also: zp2sos sos2tf tf2sos zp2tf tf2zp
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 80
+Convert series second-order sections to zeros, poles, and gains (pole
+residues).
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 8
+specgram
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 4570
+ usage: [S [, f [, t]]] = specgram(x [, n [, Fs [, window [, overlap]]]])
+
+ Generate a spectrogram for the signal. This chops the signal into
+ overlapping slices, windows each slice and applies a Fourier
+ transform to determine the frequency components at that slice.
+
+ x: vector of samples
+ n: size of fourier transform window, or [] for default=256
+ Fs: sample rate, or [] for default=2 Hz
+ window: shape of the fourier transform window, or [] for default=hanning(n)
+ Note: window length can be specified instead, in which case
+ window=hanning(length)
+ overlap: overlap with previous window, or [] for default=length(window)/2
+
+ Return values
+ S is complex output of the FFT, one row per slice
+ f is the frequency indices corresponding to the rows of S.
+ t is the time indices corresponding to the columns of S.
+ If no return value is requested, the spectrogram is displayed instead.
+
+ Example
+ x = chirp([0:0.001:2],0,2,500); # freq. sweep from 0-500 over 2 sec.
+ Fs=1000; # sampled every 0.001 sec so rate is 1 kHz
+ step=ceil(20*Fs/1000); # one spectral slice every 20 ms
+ window=ceil(100*Fs/1000); # 100 ms data window
+ specgram(x, 2^nextpow2(window), Fs, window, window-step);
+
+ ## Speech spectrogram
+ [x, Fs] = auload(file_in_loadpath("sample.wav")); # audio file
+ step = fix(5*Fs/1000); # one spectral slice every 5 ms
+ window = fix(40*Fs/1000); # 40 ms data window
+ fftn = 2^nextpow2(window); # next highest power of 2
+ [S, f, t] = specgram(x, fftn, Fs, window, window-step);
+ S = abs(S(2:fftn*4000/Fs,:)); # magnitude in range 0<f<=4000 Hz.
+ S = S/max(S(:)); # normalize magnitude so that max is 0 dB.
+ S = max(S, 10^(-40/10)); # clip below -40 dB.
+ S = min(S, 10^(-3/10)); # clip above -3 dB.
+ imagesc(t, f, flipud(log(S))); # display in log scale
+
+ The choice of window defines the time-frequency resolution. In
+ speech for example, a wide window shows more harmonic detail while a
+ narrow window averages over the harmonic detail and shows more
+ formant structure. The shape of the window is not so critical so long
+ as it goes gradually to zero on the ends.
+
+ Step size (which is window length minus overlap) controls the
+ horizontal scale of the spectrogram. Decrease it to stretch, or
+ increase it to compress. Increasing step size will reduce time
+ resolution, but decreasing it will not improve it much beyond the
+ limits imposed by the window size (you do gain a little bit,
+ depending on the shape of your window, as the peak of the window
+ slides over peaks in the signal energy). The range 1-5 msec is good
+ for speech.
+
+ FFT length controls the vertical scale. Selecting an FFT length
+ greater than the window length does not add any information to the
+ spectrum, but it is a good way to interpolate between frequency
+ points which can make for prettier spectrograms.
+
+ After you have generated the spectral slices, there are a number of
+ decisions for displaying them. First the phase information is
+ discarded and the energy normalized:
+
+ S = abs(S); S = S/max(S(:));
+
+ Then the dynamic range of the signal is chosen. Since information in
+ speech is well above the noise floor, it makes sense to eliminate any
+ dynamic range at the bottom end. This is done by taking the max of
+ the magnitude and some minimum energy such as minE=-40dB. Similarly,
+ there is not much information in the very top of the range, so
+ clipping to a maximum energy such as maxE=-3dB makes sense:
+
+ S = max(S, 10^(minE/10)); S = min(S, 10^(maxE/10));
+
+ The frequency range of the FFT is from 0 to the Nyquist frequency of
+ one half the sampling rate. If the signal of interest is band
+ limited, you do not need to display the entire frequency range. In
+ speech for example, most of the signal is below 4 kHz, so there is no
+ reason to display up to the Nyquist frequency of 10 kHz for a 20 kHz
+ sampling rate. In this case you will want to keep only the first 40%
+ of the rows of the returned S and f. More generally, to display the
+ frequency range [minF, maxF], you could use the following row index:
+
+ idx = (f >= minF & f <= maxF);
+
+ Then there is the choice of colormap. A brightness varying colormap
+ such as copper or bone gives good shape to the ridges and valleys. A
+ hue varying colormap such as jet or hsv gives an indication of the
+ steepness of the slopes. The final spectrogram is displayed in log
+ energy scale and by convention has low frequencies on the bottom of
+ the image:
+
+ imagesc(t, f, flipud(log(S(idx,:))));
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 74
+ usage: [S [, f [, t]]] = specgram(x [, n [, Fs [, window [, overlap]]]])
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 6
+square
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 379
+ -- Function File: S = square(T, DUTY)
+ -- Function File: S = square(T)
+ Generate a square wave of period 2 pi with limits +1/-1.
+
+ If DUTY is specified, the square wave is +1 for that portion of
+ the time.
+
+ on time
+ duty cycle = ------------------
+ on time + off time
+
+ See also: cos, sawtooth, sin, tripuls
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 56
+Generate a square wave of period 2 pi with limits +1/-1.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 5
+ss2tf
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 355
+ -- Function File: [NUM, DEN] = ss2tf (A, B, C, D)
+ Conversion from transfer function to state-space. The state space
+ system:
+ .
+ x = Ax + Bu
+ y = Cx + Du
+
+ is converted to a transfer function:
+
+ num(s)
+ G(s)=-------
+ den(s)
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 49
+Conversion from transfer function to state-space.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 5
+ss2zp
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 172
+ -- Function File: [POL, ZER, K] = ss2zp (A, B, C, D)
+ Converts a state space representation to a set of poles and zeros;
+ K is a gain associated with the zeros.
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 80
+Converts a state space representation to a set of poles and zeros; K is
+a gain a
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 6
+tf2sos
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 1051
+ -- Function File: [SOS, G] = tf2sos (B, A)
+ Convert direct-form filter coefficients to series second-order
+ sections.
+
+ INPUTS: B and A are vectors specifying the digital filter H(z) =
+ B(z)/A(z). See `filter()' for documentation of the B and A filter
+ coefficients.
+
+ RETURNED: SOS = matrix of series second-order sections, one per
+ row:
+ SOS = [B1.' A1.'; ...; BN.' AN.'], where
+ `B1.'==[b0 b1 b2] and A1.'==[1 a1 a2]' for section 1, etc.
+ b0 must be nonzero for each section (zeros at infinity not
+ supported). BSCALE is an overall gain factor that effectively
+ scales any one of the Bi vectors.
+
+ EXAMPLE:
+ B=[1 0 0 0 0 1];
+ A=[1 0 0 0 0 .9];
+ [sos,g] = tf2sos(B,A)
+
+ sos =
+
+ 1.00000 0.61803 1.00000 1.00000 0.60515 0.95873
+ 1.00000 -1.61803 1.00000 1.00000 -1.58430 0.95873
+ 1.00000 1.00000 -0.00000 1.00000 0.97915 -0.00000
+
+ g = 1
+
+ See also: sos2tf zp2sos sos2pz zp2tf tf2zp
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 72
+Convert direct-form filter coefficients to series second-order sections.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 5
+tf2ss
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 518
+ -- Function File: [A, B, C, D] = tf2ss (NUM, DEN)
+ Conversion from transfer function to state-space. The state space
+ system:
+ .
+ x = Ax + Bu
+ y = Cx + Du
+ is obtained from a transfer function:
+ num(s)
+ G(s)=-------
+ den(s)
+
+ The state space system matrices obtained from this function will
+ be in observable companion form as Wolovich's Observable Structure
+ Theorem is used.
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 49
+Conversion from transfer function to state-space.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 5
+tf2zp
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 241
+ -- Function File: [ZER, POL, K] = tf2zp (NUM, DEN)
+ Converts transfer functions to poles-and-zero representations.
+
+ Returns the zeros and poles of the system defined by NUM/DEN. K
+ is a gain associated with the system zeros.
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 62
+Converts transfer functions to poles-and-zero representations.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 3
+tfe
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 381
+ Usage:
+ [Pxx,freq] = tfe(x,y,Nfft,Fs,window,overlap,range,plot_type,detrend)
+
+ Estimate transfer function of system with input "x" and output "y".
+ Use the Welch (1967) periodogram/FFT method.
+ Compatible with Matlab R11 tfe and earlier.
+ See "help pwelch" for description of arguments, hints and references
+ --- especially hint (7) for Matlab R11 defaults.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 80
+ Usage:
+ [Pxx,freq] = tfe(x,y,Nfft,Fs,window,overlap,range,plot_type,detrend)
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 10
+tfestimate
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 284
+ Usage:
+ [Pxx,freq]=tfestimate(x,y,Nfft,Fs,window,overlap,range,plot_type,detrend)
+
+ Estimate transfer function of system with input "x" and output "y".
+ Use the Welch (1967) periodogram/FFT method.
+ See "help pwelch" for description of arguments, hints and references.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 80
+ Usage:
+ [Pxx,freq]=tfestimate(x,y,Nfft,Fs,window,overlap,range,plot_type,detr
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 6
+triang
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 277
+ usage: w = triang (L)
+
+ Returns the filter coefficients of a triangular window of length L.
+ Unlike the bartlett window, triang does not go to zero at the edges
+ of the window. For odd L, triang(L) is equal to bartlett(L+2) except
+ for the zeros at the edges of the window.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 24
+ usage: w = triang (L)
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 7
+tripuls
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 629
+ usage: y = tripuls(t, w, skew)
+
+ Generate a triangular pulse over the interval [-w/2,w/2), sampled at
+ times t. This is useful with the function pulstran for generating a
+ series pulses.
+
+ skew is a value between -1 and 1, indicating the relative placement
+ of the peak within the width. -1 indicates that the peak should be
+ at -w/2, and 1 indicates that the peak should be at w/2.
+
+ Example
+ fs = 11025; # arbitrary sample rate
+ f0 = 100; # pulse train sample rate
+ w = 0.3/f0; # pulse width 3/10th the distance between pulses
+ auplot(pulstran(0:1/fs:4/f0, 0:1/f0:4/f0, 'tripuls', w), fs);
+
+ See also: pulstran
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 32
+ usage: y = tripuls(t, w, skew)
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 8
+tukeywin
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 633
+ -- Function File: W = tukeywin (L, R)
+ Return the filter coefficients of a Tukey window (also known as the
+ cosine-tapered window) of length L. R defines the ratio between
+ the constant section and and the cosine section. It has to be
+ between 0 and 1. The function returns a Hanning window for R egals
+ 0 and a full box for R egals 1. By default R is set to 1/2.
+
+ For a definition of the Tukey window, see e.g. Fredric J. Harris,
+ "On the Use of Windows for Harmonic Analysis with the Discrete
+ Fourier Transform, Proceedings of the IEEE", Vol. 66, No. 1,
+ January 1978, Page 67, Equation 38.
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 80
+Return the filter coefficients of a Tukey window (also known as the
+cosine-taper
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 8
+upsample
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 372
+ -- Function File: Y = upsample (X, N)
+ -- Function File: Y = upsample (X, N, OFFSET)
+ Upsample the signal, inserting n-1 zeros between every element.
+
+ If X is a matrix, upsample every column.
+
+ If OFFSET is specified, control the position of the inserted
+ sample in the block of n zeros.
+
+ See also: decimate, downsample, interp, resample, upfirdn
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 63
+Upsample the signal, inserting n-1 zeros between every element.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 8
+welchwin
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 696
+ -- Function File: [W] = welchwin(L,C)
+ Returns a row vector containing a Welch window, given by
+ W(n)=1-(n/N-1)^2, n=[0,1, ... L-1]. Argument L is the length of
+ the window. Optional argument C specifies a "symmetric" window
+ (the default), or a "periodic" window.
+
+ A symmetric window has zero at each end and maximum in the middle;
+ L must be an integer larger than 2. `if c=="symmetric", N=(L-1)/2'
+
+ A periodic window wraps around the cyclic interval [0,1, ... L-1],
+ and is intended for use with the DFT (functions fft(),
+ periodogram() etc). L must be an integer larger than 1. `if
+ c=="periodic", N=L/2'.
+
+ See also: blackman, kaiser
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 80
+Returns a row vector containing a Welch window, given by
+W(n)=1-(n/N-1)^2, n=[
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 6
+window
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 221
+ -- Function File: W = window (F, N, OPTS)
+ Create a N-point windowing from the function F. The function F can
+ be for example `@blackman'. Any additional arguments OPT are
+ passed to the windowing function.
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 47
+Create a N-point windowing from the function F.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 5
+wkeep
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 127
+ -- Function File: [Y] = wkeep(X,L,OPT)
+ Extract the elements of x of size l from the center, the right or
+ the left.
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 75
+Extract the elements of x of size l from the center, the right or the
+left.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 4
+wrev
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 121
+ -- Function File: [Y] = wrev(X)
+ Reverse the order of the element of the vector x.
+
+ See also: flipud, fliplr
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 49
+Reverse the order of the element of the vector x.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 5
+xcorr
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 2493
+ usage: [R, lag] = xcorr (X [, Y] [, maxlag] [, scale])
+
+ Estimate the cross correlation R_xy(k) of vector arguments X and Y
+ or, if Y is omitted, estimate autocorrelation R_xx(k) of vector X,
+ for a range of lags k specified by argument "maxlag". If X is a
+ matrix, each column of X is correlated with itself and every other
+ column.
+
+ The cross-correlation estimate between vectors "x" and "y" (of
+ length N) for lag "k" is given by
+ R_xy(k) = sum_{i=1}^{N}{x_{i+k} conj(y_i),
+ where data not provided (for example x(-1), y(N+1)) is zero.
+
+ ARGUMENTS
+ X [non-empty; real or complex; vector or matrix] data
+
+ Y [real or complex vector] data
+ If X is a matrix (not a vector), Y must be omitted.
+ Y may be omitted if X is a vector; in this case xcorr
+ estimates the autocorrelation of X.
+
+ maxlag [integer scalar] maximum correlation lag
+ If omitted, the default value is N-1, where N is the
+ greater of the lengths of X and Y or, if X is a matrix,
+ the number of rows in X.
+
+ scale [character string] specifies the type of scaling applied
+ to the correlation vector (or matrix). is one of:
+ 'none' return the unscaled correlation, R,
+ 'biased' return the biased average, R/N,
+ 'unbiased' return the unbiassed average, R(k)/(N-|k|),
+ 'coeff' return the correlation coefficient, R/(rms(x).rms(y)),
+ where "k" is the lag, and "N" is the length of X.
+ If omitted, the default value is "none".
+ If Y is supplied but does not have the ame length as X,
+ scale must be "none".
+
+ RETURNED VARIABLES
+ R array of correlation estimates
+ lag row vector of correlation lags [-maxlag:maxlag]
+
+ The array of correlation estimates has one of the following forms.
+ (1) Cross-correlation estimate if X and Y are vectors.
+ (2) Autocorrelation estimate if is a vector and Y is omitted,
+ (3) If X is a matrix, R is an matrix containing the cross-
+ correlation estimate of each column with every other column.
+ Lag varies with the first index so that R has 2*maxlag+1
+ rows and P^2 columns where P is the number of columns in X.
+ If Rij(k) is the correlation between columns i and j of X
+ R(k+maxlag+1,P*(i-1)+j) == Rij(k)
+ for lag k in [-maxlag:maxlag], or
+ R(:,P*(i-1)+j) == xcorr(X(:,i),X(:,j)).
+ "reshape(R(k,:),P,P)" is the cross-correlation matrix for X(k,:).
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 56
+ usage: [R, lag] = xcorr (X [, Y] [, maxlag] [, scale])
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 6
+xcorr2
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 1046
+ -- Function File: C = xcorr2 (A)
+ -- Function File: C = xcorr2 (A, B)
+ -- Function File: C = xcorr2 (..., SCALE)
+ Compute the 2D cross-correlation of matrices A and B.
+
+ If B is not specified, it defaults to the same matrix as A, i.e.,
+ it's the same as `xcorr(A, A)'.
+
+ The optional argument SCALE, defines the type of scaling applied
+ to the cross-correlation matrix (defaults to "none"). Possible
+ values are:
+ * "biased"
+
+ Scales the raw cross-correlation by the maximum number of
+ elements of A and B involved in the generation of any element
+ of C.
+
+ * "unbiased"
+
+ Scales the raw correlation by dividing each element in the
+ cross-correlation matrix by the number of products A and B
+ used to generate that element
+
+ * "coeff"
+
+ Normalizes the sequence so that the largest cross-correlation
+ element is identically 1.0.
+
+ * "none"
+
+ No scaling (this is the default).
+
+ See also: conv2, corr2, xcorr
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 53
+Compute the 2D cross-correlation of matrices A and B.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 4
+xcov
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 630
+ usage: [c, lag] = xcov (X [, Y] [, maxlag] [, scale])
+
+ Compute covariance at various lags [=correlation(x-mean(x),y-mean(y))].
+
+ X: input vector
+ Y: if specified, compute cross-covariance between X and Y,
+ otherwise compute autocovariance of X.
+ maxlag: is specified, use lag range [-maxlag:maxlag],
+ otherwise use range [-n+1:n-1].
+ Scale:
+ 'biased' for covariance=raw/N,
+ 'unbiased' for covariance=raw/(N-|lag|),
+ 'coeff' for covariance=raw/(covariance at lag 0),
+ 'none' for covariance=raw
+ 'none' is the default.
+
+ Returns the covariance for each lag in the range, plus an
+ optional vector of lags.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 55
+ usage: [c, lag] = xcov (X [, Y] [, maxlag] [, scale])
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 12
+zerocrossing
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 186
+ -- Function File: X0 = zerocrossing (X, Y)
+ Estimates the points at which a given waveform y=y(x) crosses the
+ x-axis using linear interpolation.
+
+ See also: fzero, roots
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 80
+Estimates the points at which a given waveform y=y(x) crosses the
+x-axis using l
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 6
+zp2sos
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 1179
+ -- Function File: [SOS, G] = zp2sos (Z, P)
+ Convert filter poles and zeros to second-order sections.
+
+ INPUTS:
+ * Z = column-vector containing the filter zeros
+ * P = column-vector containing the filter poles
+ * G = overall filter gain factor
+
+ RETURNED:
+ * SOS = matrix of series second-order sections, one per row:
+ SOS = [B1.' A1.'; ...; BN.' AN.'], where
+ `B1.'==[b0 b1 b2] and A1.'==[1 a1 a2]' for section 1, etc.
+ b0 must be nonzero for each section.
+ See `filter()' for documentation of the second-order
+ direct-form filter coefficients Bi and %Ai, i=1:N.
+
+ * BSCALE is an overall gain factor that effectively scales any
+ one of the Bi vectors.
+
+ EXAMPLE:
+ [z,p,g] = tf2zp([1 0 0 0 0 1],[1 0 0 0 0 .9]);
+ [sos,g] = zp2sos(z,p,g)
+
+ sos =
+ 1.0000 0.6180 1.0000 1.0000 0.6051 0.9587
+ 1.0000 -1.6180 1.0000 1.0000 -1.5843 0.9587
+ 1.0000 1.0000 0 1.0000 0.9791 0
+
+ g =
+ 1
+
+ See also: sos2pz sos2tf tf2sos zp2tf tf2zp
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 56
+Convert filter poles and zeros to second-order sections.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 5
+zp2ss
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 556
+ -- Function File: [A, B, C, D] = zp2ss (ZER, POL, K)
+ Conversion from zero / pole to state space.
+
+ *Inputs*
+ ZER
+ POL
+ Vectors of (possibly) complex poles and zeros of a transfer
+ function. Complex values must come in conjugate pairs (i.e.,
+ x+jy in ZER means that x-jy is also in ZER).
+
+ K
+ Real scalar (leading coefficient).
+
+ *Outputs*
+ A
+ B
+ C
+ D
+ The state space system, in the form:
+ .
+ x = Ax + Bu
+ y = Cx + Du
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 43
+Conversion from zero / pole to state space.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 5
+zp2tf
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 326
+ -- Function File: [NUM, DEN] = zp2tf (ZER, POL, K)
+ Converts zeros / poles to a transfer function.
+
+ *Inputs*
+ ZER
+ POL
+ Vectors of (possibly complex) poles and zeros of a transfer
+ function. Complex values must appear in conjugate pairs.
+
+ K
+ Real scalar (leading coefficient).
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 46
+Converts zeros / poles to a transfer function.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 6
+zplane
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 1223
+ usage: zplane(b [, a]) or zplane(z [, p])
+
+ Plot the poles and zeros. If the arguments are row vectors then they
+ represent filter coefficients (numerator polynomial b and denominator
+ polynomial a), but if they are column vectors or matrices then they
+ represent poles and zeros.
+
+ This is a horrid interface, but I didn't choose it; better would be
+ to accept b,a or z,p,g like other functions. The saving grace is
+ that poly(x) always returns a row vector and roots(x) always returns
+ a column vector, so it is usually right. You must only be careful
+ when you are creating filters by hand.
+
+ Note that due to the nature of the roots() function, poles and zeros
+ may be displayed as occurring around a circle rather than at a single
+ point.
+
+ The transfer function is
+
+ B(z) b0 + b1 z^(-1) + b2 z^(-2) + ... + bM z^(-M)
+ H(z) = ---- = --------------------------------------------
+ A(z) a0 + a1 z^(-1) + a2 z^(-2) + ... + aN z^(-N)
+
+ b0 (z - z1) (z - z2) ... (z - zM)
+ = -- z^(-M+N) ------------------------------
+ a0 (z - p1) (z - p2) ... (z - pN)
+
+ The denominator a defaults to 1, and the poles p defaults to [].
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 43
+ usage: zplane(b [, a]) or zplane(z [, p])
+
+
+
+
+
+
git://git.creatis.insa-lyon.fr / CreaPhase.git / blobdiff