adaptfilt.pbufdaf - Partitioned block unconstrained frequency-domain adaptive filter

Syntax

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

Description

ha = adaptfilt.pbufdaf(l,step,leakage,delta,lambda, blocklen,...offset,coeffs,states) constructs a partitioned block unconstrained frequency-domain FIR adaptive filter ha with bin step size normalization.

Input Arguments

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

Input Argument	Description
`l`	Adaptive filter length (the number of coefficients or taps) and it must be a positive integer. L defaults to 10.
`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. When you set this argument to a value between zero and one, a leaky version of the PBFDAF algorithm is implemented. `leakage` defaults to 1 — no leakage.
`delta`	Initial common value of all of the FFT input signal powers. Its initial value should be positive. delta defaults to 1.
`lambda`	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 such that (`l/blocklen`) is also an integer. For faster execution, `blocklen` should be a power of two. `blocklen` defaults to two.
`offset`	Offset for the normalization terms in the coefficient updates. This can be useful to avoid divide by zeros conditions, or dividing by very small numbers, if any of the FFT input signal powers become very small. `offset` defaults to zero.
`coeffs`	Initial time-domain coefficients of the adaptive filter. It should be a vector of length `l`. The PBFDAF algorithm uses these coefficients to compute the initial frequency-domain filter coefficient matrix via FFTs.
`states`	Specifies the filter initial conditions. `states` defaults to a zero vector of length `l`.

Properties

Since your adaptfilt.pbufdaf 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.pbufdaf objects. To show you the properties that apply, this table lists and describes each property for the filter object.

Name	Range	Description
`Algorithm`	None	Defines the adaptive filter algorithm the object uses during adaptation
`AvgFactor`		Averaging factor used to compute the exponentially windowed FFT input signal powers for the coefficient updates. `AvgFactor` should lie in the range (0,1]. `AvgFactor` defaults to 0.9. Called `lambda` as an input argument.
`BlockLength`		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.
`FilterLength`	Any positive integer	Reports the length of the filter, the number of coefficients or taps
`FFTCoefficients`		Stores the discrete Fourier transform of the filter coefficients in `coeffs`.
`FFTStates`		States for the FFT operation.
`Leakage`	0 to 1	Leakage parameter of the adaptive filter. When you set this argument to a value between zero and one, a leaky version of the PBFDAF algorithm is implemented. `leakage` defaults to 1 — no leakage.
`Offset`		Offset for the normalization terms in the coefficient updates. This can be useful to avoid divide by zeros conditions, or dividing by very small numbers, if any of the FFT input signal powers become very small.v`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`	2*`l` element vector	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`	0 to 1	Step size of the adaptive filter. This is a scalar and should lie in the range (0,1]. `step` defaults to 1.

Examples

Demonstrating Quadrature Phase Shift Keying (QPSK) adaptive equalization using a 32-coefficient FIR filter. To perform the equalization, this example runs for 1000 iterations.

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= 1000;                 % Number of iterations
s  = sign(randn(1,ntr+D))+1j*sign(randn(1,ntr+D)); % Baseband 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
N   = 8;                       % Block size
ha = adaptfilt.pbufdaf(32,mu,1,del,lam,N);
[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;

You can compare this algorithm to another, such as the pbfdaf version. Use the same example of QPSK adaptation. The following figure shows the results.

References

So, J.S. and K.K. Pang, "Multidelay Block Frequency Domain Adaptive Filter," IEEE Trans. Acoustics, Speech, and Signal Processing, vol. 38, no. 2, pp. 373-376, February 1990

Paez Borrallo, J.M. and M.G. Otero, "On The Implementation of a Partitioned Block Frequency Domain Adaptive Filter (PBFDAF) for Long Acoustic Echo Cancellation," Signal Processing, vol. 27, no. 3, pp. 301-315, June 1992

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