MATLAB m-files listings – by Chapter (Digital Signal Processing – A Practical

Approach, E C Ifeachor and B W Jervis, Pearson/Prentice Hall, 2002; ISBN 81-

7808 609 3)

Chapter 1 Introduction

N/A

Chapter 2 Analog I/O interface for real-time DSP systems

N/A

Chapter 3 Discrete transform

function DFTD

clear all;
% Program to compute DFT coefficients directly
% (Program 3c.1, p170; program name: dftd.m)
%

direction = -1; %1 - forward DFT, -1 - inverse DFT

in = fopen('datain.dat','r');
x = fscanf(in,'%g %g',[2,inf]);
fclose(in);
x = x(1,:)+x(2,:)*i; % form complex numbers

if direction==1
y = x*dftmtx(length(x)) ; %compute DFT
else
y = x*conj(dftmtx(length(x)))/length(x); %compute IDFT
end

% Save/Print the results

out=fopen('dataout.dat','w');
fprintf(out,'%g %g\n',[real(y); imag(y)]);
fclose(out);
subplot(2,1,1),plot(1:length(x),x); title('Input Signal');
subplot(2,1,2),plot(1:length(y),y); title('Output Signal');

============================================================
function DFTF
% Program to compute DFT coefficients using DIT FFT
% (Program 3c.2, p171; program name: dftf.m)
%
clear all;
direction = -1; %1 - forward DFT, -1 - inverse DFT
in = fopen('dataout.dat','r');
x = fscanf(in,'%g %g',[2,inf]);
fclose(in);
x = x(1,:)+x(2,:)*i; % form complex numbers

if direction==1

1
 y=fft(x,length(x)) % compute FFT
else
y=ifft(x,length(x)) % compute IFFT
end

% Save/Print the results

out=fopen('dataout.dat','w');
fprintf(out,'%g %g\n',[real(y); imag(y)]);
fclose(out);
subplot(2,1,1),plot(1:length(x),x); title('Input Signal');
subplot(2,1,2),plot(1:length(y),y); title('Output Signal');

=======================================================
%
% 4-point DFT (sdft1.m)
% A simple m-file script illustrating direct 4-point DFT computation.
% input data: x(0)=1, x(1)=5, x(2)=4, x(3)=2.
%
N=4;j=sqrt(-1);
x0=1; x1=5; x2=4; x3=2;
X0=x0+x1+x2+x3;
X11=x1*exp(-j*2*pi/N);
X12=x2*exp(-j*2*pi*2/N);
X13=x3*exp(-j*2*pi*3/N);
X1a=x0+X11+X12+X13;
X1=x0+x1*exp(-j*2*pi/N)+x2*exp(-j*2*pi*2/N)+x3*exp(-j*2*pi*3/N);
X2=x0+x1*exp(-j*2*pi*2/N)+x2*exp(-j*2*pi*2*2/N)+x3*exp(-j*2*pi*2*3/N);
X3=x0+x1*exp(-j*2*pi*3/N)+x2*exp(-j*2*pi*3*2/N)+x3*exp(-j*2*pi*3*3/N);
X11
X12
X13
X1a
X0
X1
X2
X3

========================================================

%
% 4-point DFT (sdft2.m)
% A simple m-file script illustrating direct 4-point DFT computation.
% input data: x(0)=1, x(1)=0.5, x(2)=0, x(3)=0.
%
N=4;j=sqrt(-1);
x0=1; x1=0.5; x2=0; x3=0;
X0=x0+x1+x2+x3;
X11=x1*exp(-j*2*pi/N);
X12=x2*exp(-j*2*pi*2/N);
X13=x3*exp(-j*2*pi*3/N);
X1a=x0+X11+X12+X13;
X1=x0+x1*exp(-j*2*pi/N)+x2*exp(-j*2*pi*2/N)+x3*exp(-j*2*pi*3/N);
X2=x0+x1*exp(-j*2*pi*2/N)+x2*exp(-j*2*pi*2*2/N)+x3*exp(-j*2*pi*2*3/N);
X3=x0+x1*exp(-j*2*pi*3/N)+x2*exp(-j*2*pi*3*2/N)+x3*exp(-j*2*pi*3*3/N);
X11
X12
X13

2
X1a
X0
X1
X2
X3

================================================================
%
% 4-point FFT (sfft2.m)
% A simple m-file script illustrating direct 4-point FFT decimation-in-
time
% computation.
% Input data: x(0)=1, x(1)=0.5, x(2)=0, x(3)=0.
%
N=4;j=sqrt(-1);
x0=1; x1=0.5; x2=0; x3=0;
W0=1; W1=-j;
a11=x0+W0*x2;b11=x0-W0*x2;
a12=x1+W0*x3; b12=x1-W0*x3;
X0=a11+W0*a12; X2=a11-W0*a12;
X1=b11+W1*b12; X3=b11-W1*b12;
a11
b11
a12
b12
X0
X1
X2
X3

========================================================

%
%
% 8-point DFT (sfft8.m)
% A simple m-file script illustrating direct 8-point DFT computation.
% Input data: x(0)=4, x(1)=2, x(2)=1, x(3)=4, x(4)=6, x(5)=3, x(6)=5,
x(7)=2.
%

j=sqrt(-1);
x0=4; x1=2; x2=1; x3=4; x4=6; x5=3; x6=5; x7=2;
W0=1; W1=sqrt(2)/2 - j*sqrt(2)/2; W2=-j; W3=-sqrt(2)/2 - j*sqrt(2)/2;
% stage 1
A11=x0+W0*x4;B11=x0-W0*x4;
A12=x2+W0*x6;B12=x2-W0*x6;
A13=x1+W0*x5;B13=x1-W0*x5;
A14=x3+W0*x7;B14=x3-W0*x7;
% stage 2
A21=A11+W0*A12;B21=A11-W0*A12;
A22=B11+W2*B12;B22=B11-W2*B12;
A23=A13+W0*A14;B23=A13-W0*A14;
A24=B13+W2*B14;B24=B13-W2*B14;
% stage 3
X0=A21+W0*A23;X4=A21-W0*A23;
X1=A22+W1*A24;X5=A22-W1*A24;
X2=B21+W2*B23;X6=B21-W2*B23;

3
X3=B22+W3*B24;X7=B22-W3*B24;
A11
B11
A12
B12
A13
B13
A14
B14
A21
A22
B21
B22
A23
A24
B23
B24
X0
X1
X2
X3
X4
X5
X6
X7

=================================================================

%
% 4-point inverse FFT (sifft4.m)
% A simple m-file script illustrating direct 4-point inverse DFT
computation.
% Input data: x(0)=1.5 +0j, x(1)=1-0.5j, x(2)=0.5+0j, x(3)=1+0.5j
%
N=4;j=sqrt(-1);
x0=1.5 + 0j; x1=1 - 0.5j; x2=0.5 + 0j; x3=1+0.5j;
W0=1; W1=j;
a11=x0+W0*x2;b11=x0-W0*x2;
a12=x1+W0*x3; b12=x1-W0*x3;
X0=(a11+W0*a12)/N; X2=(a11-W0*a12)/N;
X1=(b11+W1*b12)/N; X3=(b11-W1*b12)/N;
a11
b11
a12
b12
X0
X1
X2
X3
x0
x1
x2
x3

======================================================

