adaptfilt
objects will be removed in a
future release. Refer to the reference page for a specific adaptfilt
object
to see its recommended replacement.
The following table summarizes the adaptive filter properties and provides a brief description of each. Full descriptions of each property, in alphabetical order, are given in the subsequent section.
Property  Description 

 Reports the algorithm the object uses for adaptation.
When you construct your adaptive filter object, this property is set
automatically by the constructor, such as 
 Averaging factor used to compute the exponentiallywindowed
estimates of the powers in the transformed signal bins for the coefficient
updates. 
 Returns the minimum meansquared prediction error. Refer to [3] in the bibliography for details about linear prediction. 
 Returns the predicted samples generated during adaptation. Refer to [3] in the bibliography for details about linear prediction. 
 Block length for the coefficient updates. This must be
a positive integer such that ( 
 Vector containing the initial filter coefficients. It
must be a length 
 Conversion factor defaults to the matrix [1 1] that
specifies softconstrained initialization. This is the 
 Update delay given in time samples. This scalar should
be a positive integer—negative delays do not work. 
 Desired signal states of the adaptive filter. 
 Vector of the epsilon values of the adaptive filter. 
 Vector of the adaptive filter error states. 
 Stores the discrete Fourier transform of the filter coefficients
in 
 Stores the states of the FFT of the filter coefficients during adaptation. 
 Vector of filtered input states with length equal to 
 Contains the length of the filter. Note that this is not the filter order. Filter length is 1 greater than filter order. Thus a filter with length equal to 10 has filter order equal to 9. 
 Determines how the RLS adaptive filter uses past data in each iteration. You use the forgetting factor to specify whether old data carries the same weight in the algorithm as more recent data. 
 Returns the minimum meansquared prediction error in the forward direction. Refer to [3] in the bibliography for details about linear prediction. 
 Contains the predicted values for samples during adaptation. Compare these to the actual samples to get the error and power. 
 Softconstrained initialization factor. This scalar should
be positive and sufficiently large to prevent an excessive number
of Kalman gain rescues. Called 
 Uppertriangular Cholesky (square root) factor of the
input covariance matrix. Initialize this matrix with a positive definite
upper triangular matrix. Dimensions are 
 Empty when you construct the object, this gets populated after you run the filter. 
 Contains the states of the Kalman gain updates during adaptation. 
 Contains the setting for leakage in the adaptive filter algorithm. Using a leakage factor that is not 1 forces the weights to adapt even when they have found the minimum error solution. Forcing the adaptation can improve the numerical performance of the LMS algorithm. 
 Contains the offset covariance matrix. 
 Specifies an optional offset for the denominator of the step size normalization term. You must specify offset to be a scalar greater than or equal to zero. Nonzero offsets can help avoid a dividebynearzero condition that causes errors. 
 A vector of 2* 
 Projection order of the affine projection algorithm. 
 Coefficients determined for the reflection portion of the filter during adaptation. 
 Size of the steps used to determine the reflection coefficients. 
 Specifies whether to reset the filter states and memory before each filtering operation. Lets you decide whether your filter retains states and coefficients from previous filtering runs. 
 A vector that contains the coefficient values of your secondary path from the output actuator to the error sensor. 
 An estimate of the secondary path filter model. 
 The states of the secondary path filter, the unknown system. 
 Uppertriangular Cholesky (square root) factor of the input covariance matrix. Initialize this matrix with a positive definite upper triangular matrix. 
 Square root of the inverse of the sliding window input signal covariance matrix. This square matrix should be fullranked. 
 Vector of the adaptive filter states. 
 Reports the size of the step taken between iterations
of the adaptive filter process. Each 
 Block length of the sliding window. This integer must
be at least as large as the filter length. 
Like dfilt
objects, adaptfilt
objects
have properties that govern their behavior and store some of the results
of filtering operations. The following pages list, in alphabetical
order, the name of every property associated with adaptfilt
objects.
Note that not all adaptfilt
objects have all of
these properties. To view the properties of a particular adaptive
filter, such as an adaptfilt.bap
filter, use get
with the object handle, like this:
ha = adaptfilt.bap(32,0.5,4,1.0); get(ha) PersistentMemory: false Algorithm: 'Block Affine Projection FIR Adaptive Filter' FilterLength: 32 Coefficients: [1x32 double] States: [35x1 double] StepSize: 0.5000 ProjectionOrder: 4 OffsetCov: [4x4 double]
get
shows you the properties for ha
and
the values for the properties. Entering the object handle returns
the same values and properties without the formatting of the list
and the more familiar property names.
Reports the algorithm the object uses for adaptation. When you construct you adaptive filter object, this property is set automatically. You cannot change the value—it is read only.
Averaging factor used to compute the exponentiallywindowed
estimates of the powers in the transformed signal bins for the coefficient
updates. AvgFactor
should lie between zero and
one. For default filter objects, AvgFactor
equals
(1  step
). lambda
is the input
argument that represent AvgFactor
Returns the minimum meansquared prediction error in the backward direction. Refer to [3] in the bibliography for details about linear prediction.
When you use an adaptive filter that does backward prediction,
such as adaptfilt.ftf
, one property
of the filter contains the backward prediction coefficients for the
adapted filter. With these coefficient, the forward coefficients,
and the system under test, you have the full set of knowledge of how
the adaptation occurred. Two values stored in properties compose the BkwdPrediction
property:
Coefficients, which contains the coefficients of the system under test, as determined using backward predictions process.
Error, which is the difference between the filter
coefficients determined by backward prediction and the actual coefficients
of the sample filter. In this example, adaptfilt.ftf
identifies
the coefficients of an unknown FIR system.
x = randn(1,500); % Input to the filter b = fir1(31,0.5); % FIR system to be identified n = 0.1*randn(1,500); % Observation noise signal d = filter(b,1,x)+n; % Desired signal N = 31; % Adaptive filter order lam = 0.99; % RLS forgetting factor del = 0.1; % Softconstrained initialization factor ha = adaptfilt.ftf(32,lam,del); [y,e] = filter(ha,x,d); ha ha = Algorithm: 'Fast Transversal LeastSquares Adaptive Filter' FilterLength: 32 Coefficients: [1x32 double] States: [31x1 double] ForgettingFactor: 0.9900 InitFactor: 0.1000 FwdPrediction: [1x1 struct] BkwdPrediction: [1x1 struct] KalmanGain: [32x1 double] ConversionFactor: 0.7338 KalmanGainStates: [32x1 double] PersistentMemory: false ha.coefficients ans = Columns 1 through 8 0.0055 0.0048 0.0045 0.0146 0.0009 0.0002 0.0019 0.0008 Columns 9 through 16 0.0142 0.0226 0.0234 0.0421 0.0571 0.0807 0.1434 0.4620 Columns 17 through 24 0.4564 0.1532 0.0879 0.0501 0.0331 0.0361 0.0266 0.0220 Columns 25 through 32 0.0231 0.0026 0.0063 0.0079 0.0032 0.0082 0.0033 0.0065 ha.bkwdprediction ans = Coeffs: [1x32 double] Error: 82.3394 >> ha.bkwdprediction.coeffs ans = Columns 1 through 8 0.0067 0.0186 0.1114 0.0150 0.0239 0.0610 0.1120 0.1026 Columns 9 through 16 0.0093 0.0399 0.0045 0.0622 0.0997 0.0778 0.0646 0.0564 Columns 17 through 24 0.0775 0.0814 0.0057 0.0078 0.1271 0.0576 0.0037 0.0200 Columns 25 through 32 0.0246 0.0180 0.0033 0.1222 0.0302 0.0197 0.1162 0.0285
Block length for the coefficient updates. This must be a positive
integer such that (l/blocklen
) is also an integer.
For faster execution, blocklen
should be a power
of two. blocklen
defaults to two.
Vector containing the initial filter coefficients. It must be
a length l
vector where l
is
the number of filter coefficients. coeffs
defaults
to length l
vector of zeros when you do not provide
the argument for input.
Conversion factor defaults to the matrix [1 1] that specifies
softconstrained initialization. This is the gamma
input
argument for some of the fast transversal algorithms.
Update delay given in time samples. This scalar should be a
positive integer — negative delays do not work. delay
defaults
to 1 for most algorithms.
Desired signal states of the adaptive filter. dstates
defaults
to a zero vector with length equal to (blocklen

1) or (swblocklen
 1) depending on the algorithm.
Vector of the epsilon values of the adaptive filter. EpsilonStates
defaults
to a vector of zeros with (projectord
 1) elements.
Vector of the adaptive filter error states. ErrorStates
defaults
to a zero vector with length equal to (projectord

1).
Stores the discrete Fourier transform of the filter coefficients
in coeffs
.
Stores the states of the FFT of the filter coefficients during adaptation.
Vector of filtered input states with length equal to l

1.
Contains the length of the filter. Note that this is not the filter order. Filter length is 1 greater than filter order. Thus a filter with length equal to 10 has filter order equal to 9.
Determines how the RLS adaptive filter uses past data in each iteration. You use the forgetting factor to specify whether old data carries the same weight in the algorithm as more recent data.
This is a scalar and should lie in the range (0, 1]. It defaults
to 1. Setting forgetting factor =
1 denotes infinite
memory while adapting to find the new filter. Note that this is the lambda
input
argument.
Returns the minimum meansquared prediction error in the forward direction. Refer to [3] in the bibliography for details about linear prediction.
Contains the predicted values for samples during adaptation. Compare these to the actual samples to get the error and power.
Returns the softconstrained initialization factor. This scalar
should be positive and sufficiently large to prevent an excessive
number of Kalman gain rescues. delta
defaults to
one.
Uppertriangular Cholesky (square root) factor of the input
covariance matrix. Initialize this matrix with a positive definite
upper triangular matrix. Dimensions are l
byl
,
where l
is the filter length.
Empty when you construct the object, this gets populated after you run the filter.
Contains the states of the Kalman gain updates during adaptation.
Contains the setting for leakage in the adaptive filter algorithm. Using a leakage factor that is not 1 forces the weights to adapt even when they have found the minimum error solution. Forcing the adaptation can improve the numerical performance of the LMS algorithm.
Contains the offset covariance matrix.
Specifies an optional offset for the denominator of the step size normalization term. You must specify offset to be a scalar greater than or equal to zero. Nonzero offsets can help avoid a dividebynearzero condition that causes errors.
Use this to avoid dividing by zero or by very small numbers
when input signal amplitude becomes very small, or dividing by very
small numbers when any of the FFT input signal powers become very
small. offset
defaults to one.
A vector of 2*l
elements, each initialized
with the value delta
from the input arguments.
As you filter data, Power
gets updated by the
filter process.
Projection order of the affine projection algorithm. projectord
defines
the size of the input signal covariance matrix and defaults to two.
For adaptive filters that use reflection coefficients, this property stores them.
As the adaptive filter changes coefficient values during adaptation, the step size used between runs is stored here.
Determines whether the filter states and coefficients get restored to their starting values for each filtering operation. The starting values are the values in place when you create the filter.
PersistentMemory
returns to zero any property
value that the filter changes during processing. Property values that
the filter does not change are not affected. Defaults to false
.
A vector that contains the coefficient values of your secondary path from the output actuator to the error sensor.
An estimate of the secondary path filter model.
The states of the secondary path filter, the unknown system.
Uppertriangular Cholesky (square root) factor of the input covariance matrix. Initialize this matrix with a positive definite upper triangular matrix.
Square root of the inverse of the sliding window input signal covariance matrix. This square matrix should be fullranked.
Vector of the adaptive filter states. states
defaults
to a vector of zeros whose length depends on the chosen algorithm.
Usually the length is a function of the filter length l
and
another input argument to the filter object, such as projectord.
Reports the size of the step taken between iterations of the
adaptive filter process. Each adaptfilt
object
has a default value that best meets the needs of the algorithm.
Block length of the sliding window. This integer must be at
least as large as the filter length. swblocklength
defaults
to 16.
[1] Griffiths, L.J., A Continuously Adaptive Filter Implemented as a Lattice Structure, Proc. IEEE Int. Conf. on Acoustics, Speech, and Signal Processing, Hartford, CT, pp. 683686, 1977.
[2] Hayes, M.H., Statistical Digital Signal Processing and Modeling, John Wiley and Sons, 1996.
[3] Haykin, S., Adaptive Filter Theory, Third Edition, PrenticeHall, Inc., 1996.