lazy_lpc
Module¶
Linear Predictive Coding (LPC) module
Summary of module contents:
Name  Description 

ParCorError  Error when trying to find the partial correlation coefficients (reflection coefficients) and there’s no way to find them. 
toeplitz  Find the toeplitz matrix as a list of lists given its first line/column. 
levinson_durbin  Solve the YuleWalker linear system of equations. 
lpc  This is a StrategyDict instance object called lpc .
Strategies stored: 5. 
parcor  Find the partial correlation coefficients (PARCOR), or reflection coefficients, relative to the lattice implementation of a given LTI FIR LinearFilter with a constant denominator (i.e., LPC analysis filter, or any filter without feedback). 
parcor_stable  Tests whether the given filter is stable or not by using the partial correlation coefficients (reflection coefficients) of the given filter. 
lsf  Find the Line Spectral Frequencies (LSF) from a given FIR filter. 
lsf_stable  Tests whether the given filter is stable or not by using the Line Spectral Frequencies (LSF) of the given filter. Needs NumPy. 

exception
ParCorError
[source]¶ Bases:
ZeroDivisionError
Error when trying to find the partial correlation coefficients (reflection coefficients) and there’s no way to find them.

levinson_durbin
(acdata, order=None)[source]¶ Solve the YuleWalker linear system of equations.
They’re given by:
\[R . a = r\]where \(R\) is a simmetric Toeplitz matrix where each element are lags from the given autocorrelation list. \(R\) and \(r\) are defined (Python indexing starts with zero and slices don’t include the last element):
\[ \begin{align}\begin{aligned}R[i][j] = acdata[abs(j  i)]\\r = acdata[1 : order + 1]\end{aligned}\end{align} \]Parameters:  acdata – Autocorrelation lag list, commonly the
acorr
function output.  order – The order of the resulting ZFilter object. Defaults to
len(acdata)  1
.
Returns: A FIR filter, as a ZFilter object. The mean squared error over the given data (variance of the white noise) is in its “error” attribute.
See also
 Examples:
>>> data = [2, 2, 0, 0, 1, 1, 0, 0, 1, 1] >>> acdata = acorr(data) >>> acdata [12, 6, 0, 3, 6, 3, 0, 2, 4, 2] >>> ldfilt = levinson_durbin(acorr(data), 3) >>> ldfilt 1  0.625 * z^1 + 0.25 * z^2 + 0.125 * z^3 >>> ldfilt.error # Squared! See lpc for more information about this 7.875
The LevinsonDurbin algorithm used to solve the equations needs \(O(order^2)\) floating point operations.
 acdata – Autocorrelation lag list, commonly the

parcor
(fir_filt)[source]¶ Find the partial correlation coefficients (PARCOR), or reflection coefficients, relative to the lattice implementation of a given LTI FIR LinearFilter with a constant denominator (i.e., LPC analysis filter, or any filter without feedback).
Parameters: fir_filt – A ZFilter object, causal, LTI and with a constant denominator. Returns: A generator that results in each partial correlation coefficient from iterative decomposition, reversing the LevinsonDurbin algorithm.  Examples:
>>> filt = levinson_durbin([1, 2, 3, 4, 5, 3, 2, 1]) >>> filt 1  0.275 * z^1  0.275 * z^2  0.4125 * z^3 + 1.5 * z^4  0.9125 * z^5  0.275 * z^6  0.275 * z^7 >>> round(filt.error, 4) 1.9125 >>> k_generator = parcor(filt) >>> k_generator <generator object parcor at ...> >>> [round(k, 7) for k in k_generator] [0.275, 0.3793103, 1.4166667, 0.2, 0.25, 0.3333333, 2.0]
See also
levinson_durbin
 LevinsonDurbin algorithm for solving YuleWalker equations (Toeplitz matrix linear system).

parcor_stable
(filt)[source]¶ Tests whether the given filter is stable or not by using the partial correlation coefficients (reflection coefficients) of the given filter.
Parameters: filt – A LTI filter as a LinearFilter object. Returns: A boolean that is true only when all correlation coefficients are inside the unit circle. Critical stability (i.e., when outer coefficient has magnitude equals to one) is seem as an instability, and returns False. See also
parcor
 Partial correlation coefficients generator.
lsf_stable
 Tests filter stability with Line Spectral Frequencies (LSF) values.

lsf
(fir_filt)[source]¶ Find the Line Spectral Frequencies (LSF) from a given FIR filter.
Parameters: filt – A LTI FIR filter as a LinearFilter object. Returns: A tuple with all LSFs in rad/sample, alternating from the forward prediction and backward prediction filters, starting with the lowest LSF value.

lsf_stable
(filt)[source]¶ Tests whether the given filter is stable or not by using the Line Spectral Frequencies (LSF) of the given filter. Needs NumPy.
Parameters: filt – A LTI filter as a LinearFilter object. Returns: A boolean that is true only when the LSF values from forward and backward prediction filters alternates. Critical stability (both forward and backward filters has the same LSF value) is seem as an instability, and returns False. See also
lsf
 Gets the Line Spectral Frequencies from a filter. Needs NumPy.
parcor_stable
 Tests filter stability with partial correlation coefficients (reflection coefficients).
