Documentation |
FIR adaptive filter that uses block affine projection
ha = adaptfilt.bap(l,step,projectord,offset,coeffs,states)
ha = adaptfilt.bap(l,step,projectord,offset,coeffs,states) constructs a block affine projection FIR adaptive filter ha.
For information on how to run data through your adaptive filter object, see the Adaptive Filter Syntaxes section of the reference page for filter.
Entries in the following table describe the input arguments for adaptfilt.bap.
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 | Affine projection step size. This is a scalar that should be a value between zero and one. Setting step equal to one provides the fastest convergence during adaptation. step defaults to 1. |
projectord | Projection order of the affine projection algorithm. projectord defines the size of the input signal covariance matrix and defaults to two. |
offset | Offset for the input signal covariance matrix. You should initialize the covariance matrix to a diagonal matrix whose diagonal entries are equal to the offset you specify. offset should be positive. offset defaults to one. |
coeffs | Vector containing the initial filter coefficients. It must be a length l vector, the number of filter coefficients. coeffs defaults to length l vector of zeros when you do not provide the argument for input. |
states | Vector of the adaptive filter states. states defaults to a vector of zeros which has length equal to (l + projectord - 2). |
Since your adaptfilt.bap 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.bap objects. To show you the properties that apply, this table lists and describes each property for the affine projection filter object.
Name | Range | Description |
---|---|---|
Algorithm | None | Defines the adaptive filter algorithm the object uses during adaptation |
FilterLength | Any positive integer | Reports the length of the filter, the number of coefficients or taps |
ProjectionOrder | 1 to as large as needed. | Projection order of the affine projection algorithm. ProjectionOrder defines the size of the input signal covariance matrix and defaults to two. |
OffsetCov | Matrix of values | Contains the offset covariance matrix |
Coefficients | Vector of elements | Vector containing the initial filter coefficients. It must be a length l vector, the number of filter coefficients. coeffs defaults to length l vector of zeros when you do not provide the argument for input. |
States | Vector of elements, data type double | Vector of the adaptive filter states. states defaults to a vector of zeros which has length equal to (l + projectord - 2). |
StepSize | Any scalar from zero to one, inclusive | Specifies the step size taken between filter coefficient updates |
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 true. |
Show an example of quadrature phase shift keying (QPSK) adaptive equalization using a 32-coefficient FIR filter.
D = 16; % delay b = exp(1j*pi/4)*[-0.7 1]; % Numerator coefficients a = [1 -0.7]; % Denominator coefficients ntr= 1000; % Number of iterations s = sign(randn(1,ntr+D))+1j*sign(randn(1,ntr+D));% Baseband 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) mu = 0.5; % Step size po = 4; % Projection order offset = 1.0; % Offset for covariance matrix ha = adaptfilt.bap(32,mu,po,offset); [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;
Using the block affine projection object in QPSK results in the plots shown here.
[1] Ozeki, K. and T. Omeda, "An Adaptive Filtering Algorithm Using an Orthogonal Projection to an Affine Subspace and Its Properties," Electronics and Communications in Japan, vol. 67-A, no. 5, pp. 19-27, May 1984
[2] Montazeri, M. and Duhamel, P, "A Set of Algorithms Linking NLMS and Block RLS Algorithms," IEEE Transactions Signal Processing, vol. 43, no. 2, pp, 444-453, February 1995