adaptfilt.fdaf - FIR adaptive filter that uses frequency-domain with bin step size normalization

Syntax

ha = adaptfilt.fdaf(l,step,leakage,delta,lambda,blocklen,offset,...coeffs,states)

Description

ha = adaptfilt.fdaf(l,step,leakage,delta,lambda,blocklen, offset,...coeffs,states) constructs a frequency-domain FIR adaptive filter ha with bin step size normalization. If you omit all the input arguments you create a default object with l = 10 and step = 1.

Input Arguments

Entries in the following table describe the input arguments for adaptfilt.fdaf.

Input Argument	Description
`l`	Adaptive filter length (the number of coefficients or taps). l must be a positive integer; it defaults to 10 when you omit the argument.
`step`	Step size of the adaptive filter. This is a scalar and should lie in the range (0,1]. `step` defaults to 1.
`leakage`	Leakage parameter of the adaptive filter. If this parameter is set to a value between zero and one, you implement a leaky FDAF algorithm. `leakage` defaults to 1 — no leakage provided in the algorithm.
`delta`	Initial common value of all of the FFT input signal powers. Its initial value should be positive. `delta` defaults to 1.
`lambda`	Specifies the averaging factor used to compute the exponentially-windowed FFT input signal powers for the coefficient updates. `lambda` should lie in the range (0,1]. `lambda` defaults to 0.9.
`blocklen`	Block length for the coefficient updates. This must be a positive integer. For faster execution, (`blocklen` + l) should be a power of two. `blocklen` defaults to l.
`offset`	Offset for the normalization terms in the coefficient updates. Use this to avoid divide by zeros or by very small numbers when any of the FFT input signal powers become very small. `offset` defaults to zero.
`coeffs`	Initial time-domain coefficients of the adaptive filter. `coeff` should be a length `l` vector. The adaptive filter object uses these coefficients to compute the initial frequency-domain filter coefficients via an FFT computed after zero-padding the time-domain vector by the `blocklen`.
`states`	The adaptive filter states. `states` defaults to a zero vector that has length equal to l.

Properties

Since your adaptfilt.fdaf filter is an object, it has properties that define its behavior in operation. Note that many of the properties are also input arguments for creating adaptfilt.fdaf objects. To show you the properties that apply, this table lists and describes each property for the adaptfilt.fdaf filter object.

Name	Range	Description
`Algorithm`	None	Defines the adaptive filter algorithm the object uses during adaptation.
`AvgFactor`	(0, 1]	Specifies the averaging factor used to compute the exponentially-windowed FFT input signal powers for the coefficient updates. Same as the input argument `lambda`.
`BlockLength`	Any integer	Block length for the coefficient updates. This must be a positive integer. For faster execution, (`blocklen` + l) should be a power of two. `blocklen` defaults to l.
`FFTCoefficients`		Stores the discrete Fourier transform of the filter coefficients in `coeffs`.
`FFTStates`		States for the FFT operation.
`FilterLength`	Any positive integer	Reports the length of the filter, the number of coefficients or taps.
`Leakage`		Leakage parameter of the adaptive filter. if this parameter is set to a value between zero and one, you implement a leaky FDAF algorithm. `leakage` defaults to 1 — no leakage provided in the algorithm.
`Offset`	Any positive real value	Offset for the normalization terms in the coefficient updates. Use this to avoid dividing by zero or by very small numbers when any of the FFT input signal powers become very small. `offset` defaults to zero.
`PersistentMemory`	`false` or `true`	Determine whether the filter states 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 state that the filter changes during processing. States that the filter does not change are not affected. Defaults to `false`.
`Power`		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.
`StepSize`	Any scalar from zero to one, inclusive	Specifies the step size taken between filter coefficient updates

Examples

Quadrature Phase Shift Keying (QPSK) adaptive equalization using 1024 iterations of a 32-coefficient FIR filter. After this example code, a figure demonstrates the equalization results.

D = 16;                         % Number of samples of delay
b  = exp(1j*pi/4)*[-0.7 1];      % Numerator coefficients of channel
a  = [1 -0.7];                  % Denominator coefficients of channel
ntr= 1024;                      % Number of iterations
s  = sign(randn(1,ntr+D))+1j*sign(randn(1,ntr+D));  %QPSK signal
n  = 0.1*(randn(1,ntr+D) + 1j*randn(1,ntr+D));        % Noise signal
r  = filter(b,a,s)+n;            % Received signal
x  = r(1+D:ntr+D);               % Input signal (received signal)
d  = s(1:ntr);                   % Desired signal (delayed QPSK signal)
del = 1;                         % Initial FFT input powers
mu  = 0.1;                       % Step size
lam = 0.9;                       % Averaging factor
ha = adaptfilt.fdaf(32,mu,1,del,lam);
[y,e] = filter(ha,x,d);
subplot(2,2,1); plot(1:ntr,real([d;y;e])); title('In-Phase Components');
legend('Desired','Output','Error');
xlabel('Time Index'); ylabel('signal value');
subplot(2,2,2); plot(1:ntr,imag([d;y;e])); title('Quadrature Components');
legend('Desired','Output','Error');
xlabel('Time Index'); ylabel('signal value');
subplot(2,2,3); plot(x(ntr-100:ntr),'.'); axis([-3 3 -3 3]);
title('Received Signal Scatter Plot'); axis('square');
xlabel('Real[x]'); ylabel('Imag[x]'); grid on;
subplot(2,2,4); plot(y(ntr-100:ntr),'.'); axis([-3 3 -3 3]);
title('Equalized Signal Scatter Plot'); axis('square');
xlabel('Real[y]'); ylabel('Imag[y]'); grid on;

References

Shynk, J.J.,"Frequency-Domain and Multirate Adaptive Filtering," IEEE Signal Processing Magazine, vol. 9, no. 1, pp. 14-37, Jan. 1992

Search MATLAB Documentation
R2012a Documentation → DSP System Toolbox
View documentation for other releases	Learn more about DSP System Toolbox