lazy_lpc.lpc
StrategyDict¶
This is a StrategyDict instance object called
lpc
. Strategies stored: 5.
Strategy lpc.autocor (Default).
Aliases available are lpc.acorr
, lpc.autocorrelation
, lpc.auto_correlation
.
Docstring starts with:
Find the Linear Predictive Coding (LPC) coefficients as a ZFilter object, the analysis whitening filter. This implementation uses the autocorrelation method, using the LevinsonDurbin algorithm or Numpy pseudoinverse for linear system solving, when needed.
Strategy lpc.covar.
Aliases available are lpc.cov
, lpc.covariance
, lpc.ncovar
, lpc.ncov
, lpc.ncovariance
.
Docstring starts with:
Find the Linear Predictive Coding (LPC) coefficients as a ZFilter object, the analysis whitening filter. This implementation uses the covariance method, assuming a zeromean stochastic process, using numpy.linalg.pinv as a linear system solver.
Strategy lpc.kautocor.
Aliases available are lpc.kacorr
, lpc.kautocorrelation
, lpc.kauto_correlation
.
Docstring starts with:
Find the Linear Predictive Coding (LPC) coefficients as a ZFilter object, the analysis whitening filter. This implementation uses the autocorrelation method, using the LevinsonDurbin algorithm.
Strategy lpc.kcovar.
Aliases available are lpc.kcov
, lpc.kcovariance
.
Docstring starts with:
Find the Linear Predictive Coding (LPC) coefficients as a ZFilter object, the analysis whitening filter. This implementation is based on the covariance method, assuming a zeromean stochastic process, finding the coefficients iteratively and greedily like the lattice implementation in LevinsonDurbin algorithm, although the lag matrix found from the given block don’t have to be toeplitz. Slow, but this strategy don’t need NumPy.
Strategy lpc.nautocor.
Aliases available are lpc.nacorr
, lpc.nautocorrelation
, lpc.nauto_correlation
.
Docstring starts with:
Find the Linear Predictive Coding (LPC) coefficients as a ZFilter object, the analysis whitening filter. This implementation uses the autocorrelation method, using numpy.linalg.pinv as a linear system solver.
Note
This docstring is selfgenerated, see the StrategyDict class and the strategies docs for more details.

covar
(blk, order=None)¶ Find the Linear Predictive Coding (LPC) coefficients as a ZFilter object, the analysis whitening filter. This implementation uses the covariance method, assuming a zeromean stochastic process, using numpy.linalg.pinv as a linear system solver.

autocor
(blk, order=None)¶ Find the Linear Predictive Coding (LPC) coefficients as a ZFilter object, the analysis whitening filter. This implementation uses the autocorrelation method, using the LevinsonDurbin algorithm or Numpy pseudoinverse for linear system solving, when needed.
Parameters:  blk – An iterable with welldefined length. Don’t use this function with Stream objects!
 order – The order of the resulting ZFilter object. Defaults to
len(blk)  1
.
Returns: A FIR filter, as a ZFilter object. The mean squared error over the given block is in its “error” attribute.
Hint
See
lpc.kautocor
example, which should apply equally for this strategy.See also
levinson_durbin
 LevinsonDurbin algorithm for solving YuleWalker equations (Toeplitz matrix linear system).
lpc.nautocor
 LPC coefficients from linear system solved with Numpy pseudoinverse.
lpc.kautocor
 LPC coefficients obtained with LevinsonDurbin algorithm.

kcovar
(blk, order=None)¶ Find the Linear Predictive Coding (LPC) coefficients as a ZFilter object, the analysis whitening filter. This implementation is based on the covariance method, assuming a zeromean stochastic process, finding the coefficients iteratively and greedily like the lattice implementation in LevinsonDurbin algorithm, although the lag matrix found from the given block don’t have to be toeplitz. Slow, but this strategy don’t need NumPy.

kautocor
(blk, order=None)¶ Find the Linear Predictive Coding (LPC) coefficients as a ZFilter object, the analysis whitening filter. This implementation uses the autocorrelation method, using the LevinsonDurbin algorithm.
Parameters:  blk – An iterable with welldefined length. Don’t use this function with Stream objects!
 order – The order of the resulting ZFilter object. Defaults to
len(blk)  1
.
Returns: A FIR filter, as a ZFilter object. The mean squared error over the given block is in its “error” attribute.
 Examples:
>>> data = [1, 0, 1, 0] * 4 >>> len(data) # Small data 16 >>> filt = lpc.kautocor(data, 2) >>> filt # The analysis filter 1 + 0.875 * z^2 >>> filt.numerator # List of coefficients [1, 0.0, 0.875] >>> filt.error # Prediction error (squared!) 1.875
See also
levinson_durbin
 LevinsonDurbin algorithm for solving YuleWalker equations (Toeplitz matrix linear system).
lpc.autocor
 LPC coefficients by using one of the autocorrelation method strategies.
lpc.nautocor
 LPC coefficients from linear system solved with Numpy pseudoinverse.

nautocor
(blk, order=None)¶ Find the Linear Predictive Coding (LPC) coefficients as a ZFilter object, the analysis whitening filter. This implementation uses the autocorrelation method, using numpy.linalg.pinv as a linear system solver.
Parameters:  blk – An iterable with welldefined length. Don’t use this function with Stream objects!
 order – The order of the resulting ZFilter object. Defaults to
len(blk)  1
.
Returns: A FIR filter, as a ZFilter object. The mean squared error over the given block is in its “error” attribute.
Hint
See
lpc.kautocor
example, which should apply equally for this strategy.See also
lpc.autocor
 LPC coefficients by using one of the autocorrelation method strategies.
lpc.kautocor
 LPC coefficients obtained with LevinsonDurbin algorithm.