4
Chapter 4 z-transform and its applications in signal processing.
%
% m-file to compute the first 5 values of the
% inverse z-transform using the power series method
% (Program 4D.1, p235; program name: prog4d1.m)
%
n = 5; % number of power series points
N1 = [1 -1.122346 1]; D1 = [1 -1.433509 0.85811];
N2 = [1 1.474597 1]; D2 = [1 -1.293601 0.556929];
N3 = [1 1 0]; D3 = [1 -0.612159 0];
B = [N1; N2; N3]; A = [D1; D2; D3];
[b,a] = sos2tf([B A]);
b = [b zeros(1,n-1)];
[h,r] = deconv(b,a); %perform long division
disp(h);
============================================================
%
% m-file for finding the partial fraction expansion of a z-transform
% (Program 4D.2, p237; program name: prog4d2.m)
%
N1=[1 -1.122346 1];
N2=[1 -0.437833 1];
N3=[1 1 0];
D1=[1 -1.433509 0.85811];
D2=[1 -1.293601 0.556929];
D3=[1 -0.612159 0];
sos=[N1 D1; N2 D2; N3 D3];
[b, a] = sos2tf(sos);
[r, p, k]=residue(b, a)

================================================
%
% A script illustrating cascade to parallel realization
% (Program 4B.3, p237; program name: prog4d3.m)
%
nstage=2;
N1 = [1 0.481199 1];
N2 = [1 1.474597 1];
D1 = [1 0.052921 0.83173];
D2 = [1 -0.304609 0.238865];
sos = [N1 D1; N2 N2];
[b, a] = sos2tf(sos);
[c, p, k] = residue(b, a);
m = length(b);
b0 = b(m)/a(m);
j=1;
for i=1:nstage
bk(j)=c(j)+c(j+1);
bk(j+1)=-(c(j)*p(j+1)+c(j+1)*p(j));
ak(j)=-(p(j)+p(j+1));
ak(j+1)=p(j)*p(j+1);
j=j+2;
end
b0

5
ak
bk
c
p
k

===============================================================
%
% A simple script illustrating basics of cascade to parallel
% conversion for a 4th order filter (cprealization.m)
%
b=[1, -2, 1, 0, 0];
a=[1, -0.41421, 0.08579, 0.292895, 0.5];
[c, p, k] = residuez(b, a);
c
p
k
b0 = b(3)/a(5)
b01=c(1)+c(2)
b11=-(c(1)*p(2)+c(2)*p(1))
a11=-(p(1)+p(2))
a12=p(1)*p(2)
b02=c(3)+c(4)
b12=-(c(3)*p(4)+c(4)*p(3))
a12=-(p(3)+p(4))
a22=p(3)*p(4)
=================================================================
%
% A simple script illustrating inverse z transform by power series codes
% File-name: pseries.m
b1 = [1 0.481199 1];
b2 = [1 1.474597 1];
a1 = [1 0.052921 0.83173];
a2 = [1 -0.304609 0.238865];
sos = [b1 a1; b2 a2];
[b, a] = sos2tf(sos);
m = length(b);
r = b;
for n=1:m
[h(n), r] = deconv(r, a);
h
r
r = [r(2:m) 0];
end

=================================================
function IZT
%program IZT (izt.m) is for:
%(1) computing the inverse z-transform via the power series or partial
% fraction expansion method
%(2) converting a transfer function, H(z), in cascade form to an
equivalent
% transfer function in parallel, via partial fraction expansion. The
% basic building block is the second order biquad

IZT_Mode = 1; %1 - use power series to perform the IZT

6
 %2 - use partial fraction/residue to perform the IZT
