Matlab Design Adaptive Filter

Adaptive Filtering

Implementation guideline — Use DSP System Toolbox System objects to implement adaptive filters. Do not implement manual weight-update loops.

When to Use

• System identification — Model unknown FIR or IIR systems online

• Noise or interference cancellation — Recover signals from noise-corrupted measurement

• Echo cancellation — Suppress acoustic or line echo

• Active noise control — Feedforward ANC with secondary path

• Inverse system identification — Equalization and deconvolution

• Adaptive prediction — Linear prediction and speech coding

• Algorithm evaluation — Compare adaptive filter algorithm performance

• Migrating from deprecated adaptfilt.* objects — Replaced by dsp.*Filter System objects (removed in R2020a)

• Any task involving dsp.LMSFilter, dsp.RLSFilter, dsp.FilteredXLMSFilter, dsp.FrequencyDomainAdaptiveFilter, dsp.AffineProjectionFilter, or maxstep()

When NOT to Use

• Static (non-adaptive) FIR/IIR filter design — Use matlab-design-digital-filter

• Kalman filtering or state estimation — Use Control System Toolbox

• Deep learning-based denoising — Use Deep Learning Toolbox

• Simulink adaptive filter blocks — Use when working in Simulink (different modeling workflow)

Workflow

Every adaptive filtering task follows this five-step workflow:

1. Analyze the Problem

Before writing code, determine:

• Topology — System identification, inverse system identification, noise cancellation, ANC, or prediction?

• Signal characteristics — White or colored input? Stationary or time-varying?

• Constraints — Filter length, latency budget, computational cost, real-time?

• Filter length — Match or slightly exceed the unknown system order

2. Select Object and Method

Use the routing table to pick the right System object:

For detailed selection guidance, see references/object-selection.md.

3. Configure

Step size (critical for stability):

lms = dsp.LMSFilter(Length=L, Method="Normalized LMS");
[muMax, muMaxMSE] = maxstep(lms, x);
lms.StepSize = 0.3 * muMaxMSE;

maxstep() is available only for:

• dsp.LMSFilter (Methods: 'LMS', 'Normalized LMS', 'Sign-Error LMS')

• dsp.BlockLMSFilter

For all other objects, see references/maxstep-reference.md.

Filter length: Set to unknown system order + 1 (or slightly longer if order is uncertain).

4. Run in Streaming Loop

All adaptive filter System objects process data frame-by-frame:

for k = 1:numFrames
    xFrame = x((k-1)*frameSize+1 : k*frameSize);
    dFrame = d((k-1)*frameSize+1 : k*frameSize);
    [y, err, wts] = lms(xFrame, dFrame);
end

In simulation, use dsp.FIRFilter or dsp.IIRFilter for the unknown system. These objects automatically maintain internal filter state across frames.

5. Verify Convergence and Extract Weights

Weight extraction differs by object and is a common source of errors:

Important: dsp.LMSFilter does NOT have a .Coefficients property. The third output argument is the only way to access weights.

For full details, see references/weight-extraction.md.

Key Functions

Patterns

System Identification

unknownSys = dsp.FIRFilter(Numerator=fir1(31, 0.4));
lms = dsp.LMSFilter(Length=32, Method="Normalized LMS");
[muMax, muMaxMSE] = maxstep(lms, randn(1000, 1));
lms.StepSize = 0.3 * muMaxMSE;

for k = 1:numFrames
    xFrame = randn(frameSize, 1);
    dFrame = unknownSys(xFrame);
    [~, ~, wts] = lms(xFrame, dFrame);
end

Active Noise Control (Two-Stage)

% Stage 1: Estimate the secondary path
estFilter = dsp.LMSFilter(Length=secPathLen, Method="Normalized LMS");
[~, ~, secPathEst] = estFilter(probeSignal, secPathOutput);

% Stage 2: Configure the FxLMS controller
fxlms = dsp.FilteredXLMSFilter(Length=ctrlLen, ...
    SecondaryPathCoefficients=secPathTrue, ...
    SecondaryPathEstimate=secPathEst.');
[y, e] = fxlms(reference, errorMic);

See references/fxlms-filter.md for the full ANC workflow.

Low-Latency Long Filter (Partitioned FDAF)

Use partitioned FDAF when you need a long adaptive filter with low processing latency.

fdaf = dsp.FrequencyDomainAdaptiveFilter( ...
    Length=2048, ...
    BlockLength=128, ...
    Method="Partitioned constrained FDAF", ...
    StepSize=0.5);

for k = 1:numBlocks
    xBlock = x((k-1)*128+1 : k*128);
    dBlock = d((k-1)*128+1 : k*128);
    [y, e] = fdaf(xBlock, dBlock);
end
% Latency = BlockLength/fs = 128/16000 = 8 ms

See references/fdaf-filter.md for method strings and FFTCoefficients extraction.

Freeze Adaptation (Stop Learning, Keep Filtering)

% dsp.LMSFilter — use AdaptInputPort
lms = dsp.LMSFilter(Length=32, AdaptInputPort=true);
adaptFlag = true;
for k = 1:numFrames
    if k > freezeFrame, adaptFlag = false; end
    [y, e, w] = lms(xFrame, dFrame, adaptFlag);
end

For dsp.FrequencyDomainAdaptiveFilter, use LockCoefficients instead. This object does not support AdaptInputPort. See references/fdaf-filter.md.

Conventions

• Always use dsp.*Filter System objects — Never implement weight-update loops manually

• Always call maxstep() for step size when available (LMS, NLMS, Sign-Error, BlockLMS)

• Always use AdaptInputPort=true for freeze/adapt control — Never wrap in if/else

• Always use dsp.FIRFilter for unknown system simulation — It maintains state across frames

• Never access .Coefficients on dsp.LMSFilter — It doesn't exist; use third output

• Never access .Coefficients on dsp.FrequencyDomainAdaptiveFilter — Use .FFTCoefficients + IFFT

• Never use adaptfilt.* functions (adaptfilt.lms, adaptfilt.nlms, adaptfilt.rls, etc.) — The entire package was removed in R2020a and will error. Always use dsp.*Filter System objects.

• Prefer 'Normalized LMS' over 'LMS' as the default method — Robust to input power variations

• Prefer 'Constrained FDAF' over 'Unconstrained FDAF' — Prevents spectral leakage

Common Mistakes

References

• Object Selection Guide — Full decision matrix

• dsp.LMSFilter — methods, maxstep, AdaptInputPort, weights

• dsp.RLSFilter — ForgettingFactor, methods, coefficients

• dsp.FilteredXLMSFilter — ANC workflow, secondary path properties

• dsp.FrequencyDomainAdaptiveFilter — Partitioned mode, FFTCoefficients

• Other Filters — AP, BlockLMS, Lattice, FTF

• Weight Extraction — per-object coefficient access

• maxstep Reference — Compatibility and fallbacks

Copyright 2026 The MathWorks, Inc.