%3 - cascade to parallel conversion
n = 5; % number of power series points
b1 = [1 0.481199 1]; a1 = [1 0.052921 0.83173];
b2 = [1 1.474597 1]; a2 = [1 -0.304609 0.238865];
B = [b1; b2]; A = [a1; a2];
[b,a] = sos2tf([B A]);
if IZT_Mode==1 %compute the IZT by power series
b = [b zeros(1,n-1)];
[h,r] = deconv(b,a); %perform long division
disp('The result of the inverse Z-transform by power series is:');
disp(h);
else
[res,poles,rem] = residuez(b,a);
disp('The poles of the transform function are:'); disp(poles');
disp('The partial fraction coefficients are:'); disp(res');
if IZT_Mode==3
i = 1 ;
for j=1:size(B,1)
[b,a] = residuez(res(i:i+1),poles(i:i+1), 0);
fprintf('Numerator and Denominator for stage
%d:\n',j);disp(b);disp(a);
i = i + 2;
end
end
end
=========================================================
%
% m-file to illustrate the computation of frequency response
% of an IIR filter using FFT (freqrespex1.m).
%
Fs=500; % sampling frequency
b1=[1 -1.6180 1]; b2=[]; % numerator/denominator filter
coefficients
a1=[1 -1.5161 0.878]; a2=[];
B=[b1; b2]; A=[a1; a2];
[b,a]=sos2tf([B A]);
n=256; % number of frequency points
dx=0;
if dx
freqz(b,a,n,Fs); % Frequency response evaluation by FFT
else
f=(0:n-1)*(Fs/2)/n;
freqz(b,a,f,Fs); % frequency response by direct evaluation.
end
=========================================================

7
Chapter 5 Correlation and Convolution

function Correlation

%Program to compute normalised/unnormalised auto- or crosscorrelation

crosscorrelation = 1 ;
normalized = 0 ;
if crosscorrelation == 0
x = [1 3 2 -1 -2]; %for autocorrelation
if normalized==0
R11 = xcorr(x,'biased') % unnormalized autocorrelation
else
R11 = xcorr(x,'coeff') % normalized autocorrelation
end
else
x1 = [4 2 -1 3 -2 -6 -5 4 5]; %for crosscorrelation
x2 = [-4 1 3 7 4 -2 -8 -2 1]; %for crosscorrelation
if normalized==0
R12 = xcorr(x1,x2,'biased') % unnormalized crosscorrelation
else
R12 = xcorr(x1,x2,'coeff') % normalized crosscorrelation
end
end

if crosscorrelation
subplot(3,1,1), plot(1:length(x1),x1), ylabel('x1(n)');
subplot(3,1,2), plot(1:length(x2),x2), ylabel('x2(n)');
subplot(3,1,3), plot(1:length(R12),R12), ylabel('R12');
else
subplot(2,1,1), plot(1:length(x),x), ylabel('x(n)');
subplot(2,1,2), plot(1:length(R11),R11), ylabel('R11');
end

Chapter 6 A framework for digital filter design

N/A

8
Chapter 7 Finite impulse response (FIR) filter design

%
% prog7b1.m, p442 Program name
%
fc=0.53; % cutoff frequency (normalized to Fs/2)
N= 10; % Filter length (number of taps)
hd=fir1(N-1,fc,boxcar(N)); % Calculate truncated ideal impulse response
coeffs
wn=hamming(N); % Calculate Hamming window coefficients
hn=fir1(N-1,fc,wn); % Obtain windowed coefficients

===============================
%
% prog7b2.m, p444 File name
%
FS=1000; % Sampling frequency
FN=FS/2; % Nyquist frequency
N=73; % Filter length
beta=5.65; % Kaiser ripple parameter
fc1=125/FN; % Normalized cut off frequencies
fc2=275/FN;
FC=[fc1 fc2]; % Band edge frequencies
hn=fir1(N-1, FC, kaiser(N, beta)); %Obtain windowed filter coefficients
[H,f]=freqz(hn, 1, 512, FS); % Compute frequency response
mag=20*log10(abs(H));
plot(f, mag), grid on
xlabel('Frequency (Hz)')
ylabel('Magnitude Response (dB)')

===============================
%
% Program name - prog7b3.m, p446
% m-file for calculating optimal FIR filter coefficients and
% plotting frequency response
%
Fs=10000; % Sampling frequency
N=41; % Filter length
WT=[10 3 10]; % Weights of the deviations in the bands
Hd=[0 0 1 1 0 0]; % Desired magnitude response in the bands
F=[0 0.1 0.2 0.3 0.4 1]; % Band edge frequencies
b = remez(N-1, F, Hd, WT); % Compute the filter coefficients
[H, f] = freqz(b, 1, 512, Fs);% Compute the frequency response
mag = 20*log10(abs(H)); % of filter and plot it
plot(f, mag), grid on
xlabel('Frequency (Hz)')
ylabel('Magnitude (dB)')

=================================

9
%
% Program name - prog7b4a.m, p449.
% m-file for calculating the optimal FIR filter coefficients
% and plotting frequency response for Example 7B.4
%
Fs=50000; % Sampling frequency
% Filter length
Ap=1; % Pass band ripple in dB
As=45; % Stop band attenuation in dB
M=[0 1 0]; % Desired magnitude response
F=[10000, 12000, 16000, 18000] ; % Band edge frequencies
dp=(10^(Ap/20)-1)/(10^(Ap/20)+1); % Pass and stop band ripples
ds=10^(-As/20);
dev=[ds dp ds];
[N1, F0, M0, W] = remezord(F, M, dev, Fs);% Determine filter order
[b delta] = remez(N1, F0, M0, W);% Compute the filter coefficients
[H, f] = freqz(b, 1, 1024, Fs); % Compute the frequency response
mag = 20*log10(abs(H)); % of filter and plot it
plot(f, mag), grid on
xlabel('Frequency (Hz)')
ylabel('Magnitude (dB)')

===========================================
%
% Program name - prog7b4b.m, p450.
% An alternative m-file for calculating the optimal FIR filter
% coefficients and plotting frequency response for Example 7B.4
%
N=44;
Fs=50000; % Sampling frequency
% Filter length
Ap=1; % Pass band ripple in dB
As=45; % Stop band attenuation in dB
M=[0 0 1 1 0 0]; % Desired magnitude response
F=[0, 0.4, 0.48, 0.64, 0.72 1] ; % Band edge frequencies
dp=(10^(Ap/20)-1)/(10^(Ap/20)+1);
ds=10^(-As/20);
W=[dp/ds, 1, dp/ds];
dev=[ds ds dp dp ds ds ];
[b delta] = remez(N-1, F, M, W);% Compute the filter coefficients
[H, f] = freqz(b, 1, 1024, Fs); % Compute the frequency response
mag = 20*log10(abs(H)); % of filter and plot it
plot(f, mag), grid on
xlabel('Frequency (Hz)')
ylabel('Magnitude (dB)')

==============================================

10
%
% Program name - prog7b5.m, p451.
% m-file for computing the coefficients of an FIR frequency sampling
% filter
%
Fs=2000; % Sampling frequency
N=15; % Filter length
fd=[0 1/7 2/7 3/7 4/7 5/7 6/7 1]; % Frequency sampling points
Hd=[1 1 1 1 0.5571 0.0841 0 0]; % Frequency samples
hn=fir2(N-1, fd, Hd); % Compute the impulse response coeffs.
[H, f] = freqz(hn, 1, 512, Fs); % Plot the magnitude frequency response
plot(f, abs(H)), grid on
xlabel('Frequency (Hz)')
ylabel('Magnitude ')

==================================================
%
% Program name - prog7b6.m, p453.
% m-file for calculating the coefficients of an FIR filter
% with arbitrary magnitude response
%
Fs=2000;
N=110;
fd=[0 0.15 0.25 0.45 0.5 0.75 0.85 1]; % Frequency sampling points
Hd=[1 1 0.3 0.3 0.1 0.1 0 0]; % Frequency samples
hn=fir2(N-1, fd, Hd); % Compute the impulse response
[H, f] = freqz(hn, 1, 512, Fs); % Plot the magnitude response
plot(f, abs(H)), grid on
xlabel('Frequency (Hz)')
ylabel('Magnitude ')

=================================================

function Filt_win

%This program uses the window method to design FIR filters.

%The following windows are supported: Rectangular, Hamming, Hanning, Blackman,

%and Kaiser.

% ftype: [] for lowpass filter

% 'high' for highpass filter
% [] for bandpass filter
% 'stop' for bandstop filter
% wtype: 1 for Rectangular window
% 2 for Hamming window
% 3 for Hanning window
% 4 for Blackman window
% 5 for Kaiser window

clear all;
wtype = 2 ;
Fs = 8000; %sampling frequency

11
n = 52; %the order of the filter
Wn = 0.4375; %normalised cutoff frequency (2*Fstop/Fs)
beta = 0; %Kaiser window beta parameter
ftype=[];
window=[]; %Hamming window will be used if variable window is empty

if wtype==1
window=ones(1,n+1); %Rectangular window
elseif wtype==3
window=hanning(n+1); %Hanning window
elseif wtype==4
window=blackman(n+1); %Blackman window
elseif wtype==5
window=kaiser(n+1,beta);%Kaiser window
end
b = fir1(n,Wn,ftype,window)

% Plot the frequency response

freqz(b,1,1024,Fs);
=========================================

function Firfilt

%FIR filtering program - program performs FIR filtering using coefficients

%and data in user specified files.
clear all;
data_file = fopen('filterin.dat','r'); %read the data to be filtered from
file
x = fscanf(data_file,'%f');
coef_file = fopen('filtcoef.dat','r'); %read the filter coefficients from
file
[b,n]=fscanf(coef_file,'%f',inf);
fclose('all');

y=filter(b,1,x); %filtering

%Plot the results

bx=fft(x,512);
by=fft(y,512);
[h, w]=freqz(b,1,1024);
subplot(3,1,1),plot(1000*(0:255)/512,abs(bx(1:256))), ylabel('X(f)');
subplot(3,1,2),plot(w/pi,abs(h)), ylabel('H(f)');
subplot(3,1,3),plot(1000*(0:255)/512,abs(by(1:256))), ylabel('Y(f)');

===================================================================

function Fresamp
%Design arbitrary FIR filter by frequency sampling method

n=15;
m = [1 1 1 1 0.5571 0.0841 0 0];
f = [0 1/7 2/7 3/7 4/7 5/7 6/7 1];
window = [1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1]; % n+1 elements long
b = fir2(n,f,m,window); % get filter coefficients

12
%Output the results
disp('The coefficients are:'); disp(b);
[h,w] = freqz(b,1,128);
plot(f,m,w/pi,abs(h)); title('Desired and Actual Frequency Responses');
==================================================

%
% Program name - REMEZ1.m
%
Fs=15000; % sampling frequency
N=41; % Filter length
WT=[10 3 10]; % Weights of the deviations in the
bands
Hd=[0 0 1 1 0 0]; % Desired magnitude response in
the bands
F=[0 0.06 0.12 0.14667 0.206667 1]; % Band edge frequencies
[b, delta] = remez(N-1, F, Hd, WT); % Compute the filter coefficients
[H, f] = freqz(b, 1, 512, Fs); % Compute the frequency response
mag = 20*log10(abs(H)); % of filter and plot it
plot(f, mag)
xlabel('Frequency (Hz)')
ylabel('Magnitude (dB)')

================================================
%
% Program name – REMEZex2.m
%
N=44
Fs=50000; % Sampling frequency
% Filter length
Ap=1; % Pass band ripple in dB
As=45; % Stop band attenuation in dB
M=[0 0 1 1 0 0]; % Desired magnitude response
F=[0, 0.4, 0.48, 0.64, 0.72 1] ; % Band edge frequencies
dp=(10^(Ap/20)-1)/(10^(Ap/20)+1);
ds=10^(-As/20);
W=[dp/ds, 1, dp/ds];
dev=[ds ds dp dp ds ds ];
[b delta] = remez(N-1, F, M, W);% Compute the filter coefficients
[H, f] = freqz(b, 1, 1024, Fs); % Compute the frequency response
mag = 20*log10(abs(H)); % of filter and plot it
plot(f, mag), grid on
xlabel('Frequency (Hz)')
ylabel('Magnitude (dB)')

================================================

13
Chapter 8 Design of infinite impulse response (IIR) digital filters.

%
% Program 8.1, p511. m-file for the analog filter design
% (Example 8.19)
% program name: prog81.m
%
FN=1000/2;
fc=300; % cut offf frequency
N=5; % filter order
[z, p, k]=buttap(N); % create an analog filter
w=linspace(0, FN/fc, 1000); % plot the response of filter
h=freqs(k*poly(z), poly(p), w);
f=fc*w;
plot(f, 20*log10(abs(h))), grid
ylabel('Magnitude (dB)')
xlabel('Frequency (Hz)')

=============================================

%
% Program 8.2, p511. m-file for the design of the
% impulse invariant filter (Example 8.19)
% program name: prog82.m
%
Fs=1000; % sampling frequency
fc=300; % cutoff frequency
WC=2*pi*fc; % cutoff frequency in radian
N=5; % filter order
[b,a]=butter(N,WC,'s'); % create an analog filter
[z, p, k]=butter(N, WC, 's');
[bz, az]=impinvar(b,a,Fs); % determine coeffs of IIR filter
[h, f]=freqz(bz, az, 512,Fs);
plot(f, 20*log10(abs(h))), grid
xlabel('Frequency (Hz)')
ylabel('Magnitude (dB)')

==============================================

%
% Program 8.3, p512. m-file for the design of the BZT filter
% (Example 8.19)
% program name: prog83.m
%
Fs=1000; % sampling frequency
FN=Fs/2;
fc=300; % cutoff frequency
N=5;
[z, p, k]=butter(N, fc/FN);
[h, f]=freqz(k*poly(z), poly(p), 512, Fs);
plot(f, 20*log10(abs(h))), grid
ylabel('Magnitude (dB)')
xlabel('Frequency (Hz)')

14
=====================================================
%
% m-file for Example 8B.1 (Program 8B.1, p564).
% Program name: prog8b1.m
%
N=2; % Filter order
Fs=1280; % Sampling frequency
fc=150; % Cutoff frequency
WC=2*pi*fc; % Cutoff frequency in radian
%
% Create an analogue filter
%
[b,a]=butter(N,WC,'s');
[z,p,k]=butter(N, WC, 's');
%
% Convert analogue filter into Discrete IIR filter
%
[bz, az]=impinvar(b, a, Fs); %Determine coeffs of IIR filter
subplot(2,1,1) % Plot magnitude freq. response
[H, f]=freqz(bz, az, 512, Fs);
plot(f, 20*log10(abs(H)))
xlabel('Frequency (Hz)')
ylabel('Magnitude Response (dB)')
subplot(2,1,2) % Plot pole-zero diagram
zplane(bz, az)
zz=roots(bz); % Determine poles and zeros
pz=roots(az);

============================================================

%
% m-file for Example 8B.2 (Program 8B.2, p566).
% Program name: prog8b2.m
%
N=2; % Filter order
Fs=1280; % Sampling frequency
FN=Fs/2;
fc=150; % Cutoff frequency
Fc=fc/FN; % Normalized Cutoff frequency
[b,a]=butter(N,Fc); % Create and digitize analogue
filter.
[z,p,k]=butter(N, Fc);
subplot(2,1,1) % Plot magnitude freq. response
[H, f]=freqz(b, a, 512, Fs);
plot(f, abs(H))
xlabel('Frequency (Hz)')
ylabel('Magnitude Response ')
subplot(2,1,2) % Plot pole-zero diagram
zplane(b, a)
b
a

15
==========================================================

%
% m-file for Example 8B.3 (Program 8B.3, p567)
% Program name: prog8b3.m
%
Fs=2000; % Sampling frequency
FN=Fs/2;
fc1=200/FN;
fc2=300/FN;
[b,a]=butter(4,[fc1, fc2]); % Create and digitize analogue
filter.
[z,p,k]=butter(4, [fc1, fc2]);
subplot(2,1,1) % Plot magnitude freq. response
[H, f]=freqz(b, a, 512, Fs);
plot(f, abs(H))
xlabel('Frequency (Hz)')
ylabel('Magnitude Response ')
subplot(2,1,2) % Plot pole-zero diagram
zplane(b, a)

=========================================================

%
% m-file for Example 8B.4 (Program 8B.4, p569)
% Program name: prog8b4.m
%
Fs=8000; % Sampling frequency
Ap=3;
As=20;
wp=500/4000;
ws=2000/4000;
[N, wc]=buttord(wp, ws, Ap, As); % Determine filter order
[zz, pz, kz]=butter(N,500/4000); % Digitise filter
[b, a]=butter(N, 500/4000);
subplot(2,1,1) % Plot magnitude freq.
response
[H, f]=freqz(b, a, 512, Fs);
plot(f, abs(H))
xlabel('Frequency (Hz)')
ylabel('Magnitude Response ')
subplot(2,1,2) % Plot pole-zero diagram
zplane(b, a)

=======================================================

16
%
% m-file for Example 8B.5 (Program 8B.5, p571)
% Program name: prog8b5.m
%
Fs=8000; % Sampling frequency
Ap=3;
As=20;
wp=2000/4000;
ws=500/4000;
[N, wc]=buttord(wp, ws, Ap, As); % Determine filter order
[zz, pz, kz]=butter(N,2000/4000, 'high'); % Digitise filter
[b, a]=butter(N, 2000/4000, 'high');
subplot(2,1,1) % Plot magnitude freq.
response
[H, f]=freqz(b, a, 512, Fs);
plot(f, abs(H))
xlabel('Frequency (Hz)')
ylabel('Magnitude Response ')
subplot(2,1,2) % Plot pole-zero diagram
zplane(b, a)

====================================================

%
% m-file for Example 8B.6 (Program 8B.6, p572)
% Program name: prog8b6.m
% Band pass filter
%
Fs=1000; % Sampling frequency
Ap=3;
As=20;
Wp=[200/500, 300/500]; % Band edge frequencies
Ws=[50/500, 450/500];
[N, Wc]=buttord(Wp, Ws, Ap, As); % Determine filter order
[zz, pz, kz]=butter(N,Wp); % Digitise filter
[b, a]=butter(N, Wp);
subplot(2,1,1) % Plot magnitude freq. response
[H, f]=freqz(b, a, 512, Fs);
plot(f, abs(H))
xlabel('Frequency (Hz)')
ylabel('Magnitude Response ')
subplot(2,1,2) % Plot pole-zero diagram
zplane(b, a)

=======================================================

17
%
% m-file for Example 8B.7 (Program 8B.7, p574)
% Program name: prog8b7.m
% Band stop filter

%
Fs=1000; % Sampling frequency
Ap=3;
As=20;
Wp=[50/500, 450/500]; % Band edge frequencies
Ws=[200/500, 300/500];
[N, Wc]=buttord(Wp, Ws, Ap, As); % Determine filter order
[zz, pz, kz]=butter(N,Ws, 'stop'); % Digitise filter
[b, a]=butter(N, Ws, 'stop');
subplot(2,1,1) % Plot magnitude freq. response
[H, f]=freqz(b, a, 512, Fs);
plot(f, abs(H))
xlabel('Frequency (Hz)')
ylabel('Magnitude Response ')
subplot(2,1,2) % Plot pole-zero diagram
zplane(b, a)

============================================================

%
% m-file for the design Example 8B.8 (Program 8B.8, p576)
% Program Name: prog8b8.m
%
Ap=0.25;
As=45;
Fs=100000;
Wp=[20500/50000, 23500/50000]; % Band edge frequencies
Ws=[19000/50000, 25000/50000];

[N,Wc]=ellipord(Wp, Ws, Ap, As); % Determine filter order

[b, a]=ellip(N, Ap, As, Wc); % Determine filter coeffs
[z, p, k]=ellip(N, Ap, As,Wc); % Determine poles and
zeros
sos=zp2sos(z, p,k); % Convert to second order
sections
subplot(2,1,1) % Plot magnitude freq.
response
[H, f]=freqz(b, a, 512, Fs);
plot(f, 20*log10(abs(H)))
xlabel('Frequency (Hz)')
ylabel('Magnitude Response (dB)')
subplot(2,1,2) % Plot pole-zero diagram
zplane(b, a)

============================================================

18
function IIRBZT

%Design program for IIR filters with Butterworth, Chebyshev, Inverse

%Chebyshev or Elliptic Characteristic using bilinear transformation

%output arguments:
%n - estimated minimun filter order.
%Wn - cutoff frequencies.
%b,a - coefficients of digital filter
%ftype - 'low' for lowpass filter
% 'high' for highpass filter
% 'bandpass' for bandpass filter
% 'stop' for bandstop filter
%ctype - 1 for Butterworth filter
% 2 for Chebyshev filter
% 3 for Inverse Chebyshev filter
% 4 for Elliptic filter

%steps of designing a digital filter implied in the called functions:

% step 1: estimate the minimum order of the filter from specifications
% step 2: get analog, pre-warped frequencies
% step 3: convert to low-pass prototype estimate
% step 4: Get n-th order analog lowpass prototype with desired filter
characters
% step 5: Transform to lowpass, bandpass, highpass, or bandstop of
desired Wn
% step 6: Use Bilinear transformation to find discrete equivalent:

clear all; format;

Fs = 100000; %sampling frequency(Hz).

Wp = [20500 23500]/(Fs/2); %passband edge frequency normalised by
Fs/2.
Ws = [19000 25000]/(Fs/2); %stopband edge frewquency normalised by
Fs/2.
Rp = 0.25; %passband attenuation in dB.
Rs = 45; %stopband attenuation in dB
ctype = 4; %character of filter
ftype = 'bandpass'; %type of filter

if ctype==1
[n,Wn]=buttord(Wp,Ws,Rp,Rs);
[b,a]=butter(n,Wn,ftype);
elseif ctype==2
[n,Wn]=cheb1ord(Wp,Ws,Rp,Rs);
[b,a]=cheby1(n,Rp,Wn,ftype);
elseif ctype==3
[n,Wn]=cheb2ord(Wp,Ws,Rp,Rs);
[b,a]=cheby2(n,Rs,Wn,ftype);
elseif ctype==4
[n,Wn]=ellipord(Wp,Ws,Rp,Rs);
[b,a]=ellip(n,Rp,Rs,Wn,ftype);
end

%Output the result

disp('Numerator coefficients (in descending powers of z):'); disp(b);
disp('Denominator coefficients (in descending powers of z):'); disp(a);

19
freqz(b,a,1024,Fs);

=======================================================

function Impinv

%Impulse invariance method of anolog-to-digital filter conversion

%a,b -- s-plane coefficients

%az,bz -- digital filter coefficients

clear all;
b = 1;
a = [1.84496 1.920675 1];
[bz,az]=impinvar(b,a) %get z-plane coefficients using impulse Inv.
freqz(bz,az,1024);

=======================================================

%
% Program name - prob825.m (problem 8.25(1), p553)
% Comparison of magnitude and phase responses of an analogue
% and equivalent BZT and impulse invariant discrete-time filters
% and pole-zero diagrams (elliptic low pass filter)
%
Fs=10000; FN=Fs/2;
fp=1000; fs=3000;
wp=fp*2*pi; ws=fs*2*pi;
Ap=1; As=60;
%
% Calculate filter coefficients and frequency responses
[N, wc]=ellipord(wp, ws, Ap, As,'s'); % analog filter
[B, A]=ellip(N, Ap, As, wc, 's');
[bBZT, aBZT]=bilinear(B,A,Fs); % BZT filter
[bIIT,aIIT]=impinvar(B,A,Fs); % Impulse invariance filter
%
% Compute frequency response
[Ha, wa]=freqs(B,A);
[HBZT, fBZT]=freqz(bBZT, aBZT, 512, Fs);
[HIIT, fIIT]=freqz(bIIT, aIIT, 512, Fs);
%
% Plot magnitude frequency responses
%
figure(1); % Plot analogue magnitude
response
plot(wa/(2*pi), 20*log10(abs(Ha)))
hold on
figure (1);
plot(fBZT, 20*log10(abs(HBZT)), 'r:') % Plot BZT magnitude response
hold on
figure (1);
plot(fIIT, 20*log10(abs(HIIT)), 'g:') % Plot Impinv magnitude
response
legend('Analog', 'BZT', 'Imp Invar');
axis([0 10000 -120 0])
ylabel('Magnitude (dB)')
xlabel('Frequency (Hz)')

20
title('Filter magnitude responses')
hold off;
%
% Plot phase responses
%
figure(2);
plot(wa/(2*pi), angle(Ha)*180/pi) % Plot analogue phase response
hold on
figure (2);
plot(fBZT, angle(HBZT)*180/pi, 'r:') % Plot BZT phase response
hold on
figure(2);
plot(fIIT, angle(HIIT)*180/pi, 'g.') %ImpInvar phase response
legend('Analog', 'BZT','Imp Invar');
axis([0 10000 -360 360])
ylabel('Phase (Degrees)')
xlabel('Frequency (Hz)')
title('Filter Phase Responses')
hold off
%
% Plot pole-zero diagrams
%
figure (3);
zplane(bBZT, aBZT)
title('Pole-zero diagram - BZT filter')
figure (4);
zplane(bIIT, aIIT)
xmin=-1; xmax=1; ymin=-1; ymax=1; % Scale the z-plane for the Impulse
Inva.
axis([xmin xmax ymin ymax])
title('Pole-zero diagram - impulse invariance filter')

=====================================================
%
% Program name - prob8261a.m (modified problem 8.26(1), p553)
% Comparison of characteristic features of discrete-time Butterworth,
% Chebyshev 1,Chebyshev 2 and elliptic lowpass filters.
%
Fs=8000;
fp=500/4000; fs=2000/5000;
Ap=0.1; As=60;
%
% Calculate filter coefficients
[N1, wc1]=buttord(fp, fs, Ap, As); % filter order
[N2, wc2]=cheb1ord(fp, fs, Ap, As);
[N3, wc3]=cheb2ord(fp, fs, Ap, As);
[N4, wc4]=ellipord(fp, fs, Ap, As);
[b1, a1]=butter(4, fp); % Butterworth filter
[b2, a2]=cheby1(4, Ap, fp);
[b3, a3]=cheby2(4, As, fs);
[b4, a4]=ellip(4, Ap, As, fp);
%
% Calculate frequency responses
%
[H1, f1]=freqz(b1, a1, 512, Fs);
[H2, f2]=freqz(b2, a2, 512, Fs);
[H3, f3]=freqz(b3, a3, 512, Fs);

21
[H4, f4]=freqz(b4, a4, 512, Fs);
%
% Plot magnitude frequency responses
%
figure (1);
plot(f1, 20*log10(abs(H1)), 'r:') % Plot Butterworth magnitude
response
hold on
figure (1);
plot(f2, 20*log10(abs(H2)), 'b--') % Plot Cheby1 magnitude response
hold on
figure (1);
plot(f3, 20*log10(abs(H3)), 'g-.') % Plot Cheby2 magnitude response
hold on
figure (1);
plot(f4, 20*log10(abs(H4)), 'k-') % Plot elliptic magnitude response
hold on
legend('Butworth', 'Cheby1', 'Cheby2', 'Ellip');
axis([0 4000 -100 10])
ylabel('Magnitude (dB)')
xlabel('Frequency (Hz)')
title('Filter magnitude responses')
hold off;
%
% Plot phase responses
%
figure (2);
plot(f1, angle(H1)*180/pi, 'r:') % Plot BZT phase response
hold on
figure (2);
plot(f2, angle(H2)*180/pi, 'b--') % Plot Cheby 1 phase response
hold on
figure (2);
plot(f3, angle(H3)*180/pi, 'g-.') % Plot Cheby 2 phase response
hold on
figure (2);
plot(f4, angle(H4)*180/pi, 'k-') % Plot elliptic phase response
hold on
figure(2);
legend('Butter', 'Cheby1','Cheby2', 'Ellip');
axis([0 4000 -360 360])
ylabel('Phase (Degrees)')
xlabel('Frequency (Hz)')
title('Filter Phase Responses')
hold off
%
% Plot pole-zero diagrams
%
figure (3);
zplane(b1, a1)
title('Pole-zero diagram - Butterworth filter')
figure (4);
zplane(b2, a2)
title('Pole-zero diagram - Chebyshev 1 filter')
figure (5);
zplane(b3, a3)
title('Pole-zero diagram - Chebyshev 2 filter')

22
figure (6);
zplane(b4, a4)
title('Pole-zero diagram - Elliptic filter')
N1
N2
N3
N4

==========================================================

Chapter 9 Multirate digital signal processing

%
% m-file to illustrate simple interpolation and
% decimation operations (Program 9B.1, p641)
% File name: prog9b1.m
% An Illustration of interpolation by a factor of 4
%
Fs=1000; % sampling frequency
A=1.5; % relative amplitudes
B=1;
f1=50; % signal frequencies
f2=100;
t=0:1/Fs:1; % time vector
x=A*cos(2*pi*f1*t)+B*cos(2*pi*f2*t); % generate signal
y=interp(x,4); % interpolate signal by 4
stem(x(1:25)) % plot original signal
xlabel('Discrete time, nT ')
ylabel('Input signal level')
figure
stem(y(1:100)) % plot interpolated
signal.
xlabel('Discrete time, 4 x nT')
ylabel('Output signal level')

==========================================

%
% m-file to illustrate simple interpolation and
% decimation operations (Program 9B.2, p644).
% File name: prog9b2.m
% An Illustration of sampling rate changes using upfirdn by a factor
of 4
%
Fs=1000; % sampling frequency
A=1.5; % relative amplitudes
B=1;
f1=50; % signal frequencies
f2=100;
t=0:1/Fs:1; % time vector
x=A*cos(2*pi*f1*t)+B*cos(2*pi*f2*t); % generate signal
y=resample(x,4,1); % interpolate signal by 4
stem(x(1:25)) % plot original signal

23
xlabel('Discrete time, nT ')
ylabel('Input signal level')
figure
stem(y(1:100)) % plot interpolated signal.
xlabel('Discrete time, 4 x nT')
ylabel('Interpolated output signal level')
y1=resample(y,1,4);
figure
stem(y1(1:25)) % plot decimated signal.
xlabel('Discrete time, nT')
ylabel('Decimated output signal level')

============================================

function moptimum

%Program moptimum is for designing I-stage optimum decimator

%or interpolator (I=1,2,3 or 4). The program computes the decimation
%factors, filter characteristics, and decimator efficiencies

%The following parameters must be provided by the user:

% Fs - input sampling frequency
% M - overall decimation factor
% fp - passband edge frequency
% dp - overall passband deviation in +ve dB
% ds - overall stopband deviation in +ve dB

clear all;
Fs = 96000; % sampling frequency in Hz
fp = 450; % passband edge frequency in Hz
dp = 0.0864; % overall passband deviation in +ve dB
ds = 60; % overall stopband deviation in +ve dB
M = 96; % overall decimation factor

EvalNStageDecimator(Fs,fp,dp,ds,M); % evaluate single stage decimator

for i=2:4 % evaluate all possible 2-, 3- and 4-stage decimators
R = GetFactors(M,i);
for j=1:size(R,1);
EvalNStageDecimator(Fs,fp,dp,ds,R(j,:));
end
end

===============================================

24
% m-file for working out the computational
% complexities of a 2-stage decimator
% Program name: mrate-ex1.m
%
dp=0.01; ds=0.01; dp1=dp/2; ds1=ds;
fp=5000;
Fi=1536000; F0=12000;
M=Fi/F0; M1=16; M2=8;
F1=Fi/M1; F2=F1/M2;
fs1=F1-(Fi/(2*M)); fs2=F2-(Fi/(2*M));
df1=(fs1-fp)/Fi; df2=(fs2-fp)/F1;
NUM= -10*log10(dp1*ds1)-13;
N1=(NUM/(14.6*df1)); N2=(NUM/(14.6*df2));
MPS=(N1*F1 + N2*F2); TSR = N1+N2;
M1
M2
fs1
fs2
df1
df2
N1
N2
MPS
======================================

function DecimationFactors = GetFactors(M,n)

% The function GetFactors finds all possible decimation factors for

% 2-, 3-, and 4-stage decimation. M is the
% overall decimation factor and n is the number of stages

p = floor(M/(2^(n-1)));
m = 1;
for i=2:p
for j=2:p
if n==2&i*j==M
R(m,1) = i; % get the 2-stage decimator factors
R(m,2) = j;
m = m + 1;
elseif n>2
for k=2:p
if n==3&i*j*k==M
R(m,1) = i; % get the 3-stage
R(m,2) = j; % decimator factors
R(m,3) = k;
m = m + 1;
elseif n>3
for l=2:p
if i*j*k*l==M
R(m,1) = i; % get the 4-stage
R(m,2) = j; % decimator
factors
R(m,3) = k;
R(m,4) = l;
m = m + 1;
end

25
 end
end
end
end
end
end
R = fliplr(sort(R')'); % sort the decimation factor vectors
z = zeros(1,size(R,2));
k = 1;
for i=1:size(R,1) % reject the redundancies
for j=i+1:size(R,1)
if R(i,:)==R(j,:)
R(j,:) = z;
end
end
if R(i,:)~=z
DecimationFactors(k,:) = R(i,:);
k = k + 1;
end
end

==========================================================

function decimation

%program performs multi-stages of decimation on data in a user-specified

data file
%enough data must be guaranteed when using a large overall decimation
fator

clear all;

r = [2 2 3 2]; % decimation factor array for different stages

FIR = 0; % 1 - use FIR filter, 0 - use IIR filter
n = 0; % order of IIR filter or FIR filter length
% n=0 for 30 points FIR filter or 8th order Chebyshev
type I LPF filter
in = fopen('decimation.dat','r') ;
[x,count] = fscanf(in,'%g',inf); % data to be decimated
y = x;
fclose(in);
for i=1:length(r)
if n==0 %decimating data use default filter
if FIR
y = decimate(y,r(i),'fir');
else
y = decimate(y,r(i));
end
else
if FIR
y = decimate(y,r(i),n,'fir');
else
y = decimate(y,r(i),n);
end
end
end

26
plot(1:count,x,1:prod(r):count,y(1:length(y)),'o');

===========================================================

function EvalNStageDecimator(Fs,fp,dp,ds,R)

format long;
a1 = 0.005309; a2 = 0.07114; a3 = -0.4761; a4 = -0.00266;
a5 = -0.5941; a6 = -0.4278; a7 = 11.01217; a8 = 0.51244;
dp = 10^(dp/20.0)-1; ds = 10^(-ds/20.0);
Ftemp = Fs;

dp = dp/length(R);
MPS = 0; TSR = 0;
fprintf('stage\tfactor\tFi\tfp\tfs\tdp\tds\tN\n');
for i=1:length(R) % n=size(R,1) possible k-stages decimators
F = Ftemp/R(i);
fs = F - Fs/2/prod(R);
df = (fs - fp)/Ftemp;
Ftemp = F;
N = round((log10(ds)*(a1*log10(dp)^2+a2*log10(dp)+a3)+...
a4*log10(dp)^2+a5*log10(dp)+a6)/df-df*(a7+a8*(log10(dp)-
log10(ds)))+1);
fprintf('%d\t%d\t%d\t%d\t%d\t%-7.4f\t%-7.4f\t
%d\n',i,R(i),F,fp,fs,dp,ds,N);
MPS = MPS + N*F;
TSR = TSR + N;
end
fprintf('MPS = %d, TSR = %d\n\n',MPS,TSR);
format;

========================

function interpolation

%program performs multi-stages interpolation on data in a user-specified

data file

clear all;

r = [2 1 1]; % decimation factor array for different stages

l = 4; % filter length
alpha = 0.5; % cut-off frequency
in = fopen('decimation.dat','r') ;
[x,count] = fscanf(in,'%g',inf); % data to be decimated
y = x;
fclose(in);
for i=1:length(r)
y = interp(y,r(i),l,alpha);
end
subplot(1,2,1);stem(x);subplot(1,2,2);stem(y);

27
Chapter 10 Adaptive filters

function LMSADF

%Program to illustrate adaptive filtering using the LMS algorithms

% X delayed input data vector

% Y measured signal
% W coefficient vector
% E enhanced signal

N=30; % filter length

M=0; % delay
w0=1; % initial value for adaptive filter coefficients
SF=2048; % factor for reducing the data samples - 11 bit ADC assumed
mu=0.04;
X = zeros(N,1);
delay = zeros(1,M+1);
W = w0*ones(N,1);
in = fopen('ADF.dat','r'); %read input data from specified data file
Y = fscanf(in,'%g',inf)/SF;
fclose(in);
if w0==0
sf = SF; % scaling factor for display
else
sf = SF/N/w0;
end
for i=1:length(Y)
if M>0
delay(2:M+1) = delay(1:M); % shift data for delay
end
delay(1) = Y(i);
X(2:N) = X(1:N-1); % update buffer
X(1) = delay(M+1);
E(i) = Y(i)-W'*X; % the enhanced signal
W = W + 2*mu*E(i)*X; % update the weights
end
subplot(2,1,1),plot(1:length(Y),Y*SF); title('Input Signal');
subplot(2,1,2),plot(1:length(E),E*sf); title('Enhanced Signal');

====================================================

function UDUADF
% program to illustrate adaptive filtering using
% the RLS algorithm via the UDU factorization

% X delayed input data vector

% Y measured signal
% W coefficient vector
% E enhanced signal

clear all;

N = 30; % filter length

28
M = 1; % delay
npt = N*(N+1)/2;
SF = 2048; % 12-bit ADC scaling
p0 = 0.05;
w0 = 1;
gamma = 0.98;
RemoveMean = 0; % 1 - remove the mean from the data, 0 - otherwise

delay = zeros(1,M);
U=zeros(1,npt);
U(1)=p0;
W = w0*ones(N,1);
X = zeros(N,1);
for i=1:N-1
ik=(i*(i+1)-2)/2+1;
U(ik)=p0;
end

if w0==0
sf = SF; % scaling factor for display
else
sf = SF/N/w0;
end

in = fopen('ADF.dat','r'); %read input data from specified data file

Y = fscanf(in,'%g',inf)/SF;
fclose(in);

if RemoveMean % remove the mean from the data if

required
Y = Y - sum(Y)/length(Y);
end

for i=1:length(Y)
if M>0
delay(2:M+1) = delay(1:M); % shift input data in delay
registers
end
delay(1) = Y(i);
X(2:N) = X(1:N-1); % update buffer
X(1) = delay(M+1);

E(i) = Y(i) - X'*W; % the enhanced signal

W = uduflt(W,X,U,E(i),gamma ,N);
end
subplot(2,1,1),plot(1:length(Y),Y*SF); title('Input Signal');
subplot(2,1,2),plot(1:length(E),E*sf); title('Enhanced Signal');

==========================================

29
function w=uduflt(w,x,u,ek,gamma,N)
% udu algorithm - a numerically stable form of
% the recursive least squares algorithm
%
% inputs:
% x() input vector
% dn latest input data value
% w() coefficient vector
% u() vector containing elements of U and D
%
% outputs:
% en error signal
% yn digital filter output
% w() updated coefficient vector
% u() updated elements of U and D
%

sf = 1/gamma;

m=1; % update the UD elements

v=zeros(1,N);
v(1)=x(1);
for j=2:N
v(j)=x(j);
for k=1:j-1
m=m+1;
v(j)=v(j)+u(m)*x(k);
end
m=m+1;
b(j)=u(m)*v(j);
end
b(1)=u(1)*x(1);
alpha=gamma+b(1)*v(1);
delta=1/alpha;
u(1)=u(1)*delta;

m=1;
for j=2:N
beta1=alpha;
alpha=alpha+b(j)*v(j);
p=-v(j)*delta;
delta=1/alpha;
for k=1:j-1
m=m+1;
beta=u(m);
u(m)=beta+b(k)*p;
b(k)=b(k)+b(j)*beta;
end
m=m+1;
u(m)=u(m)*beta1*delta*sf;
end
perr=ek/alpha;
for j=1:N % update the weights
w(j)=w(j)+b(j)*perr;
end

30
============================================

function SQRTADF
% program to illustrate adaptive filtering using
% the square root RLS algorithm

% X delayed input data vector

% Y measured signal
% W coefficient vector
% E enhanced signal

N = 30; % filter length

M = 1; % delay
npt = N*(N+1)/2;
SF = 2048; % 12-bit ADC scaling
p0 = 0.05;
w0 = 1;
gamma = 0.98;
RemoveMean = 0; % 1 - remove the mean from the data, 0 - otherwise

delay = zeros(1,M);
W = w0*ones(N,1);
X = zeros(N,1);
S = zeros(1,npt);
S(1)=p0;
for i=1:N-1
ik=(i*(i+1)-2)/2+1;
S(ik)=p0;
end

if w0==0
sf = SF; % scaling factor for display
else
sf = SF/N/w0;
end

in = fopen('ADF.dat','r'); %read input data from specified data file

Y = fscanf(in,'%g',inf)/SF;
fclose(in);

if RemoveMean % remove the mean from the data if

required
Y = Y - sum(Y)/length(Y);
end

for i=1:length(Y)
if M>0
delay(2:M+1) = delay(1:M); % shift input data in delay
registers
end
delay(1) = Y(i);
X(2:N) = X(1:N-1); % update buffer
X(1) = delay(M+1);

E(i) = Y(i) - X'*W; % the enhanced signal

31
 W = sqrtflt(W,X,E(i),S,gamma,N);
end
subplot(2,1,1),plot(1:length(Y),Y*SF); title('Input Signal');
subplot(2,1,2),plot(1:length(E),E*sf); title('Enhanced Signal');

==================================================

function w=sqrtflt(w,x,perr,s,gamma,N)

% A simple square root RLS adaptive filter

% For details, see:
% Digital Signal Processing: A Practical Approach
% E C Ifeachor and B W Jervis, Pearson, 2002

forgt=sqrt(gamma);
sig=forgt;
sigsq=forgt*forgt;
ij=1; ji=1;
for j=2:N
fj=0.0;
for i=1:j-1
ji=ji+1;
fj=fj+s(ji)*x(i);
end
a=sig/forgt;
b=fj/sigsq;
sigsq=sigsq+fj*fj;
sig=sqrt(sigsq);
a=a/sig;
g(j)=s(ji)*fj;
s(ji)=a*s(ji);
for i=1:j-1
ij=ij+1;
sqp=s(ij);
s(ij)=a*(sqp-b*g(i));
g(i)=g(i)+sqp*fj;
end
ij=ij+1;
end
w = w + g'*perr/sigsq;

=============================
function RLSadf
% program to illustrate adaptive filtering using
% the RLS algorithm

% X delayed input signal

% Y measured signal
% W coefficient vector
% E enhanced signal

N = 30; % filter length

M = 1; % stages of delay
SF = 2048; % 12-bit ADC scaling
p0 = 0.05;

32
w0 = 100;
gamma = 0.98;
RemoveMean = 0; % 1 to remove the mean, 0 otherwise
W = w0*ones(N,1); % adaptive filter weights
X = zeros(N,1);
delay = zeros(1,M+1);
P = p0*diag(ones(1,N),0);
if w0==0
sf = SF; % scaling factor for display
else
sf = SF/N/w0;
end

in = fopen('ADF.dat','r'); %read input data from specified data file

Y = fscanf(in,'%g',inf)/SF;
fclose(in);

if RemoveMean % remove the mean from the data if required

Y = Y - sum(Y)/length(Y);
end

for i=1:length(Y)
if M>0
delay(2:M+1) = delay(1:M); % shift input data in delay
registers
end
delay(1) = Y(i);
X(2:N) = X(1:N-1); % update buffer
X(1) = delay(M+1);

E(i) = Y(i) - X'*W; % the enhanced signal

G = P*X/(gamma + X'*P*X);
P = (P - G*X'*P)/gamma;
W = W + G*E(i); % update the weights
end
subplot(2,1,1),plot(1:length(Y),Y*SF); title('Input Signal');
subplot(2,1,2),plot(1:length(E),E*sf); title('Enhanced Signal');

========================================

Chapter 11 Spectrum estimation and analysis

N/A

33
Chapter 12 General and special-purpose digital signal processors.

function cgdft
% function cgdft compute DFT coefficients using DIT FFT algorithm
% function cgfft.m is used to implement the constant geometry FFT

clear all;
direction = 1; %1 - forward DFT, -1 - inverse DFT
in=fopen('datain.dat','r');
[x,count]=fscanf(in,'%g %g',[2 inf]);
fclose(in);
x = x(1,:)+x(2,:)*i; % form complex numbers
npt = 2^(nextpow2(count/2)); % find the next power of two
x(1:npt) = [x; zeros(npt-count/2,1)]; % x is padded with trailing zeros
to npt

y=cgfft(x,npt,direction); % calculate the constant geometry FFT

% Save/Print the results

out=fopen('dataout.dat','w');
fprintf(out,'%g %g\n',[real(y); imag(y)]);
fclose(out);
subplot(2,1,1),plot(1:npt,x); title('Input Signal');
subplot(2,1,2),plot(1:npt,y); title('Output Signal');

===============================================

function x=cgfft(x,npt,direction)

% Function computes the DFT of a sequence using radix2 FFT

% with constant geometry

% in-place bit reverse shuffling of data

j=2;
for n=2:npt
if n<j
t = x(j-1);
x(j-1) = x(n-1);
x(n-1) = t;
end
k = npt/2;
while k<j-1
j = j-k;
k = k/2;
end
j = j+k;
end
m = log2(npt); % calculate the number of stages: m=log2(npt)

34
w = exp(direction*2*pi*(0:npt/2-1)/npt*i); % pre-compute the twiddle
factors

% perform the FFT computation for each stage

for d=1:m
n = 1;
dk = 2^(d-1);
dr = npt/(2^d);
for k=0:dk-1
p = (k*npt)/(2^d)+1;
for r=1:dr
if rem(d,2)~=0
t = x(2*n)*conj(w(p));
x1(n) = x(2*n-1)+t;
x1(npt/2+n) = x(2*n-1)-t;
else
t = x1(2*n)*conj(w(p));
x(n) = x1(2*n-1)+t;
x(npt/2+n) = x1(2*n-1)-t;
end
n = n+1;
end
end
end
if rem(m,2)~=0
x = x1;
end

%If inverse fft is desired divide each coefficient by npt

if direction==-1
x = x /npt;
end

Chapter 13 Analysis of finite wordlength effects in fixed-point DSP systems.

N/A

Chapter 14 Applications and design studies

N/A

35