jens/matlab
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

- added

Browse Source 
git-svn-id: http://moon:8086/svn/matlab/trunk@153 801c6759-fa7c-4059-a304-17956f83a07c
This commit is contained in:
jens
2021-03-22 20:28:22 +00:00
parent 1b5742e13e
commit b31f3e7435
140 changed files with 6054 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
common/alpha.m
Executable
+13
View File
@@ -0,0 +1,13 @@
% a = alpha(xs,xl,nl,pl,es,dts,pa)
function a = alpha(xs,xl,nl,pl,es,dts,pa)
N = lge(xs);
for n = 1:N,
if((xs(n) > pl*xl(n)) & (dts(n)*es(n) >= pa*es(n)))
% a(n) = ((es(n)-nl(n)+0.001)/(es(n)+0.001))^2;
a(n) = max(1-nl(n)/(es(n)+0.008),0)^2;
else
a(n) = 0;
end;
end;
common/ccorr.m
Executable
+52
View File
@@ -0,0 +1,52 @@
% Kreuzkorrelation von x und y
% ----------------------------
%
% Aufruf:
% Function [rxy,fpo]=ccorr(x,y,N)
%
% Parameter:
% x : Eingangsdaten 1
% y : Eingangsdaten 2
% N : Maximale Verschiebung der Eingangsdaten
%
% Rückgabewerte:
% rxy: Kreuzkorrelationskoeffzienten
% fpo: Anzahl der Floating-Point Operationen
% -------------------------------------------------------------------------
% Datum : 07.08.2001
% Autor : Jens Ahrensfeld
% Thema : Diplomarbeit
% Datei : ccorr.m
% Benötigte Dateien:
%
% -------------------------------------------------------------------------
function [rxy,fpo]=ccorr(x,y,N)
% Ermittling der FFT-Länge (für Radix-2)
C = 2^ceil(log2(N));
% Zero-Padding wenn N != 2^r
xzp = [x;zeros(C-N,1)];
yzp = [y;zeros(C-N,1)];
flops(0);
% C-Punkte FFT der Eingangsdaten
Xk = fft(xzp,C);
Yk = fft(yzp,C);
% Korrelation im Frequenzbereich
Rk = Xk.*conj(Yk);
% Rücktransformation
rk = ifft(Rk,C)/C;
% Abspeichern der ersten N Werte
rxy(1:N/2) = rk(N/2+1:N);
rxy(N/2+1:N) = rk(1:N/2);
fpo = flops;
% -------------------------------------------------------------------------
% Ende ccorr.m
common/ccorr2.m
Executable
+32
View File
@@ -0,0 +1,32 @@
% Kreuzkorrelation von x und y
% ----------------------------
%
% Aufruf:
% Function [rxy]=ccorr2(x,y,M)
%
% Parameter:
%
% Rückgabewerte:
% -------------------------------------------------------------------------
% Datum : ..2001
% Autor : Jens Ahrensfeld
% Thema : Diplomarbeit
% Datei : newfunc.m
% Benötigte Dateien:
%
% -------------------------------------------------------------------------
function [rxy]=ccorr2(x,y,M)
% Berechne Erwartungswert xm, ym von X und Y im Intervall N
for n = N:N:L-W,
rmax(k) = 0;
for w = 0:W-1
sxy(k) = sum(x(n+w:-1:n-N+1+w).*y(n:-1:n-N+1));
sxym(k) = sum(abs(x(n+w:-1:n-N+1+w).*y(n:-1:n-N+1)));
rmax(k) = max(sxy(k)/sxym(k),rmax(k));
end;
% r(n:-1:n-N+1) = ones(N,1)*sxy(k)/sxym(k);
r(n:-1:n-N+1) = ones(N,1)*min(rmax(k),1);
k = k+1;
end;
common/cdkap2.m
Executable
+2
View File
@@ -0,0 +1,2 @@
cd f:
cd \work\dpa\matlab\sim\kap2
common/cdkap4.m
Executable
+2
View File
@@ -0,0 +1,2 @@
cd f:
cd \work\dpa\matlab\sim\kap4
common/cic_filter.m
Executable
+30
View File
@@ -0,0 +1,30 @@
function [y, gain] = cic_filter(R, M, N, x)
% [y, gain] = cic_filter(R, M, N, x)
a_i = [1 -1];
b_i = 1;
a_c = 1;
b_c = [1 zeros(1, M-1) -1];
gain = (M*R)^N
k_i = 1/(M*R);
i_out = x;
% Integrator
for i=1:N,
i_out = k_i*filter(b_i, a_i, i_out);
end;
% Decimate
c_out = i_out(R:R:length(i_out));
% Comb
for i=1:N,
c_out = filter(b_c, a_c, c_out);
end;
y = c_out;
common/cielab2xyz.m
Executable
+45
View File
@@ -0,0 +1,45 @@
% function [xyz] = cielab2xyz(lab, ref_xyz)
%
% // C-Code
% var_Y = ( CIE-L* + 16 ) / 116
% var_X = CIE-a* / 500 + var_Y
% var_Z = var_Y - CIE-b* / 200
%
% if ( var_Y^3 > 0.008856 ) var_Y = var_Y^3
% else var_Y = ( var_Y - 16 / 116 ) / 7.787
% if ( var_X^3 > 0.008856 ) var_X = var_X^3
% else var_X = ( var_X - 16 / 116 ) / 7.787
% if ( var_Z^3 > 0.008856 ) var_Z = var_Z^3
% else var_Z = ( var_Z - 16 / 116 ) / 7.787
%
% X = ref_X * var_X //ref_X = 95.047 Observer= 2°, Illuminant= D65
% Y = ref_Y * var_Y //ref_Y = 100.000
% Z = ref_Z * var_Z //ref_Z = 108.883
%
% Source http://www.easyrgb.com
function [xyz] = cielab2xyz(lab, ref_xyz)
[m,n] = size(lab);
if ((m ~= 3) & (n == 3))
lab = lab'
end;
xyz_k(2,:) = (lab(1,:) + 16)/116;
xyz_k(1,:) = lab(2,:)/500 + xyz_k(2,:);
xyz_k(3,:) = xyz_k(2,:) - lab(3,:)/200;
xyz = f1(xyz_k);
xyz(1,:) = xyz(1,:).*ref_xyz(1,:);
xyz(2,:) = xyz(2,:).*ref_xyz(2,:);
xyz(3,:) = xyz(3,:).*ref_xyz(3,:);
function xyz = f1(xyz_k)
thresh_n = 0.008856;
[idx_m, idx_n] = find(xyz_k.^3 > thresh_n);
xyz(idx_m,idx_n) = xyz_k(idx_m,idx_n).^3;
[idx_m, idx_n] = find(xyz_k.^3 <= thresh_n);
xyz(idx_m,idx_n) = (xyz_k(idx_m,idx_n) - 16/116)/7.787;
common/clusters.m
Executable
+29
View File
@@ -0,0 +1,29 @@
% clusters.m
% function cb = clusters(input,ref,maxIt)
% clusters(randn(2,400)/sqrt(12),randn(2,1)/sqrt(12));
% 17.01.2003, Jens Ahrensfeld
function cb = clusters(input,ref,maxIt)
eps = 0.4;
epse = 0.001;
[nDim, nData] = size(input);
[nDimr, nDatar] = size(ref);
if (nDim ~= nDimr),
error('Dimensions must match!');
end;
d = zeros(nDatar,1);
for i=1:maxIt,
n = round(rand(1,1)*(nData-1))+1; % Randomly pick input vector
for k=1:nDatar,
d(k) = sqrt(sum((input(:,n)-ref(:,k)).^2)); % Calc distances between references and input
end;
[min, winidx] = min(d); % Calc best reference vector - the winner
winner = ref(:,winidx);
epsi = eps*(1-i/maxIt)+epse;
ref(:,winidx) = winner + epsi*(input(:,n)-winner); % Move winner towards input
end;
cb = ref;
common/clusters_ob.m
Executable
+144
View File
@@ -0,0 +1,144 @@
% cltest.m
% function cltest(dim, numvecperclass, classdist, numClasses, numref, maxIt);
% Sample cltest(2, 80, 8, 3, 3, 800)
% 17.01.2003, Jens Ahrensfeld
% From
% "Color Quantization of Images", Orchard, Bouman
% IEEE Trans. on Sig. Proc., vol. 39, no. 12, pp. 2677-2690, Dec. 1991.
function [cb, idx] = clusters_ob(xs,M,tse_max)
[nc,len] = size(xs);
% Root node
tree(1) = node_root(xs, 1:len);
tse = 0;
node = tree(1);
end_nodes = 1;
num_nodes = 1;
lambdas = tree(1).lambda;
map = node.q;
for m=1:M-1,
if (num_nodes == 0)
break;
end;
[v, i] = max(lambdas);
n = end_nodes(i);
node = tree(n);
L_n = node.lambda;
num_nodes = num_nodes - 1;
if(node.tse < tse_max)
break;
end;
if L_n == 0
continue;
end;
lambdas(i) = [];
end_nodes(i) = [];
[node2n, node2n1] = node_split(xs, node);
if((node2n.N * node2n1.N) == 0)
disp('No further split');
continue;
end;
tree(2*n) = node2n;
tree(2*n+1) = node2n1;
L2n = tree(2*n).lambda;
L2n1 = tree(2*n+1).lambda;
end_nodes = [end_nodes 2*n 2*n+1];
lambdas = [lambdas L2n L2n1];
num_nodes = num_nodes + 2;
tse = tse + tree(n).tse;
end;
map = [tree(end_nodes).q];
lambda = [tree(end_nodes).lambda];
len = length(lambda);
[v,i] = sort(lambda);
s = i(len:-1:1);
cnt = 1;
for s=s,
if (isempty(tree(s).C))
break
end
idx{cnt} = tree(s).C;
cb(:,cnt) = map(:,s);
cnt = cnt + 1;
end;
v;
% ---------------------------------------------------------
function [node_2n, node_2n1] = node_split(xs, node)
C_n = node.C;
e_n = node.e;
q_n = node.q;
i = find(e_n'*xs(:,C_n) <= e_n'*q_n);
C_2n = C_n(i);
i = find(e_n'*xs(:,C_n) > e_n'*q_n);
C_2n1 = C_n(i);
xs_2n = xs(:,C_2n);
xs_2n1 = xs(:,C_2n1);
R_n = node.R;
m_n = node.m;
N_n = node.N;
R_2n = xs_2n*xs_2n';
m_2n = sum(xs_2n,2);
N_2n = length(C_2n);
R_2n1 = R_n - R_2n;
m_2n1 = m_n - m_2n;
N_2n1 = N_n - N_2n;
node_2n = struct('R',R_2n,'m',m_2n,'N',N_2n,'C',C_2n,'q',0,'e',0,'lambda',0, 'tse', 0);
node_2n1 = struct('R',R_2n1,'m',m_2n1,'N',N_2n1,'C',C_2n1,'q',0,'e',0,'lambda',0, 'tse', 0);
node_2n = node_stat(node_2n, xs);
node_2n1 = node_stat(node_2n1, xs);
% ---------------------------------------------------------
function out = node_root(xs, C)
xs_n = xs(:,C);
R = xs_n*xs_n';
m = sum(xs_n,2);
N = length(C);
node = struct('R',R,'m',m,'N',N,'C',C,'q',0,'e',0,'lambda',0, 'tse', 0);
out = node_stat(node, xs);
% ---------------------------------------------------------
function out = node_stat(in, xs)
xs_n = xs(:,in.C);
Cov_n = in.R - 1/in.N*in.m*in.m';
[ev,es] = eig(Cov_n);
[max_v,max_i] = max(diag(es));
e_n = ev(:,max_i);
q_n = in.m/in.N;
tse_n = norm(xs_n-repmat(q_n,1,in.N))^2;
lambda_n = sum(((xs_n - repmat(q_n,1,in.N))'*e_n).^2);
in.e = e_n;
in.q = q_n;
in.tse = tse_n;
in.lambda = lambda_n;
out = in;
common/clusters_ransac.m
Executable
+37
View File
@@ -0,0 +1,37 @@
% clusters.m
% function cb = clusters(input,ref,maxIt)
% clusters(randn(2,400)/sqrt(12),randn(2,1)/sqrt(12));
% 17.01.2003, Jens Ahrensfeld
function [cb, idx, output] =clusters_ransac(input,max_distance,move_thresh)
cl_count = 0;
[nDim, nData] = size(input);
points_remain = input;
while length(points_remain) > 0,
[nDim,nRem] = size(points_remain);
new_idx = round(rand(1,1)*(nRem-1))+1;
ref = points_remain(:,new_idx);
ref_last = zeros(nDim,1);
d_max = 2*move_thresh;
while d_max > move_thresh
d = sqrt(sum((points_remain-repmat(ref,1,nRem)).^2)); % Calc distances between references and input
points_assigned_idx = find(d <= max_distance);
num_assigned = length(points_assigned_idx);
if (num_assigned > 0);
ref = mean(points_remain(:,points_assigned_idx),2);
d_max = max(sqrt(sum((ref_last-ref).^2)));
ref_last = ref;
else
break;
end;
end;
cl_count = cl_count +1;
output{cl_count} = points_remain(:,points_assigned_idx);
idx{cl_count} = points_assigned_idx;
points_remain(:,points_assigned_idx) = [];
cb(:,cl_count) = ref;
end;
common/coef.m
Executable
+71
View File
@@ -0,0 +1,71 @@
% COEF generiert IIR-Tiefpass Koeffizienten für geradzahlige Ordnung
% [b,a] = coef(fa,fg,Q,N)
%
% fa : Abtastfrequenz [Hz]
% fg : Grenzfrequenz [Hz] fg <= fa/2
% Q : Polgüte (Q=1.0 für Butterworth)
% N : Filterordnung (durch zwei teilbar)
% Type : 'Lowpass', 'Highpass', 'Bandpass', 'Bandstop'
%
function [b,a] = coef(fa,fg,Q,N,Type)
if (rem(N,2) > 0)
error('Filterordnung muss z.Zt. noch durch zwei teilbar sein!');
end;
if (strcmp(Type,'Bandstop'))
TF = 4;
end;
TF
sn = sin(2*pi*fg/fa);
cs = cos(2*pi*fg/fa);
ak = ones(N/2,3);
bk = ones(N/2,3);
a = 1;
b = 1;
if (strcmp(Type,'Lowpass'))
for n = 1:N/2,
Qp = 1/(2*sin(pi*(n-0.5)/N))
alpha = sn/(2*Q*Qp);
a0 = 1+alpha;
ak(n,2) = -2*cs/a0;
ak(n,3) = (1-alpha)/a0;
bk(n,1) = 0.5*(1-cs)/a0;
bk(n,2) = (1-cs)/a0;
bk(n,3) = 0.5*(1-cs)/a0;
a = conv(a,ak(n,(1:3)));
b = conv(b,bk(n,(1:3)));
end;
end;
if (strcmp(Type,'Highpass'))
for n = 1:N/2,
Qp = 1/(2*sin(pi*(n-0.5)/N))
alpha = sn/(2*Q*Qp);
a0 = 1+alpha;
ak(n,2) = -2*cs/a0;
ak(n,3) = (1-alpha)/a0;
bk(n,1) = 0.5*(1+cs)/a0;
bk(n,2) = -(1+cs)/a0;
bk(n,3) = 0.5*(1+cs)/a0;
a = conv(a,ak(n,(1:3)));
b = conv(b,bk(n,(1:3)));
end;
end;
if (strcmp(Type,'Bandpass'))
for n = 1:N/2,
Qp = 1/(2*sin(pi*(n-0.5)/N))
alpha = sn/(2*Q*Qp);
a0 = 1+alpha;
ak(n,2) = -2*cs/a0;
ak(n,3) = (1-alpha)/a0;
bk(n,1) = alpha/a0;
bk(n,2) = 0;
bk(n,3) = -alpha/a0;
a = conv(a,ak(n,(1:3)));
b = conv(b,bk(n,(1:3)));
end;
end;
common/color_conv.m
Executable
+8
View File
@@ -0,0 +1,8 @@
function out = color_conv(in, type_in, type_out)
[ny,nx,nc] = size(in)
% Get LAB-Data
color_write('color_in.dat',reshape(in,nc,ny*nx));
commandStr = sprintf('color_conv.exe %s %s %s %s','color_in.dat', 'color_out.dat',type_in, type_out);
dos(commandStr);
out = reshape(color_read('color_out.dat'), ny,nx,nc);
common/color_conv_v.m
Executable
+8
View File
@@ -0,0 +1,8 @@
function out = color_conv(in, type_in, type_out)
[ny,nx] = size(in)
% Get LAB-Data
color_write('color_in.dat',in);
commandStr = sprintf('color_conv.exe %s %s %s %s','color_in.dat', 'color_out.dat',type_in, type_out);
dos(commandStr);
out = color_read('color_out.dat');
common/color_read.m
Executable
+20
View File
@@ -0,0 +1,20 @@
function data = color_read(name)
item_size = 8;
fid = fopen(name,'r');
if(fid < 0)
data = fid;
return;
end;
version = fread(fid,1,'uint');
prec_type = fscanf(fid,'%s',1);
fread(fid,1,'uint8');
n_rows = fread(fid,1,'uint');
n_cols = fread(fid,1,'uint');
data_size = fread(fid,1,'uint');
data = reshape(fread(fid,n_rows*n_cols,prec_type),n_rows,n_cols);
[n_rows,n_cols] = size(data)
fclose(fid);
common/color_write.m
Executable
+16
View File
@@ -0,0 +1,16 @@
function color_write(name, data)
[n_rows,n_cols] = size(data)
item_size = 8;
prec_type = 'float64';
fid = fopen(name,'w');
fwrite(fid,1,'uint');
fprintf(fid,'%s',prec_type);
fwrite(fid,13,'uint8');
fwrite(fid,n_rows,'uint');
fwrite(fid,n_cols,'uint');
fwrite(fid,n_rows*n_cols*item_size,'uint');
fwrite(fid,data(:),prec_type);
fclose(fid);
common/correlt.m
Executable
+15
View File
@@ -0,0 +1,15 @@
% correl(x,y,N)
function rxy = correlt(x,y,S)
L = lge(x);
N = L-S;
if (N == 0)
error('N = 0 !');
end;
for s=1:S,
rxy(s)=sum(x(S-s+1:L-s+1).*y(S:L))^2/(sum(x(S-s+1:L-s+1).^2)*sum(y(S:L).^2));
%rxy(s)=abs(sum(x(S-s+1:L-s+1).*y(S:L)))/(sum(abs(x(S-s+1:L-s+1).*y(S:L)))+0.0001);
end;
common/corrja.m
Executable
+15
View File
@@ -0,0 +1,15 @@
% correl(x,y,N)
function rxy = corrph(x,y,S)
L = lge(x);
N = L-S;
if (N == 0)
error('N = 0 !');
end;
for s=1:S,
%rxy(s)=sum(x(S-s+1:L-s+1).*y(S:L))^2/(sum(x(S-s+1:L-s+1).^2)*sum(y(S:L).^2));
rxy(s)=abs(sum(x(S-s+1:L-s+1).*y(S:L)))/(sum(abs(x(1:L).*y(1:L)))+0.0001);
end;
common/corrlp.m
Executable
+15
View File
@@ -0,0 +1,15 @@
% correl(x,y,N)
function rxy = corrlp(x,y,S)
L = lge(x);
N = L-S;
if (N == 0)
error('N = 0 !');
end;
for s=1:S,
rxy(s)=sum(x(S-s+1:L-s+1).*y(S:L))^2/(sum(x(S-s+1:L-s+1).^2)*sum(y(S:L).^2));
%rxy(s)=abs(sum(x(S-s+1:L-s+1).*y(S:L)))/(sum(abs(x(S-s+1:L-s+1).*y(S:L)))+0.0001);
end;
common/corrph.m
Executable
+17
View File
@@ -0,0 +1,17 @@
% correl(x,y,N)
function rxy = corrph(x,y,S)
L = lge(x);
N = L-S;
if (N == 0)
error('N = 0 !');
end;
for s=0:S-1,
%rxy(s)=sum(x(S-s+1:L-s+1).*y(S:L))^2/(sum(x(S-s+1:L-s+1).^2)*sum(y(S:L).^2));
%rxy(s)=abs(sum(x(S-s+1:L-s+1).*y(S:L)))/(sum(abs(x(S-s+1:L-s+1).*y(S:L)))+0.0001);
rxy(s+1)=sum(x(1:L-S).*y(1+s:L-S+s))/(sum(abs(x(1:L-S).*y(1+s:L-S+s)))+0.001);
%rxy(s+1)=sum((x(1:L-S).^2).*(y(1+s:L-S+s).^2))/(sum(x(1:L-S).^2 + y(1+s:L-S+s).^2) +0.001);
end;
common/dat2wav.m
Executable
+17
View File
@@ -0,0 +1,17 @@
% function y = dat2wav(name, fa, nBits, ampthresh)
%
function y = dat2wav(name, fa, nBits, ampthresh)
datfile = sprintf('%s.dat', name);
wavfile = sprintf('%s.wav', name);
fid = fopen(datfile,'r');
data_float = fread(fid, 'float32');
fclose(fid);
a = max(abs(data_float));
ks = ampthresh/a;
data = (2^(nBits-1))*ks*data_float;
wavw16(data,fa,wavfile);
common/dosa.m
Executable
+10
View File
@@ -0,0 +1,10 @@
% correl(x,y,N)
function xm = dosa(x,fa,M)
xf = iirtp(fa,0.45*fa/M,1,8,x);
xm = xf(1:M:lge(x));
common/dspfft.m
Executable
+3
View File
@@ -0,0 +1,3 @@
% X = DSPFFT(x,C)
function X = dspfft(x,C)
X = fft(x,C)/C;
common/dspifft.m
Executable
+3
View File
@@ -0,0 +1,3 @@
% x = DSPIFFT(X,C)
function x = dspifft(X,C)
x = ifft(X,C)*C;
common/dtdet01.m
Executable
+85
View File
@@ -0,0 +1,85 @@
% dtdet3
function [a,rxds,xs,xl,es,clm,dtf] = dtdet(x,d,e,dti)
nstates = 9;
xsi = 1;
xli = 2;
dtsi = 3;
esi = 4;
nli = 5;
eli = 6;
rxdi = 7;
psxi = 8;
psdi = 9;
dtalki = 10;
% ------------------------------------------------------------------------
% Double-Talk-Detector params
ar = 0.05;
af = 0.005;
arrxd = 0.0004;
afrxd = 1.0;
al = 0.0001;
pa = 0.7;
pl = 2.0;
po = 0.93;
htime = 80;
% ------------------------------------------------------------------------
if (lge(dti) == 1);
dti = zeros(nstates,1);
dti(xli)=0.01;
dti(nli)=0.01;
dti(eli)=0.1;
dti(dtalki) = 0;
end;
% ------------------------------------------------------------------------
fa = 8000;
fc = 800;
L = lge(x);
M = 4;
% ------------------------------------------------------------------------
%d = iirtp(fa,fc,1,8,d);
%x = iirtp(fa,fc,1,8,x);
d = dosa(d,fa,M);
x = dosa(x,fa,M);
e = dosa(e,fa,M);
%[xs,dti(xsi)] = phxs(x,ar,af,dti(xsi));
%[xl,dti(xli)] = phxl(x,xs,al,pl,dti(xli));
rxd = max(abs(corrph(x,d,40/M)));
%[es,dti(esi)] = phxs(e,0.008,0.005,dti(esi));
%[el,dti(eli)] = phxl(e,es,0.0001,pl,dti(eli));
%[rxds,dti(rxdi)] = phxs(rxd*ones(L,1),arrxd,afrxd,dti(rxdi));
%[nl,dti(nli)] = phnl(e,es,el,xs,xl,al,pl,dti(nli));
%a = alpha(xs,xl,nl,pl,es,(rxd > po),pa);
if (rxd > po)
if(dti(dtalki)==1)
a = [zeros(htime,1);ones(L-htime,1)];
dti(dtalki)=0;
else
a = ones(L,1);
end;
else
a = zeros(L,1);
dti(dtalki)=1;
end;
rxds=ones(L,1)*rxd;
dtf = dti;
xs=1;
es=1;
xl=1;
clm=1;
% ------------------------------------------------------------------------
common/dtdet02.m
Executable
+82
View File
@@ -0,0 +1,82 @@
% dtdet3
function [a,rxds,xs,xl,ds,dl,dtf] = dtdet(x,d,e,dti)
nstates = 11;
xsi = 1;
xli = 2;
dtsi = 3;
dsi = 4;
dli = 5;
eli = 6;
rxdi = 7;
psxi = 8;
psdi = 9;
dtalki = 10;
esi = 11;
% ------------------------------------------------------------------------
% Double-Talk-Detector params
ar = 0.05;
af = 0.005;
arrxd = 0.0004;
afrxd = 1.0;
al = 0.0001;
pa = 0.7;
pl = 2.0;
po = 0.93;
arf = 0.0006;
htime = 80;
% ------------------------------------------------------------------------
if (lge(dti) == 1);
dti = zeros(nstates,1);
dti(xli)=0.1;
dti(dli)=0.1;
dti(xsi)=0.0;
dti(dsi)=0.0;
dti(eli)=0.1;
dti(dtalki) = 0;
end;
% ------------------------------------------------------------------------
fa = 8000;
fc = 800;
L = lge(x);
M = 1;
% ------------------------------------------------------------------------
%d = iirtp(fa,fc,1,8,d);
%x = iirtp(fa,fc,1,8,x);
d = dosa(d,fa,M);
x = dosa(x,fa,M);
e = dosa(e,fa,M);
[xs,dti(xsi)] = sm2(x,dti(xli),arf);
[xl,dti(xli)] = sm2(x,dti(xli),arf/M);
%[xl,dti(xli)] = phxl(x,xs,al,pl,dti(xli));
%[ds,dti(dsi)] = phxs(d,ar,af,dti(dsi));
[dl,dti(dli)] = sm2(d,dti(dli),arf/M);
[el,dti(eli)] = sm2(e,dti(eli),0.5*arf/M);
%[es,dti(esi)] = sm2(e,dti(esi),10*arf/M);
%[dl,dti(dli)] = phxl(d,ds,al,pl,dti(dli));
xs = zeros(L,1);
ds = zeros(L,1);
%rxd = max(abs(correlt(x,d,40/M)));
%[es,dti(esi)] = phxs(e,0.008,0.005,dti(esi));
%[el,dti(eli)] = phxl(e,es,0.0001,pl,dti(eli));
%[rxds,dti(rxdi)] = phxs(rxd*ones(L,1),arrxd,afrxd,dti(rxdi));
%[nl,dti(nli)] = phnl(e,es,el,xs,xl,al,pl,dti(nli));
%a = alpha(xs,xl,nl,pl,es,(rxd > po),pa);
a = zeros(L,1);
rxd = max(corrph(xl,dl,30));
a = (((xl(1:1.0/M:L/M)*rxd) > (pl*dl(1:1.0/M:L/M))));
rxds=0*ones(L,1);
dtf = dti;
xl = zeros(L,1);
dl = zeros(L,1);
% ------------------------------------------------------------------------
common/dtdet03.m
Executable
+85
View File
@@ -0,0 +1,85 @@
% dtdet3
function [a,rxds,xs,xl,es,clm,dtf] = dtdet(x,d,e,dti)
nstates = 9;
xsi = 1;
xli = 2;
dtsi = 3;
esi = 4;
nli = 5;
eli = 6;
rxdi = 7;
psxi = 8;
psdi = 9;
dtalki = 10;
% ------------------------------------------------------------------------
% Double-Talk-Detector params
ar = 0.05;
af = 0.005;
arrxd = 0.0004;
afrxd = 1.0;
al = 0.0001;
pa = 0.7;
pl = 2.0;
po = 0.93;
htime = 80;
% ------------------------------------------------------------------------
if (lge(dti) == 1);
dti = zeros(nstates,1);
dti(xli)=0.01;
dti(nli)=0.01;
dti(eli)=0.1;
dti(dtalki) = 0;
end;
% ------------------------------------------------------------------------
fa = 8000;
fc = 800;
L = lge(x);
M = 4;
% ------------------------------------------------------------------------
%d = iirtp(fa,fc,1,8,d);
%x = iirtp(fa,fc,1,8,x);
d = dosa(d,fa,M);
x = dosa(x,fa,M);
e = dosa(e,fa,M);
%[xs,dti(xsi)] = phxs(x,ar,af,dti(xsi));
%[xl,dti(xli)] = phxl(x,xs,al,pl,dti(xli));
rxd = min(max(corrja(x,d,30)),1);
%[es,dti(esi)] = phxs(e,0.008,0.005,dti(esi));
%[el,dti(eli)] = phxl(e,es,0.0001,pl,dti(eli));
%[rxds,dti(rxdi)] = phxs(rxd*ones(L,1),arrxd,afrxd,dti(rxdi));
%[nl,dti(nli)] = phnl(e,es,el,xs,xl,al,pl,dti(nli));
%a = alpha(xs,xl,nl,pl,es,(rxd > po),pa);
if (rxd > po)
if(dti(dtalki)==1)
a = [zeros(htime,1);ones(L-htime,1)];
dti(dtalki)=0;
else
a = ones(L,1);
end;
else
a = zeros(L,1);
dti(dtalki)=1;
end;
rxds=ones(L,1)*rxd;
dtf = dti;
xs=1;
es=1;
xl=1;
clm=1;
% ------------------------------------------------------------------------
common/eudist.m
Executable
+31
View File
@@ -0,0 +1,31 @@
% clusters.m
% function cb = clusters(input,ref,maxIt)
% clusters(randn(2,400)/sqrt(12),randn(2,1)/sqrt(12));
% 17.01.2003, Jens Ahrensfeld
function [indices, output] = eudist(input,ref)
[nDim, nData] = size(input);
[nDimr, nClasses] = size(ref);
if (nDim ~= nDimr),
error('Dimensions must match!');
end;
cnt = zeros(nClasses,1);
for j=1:nClasses,
indices{j} = [];
end;
for i=1:nData,
for j=1:nClasses,
d(j) = sqrt(sum((input(:,i)-ref(:,j)).^2)); % Calc distances between references and input
end;
[value nearestClass] = min(d);
cnt(nearestClass) = cnt(nearestClass) + 1;
indices{nearestClass} = [ indices{nearestClass} i ];
end;
% Separate data
for j=1:nClasses,
output{j} = input(:,indices{j});
end;
common/flms.m
Executable
+133
View File
@@ -0,0 +1,133 @@
% Frequency LMS Adaptive Filter -FLMS-
% ------------------------------------
%
% Aufruf:
% Function [ys,ee,wf,fpo]=flms(x,d,alpha,N,C,L,wi)
%
% Parameter:
% x : Eingangsvektor
% d : Referenzvektor
% alpha: konstante Schrittweite 0 < alpha <= 1.0
% N : Anzahl Filterkoeffizienten
% C : FFT-Länge, idealerweise eine Zweier-Potenz (0=Auto)
% L : Länge eines Verarbeitungsblocks (idealerweise C=L+N=2N)
% wi : Startwerte der Filterkoeffizienten im Zeitbereich
%
% Rückgabewerte:
% ee : Adaptitionsfehler
% ys : Filterausgang
% wf : Filterkoeffizienten am Ende der Adaption im Zeitbereich
% fpo : Anzahl benötigten der Floating-Point Operationen
% -------------------------------------------------------------------------
% Datum : 20.7.2001
% Autor : Jens Ahrensfeld
% Thema : Diplomarbeit
% Datei : flms.m
% Benötigte Dateien: dspfft.m, dspifft.m
%
% -------------------------------------------------------------------------
function [ys,ee,wf,fpo]=flms(x,d,alpha,N,C,L,wi)
% -------------------------------------------------------------------------
% Überprüfen der Parameter
% -------------------------------------------------------------------------
if (N ~= fix(N)),
error('Fehler: N muss eine ganze Zahl sein!');
end;
if (C ~= fix(C)),
error('Fehler: C muss eine ganze Zahl sein!');
end;
if (L ~= fix(L)),
error('Fehler: L muss eine ganze Zahl sein!');
end;
% -------------------------------------------------------------------------
% Automatik-Auswahl
% -------------------------------------------------------------------------
% Falls C=0 => Automatische Wahl von C=2^r
% Anahme: C = L + N
if (C==0)
C = 2^ceil(log2(L+N-1))
end;
% -------------------------------------------------------------------------
% FLMS Parameter
% -------------------------------------------------------------------------
gamma = 1.0/C; % Sicherheitskonstante vermeidet Division durch Null
lambda = 0.6; % Vergessensfaktor
% -------------------------------------------------------------------------
% Initialisierungen
% -------------------------------------------------------------------------
Lx = length(x); % Länge des Eingangsvektors
K = Lx/L; % Anzahl Verarbeitungsblöcke
ee=zeros(Lx,1); % Fehlervektor
ys=zeros(Lx,1); % Filterausgang, Schaetzung von d
wf = zeros(C,1); % Filter im Zeitbereich
PX = zeros(C,1); % Schaetzung des Leistungsdichtespektrums
WS = zeros(C,1); % Filterkoeff. im Frequenzbereich
X = zeros(C,1); % Eingangsvektor im Frequenzbereich
mu = zeros(C,1); % Variable Schrittweite
yy = zeros(C,1); % Filterausgang im Zeitbereich
YS = zeros(C,1); % Filterausgang im Frequenzbereich
xzp = zeros(Lx+C-L,1); % Eingangsvektor mit C-L führenden Nullen
xzp(C-L+1:Lx+C-L) = x; % Einfügen von Np führenden Nullen an den Eingangsvektor
% Anfangswerte der Filterkoeffienten in den Frequenzbereich transformieren
WS(1:C) = dspfft(wi(1:N),C);
% -------------------------------------------------------------------------
% Algorithmus Start
% -------------------------------------------------------------------------
flops(0);
for k=1:K,
kL = (k-1)*L;
% Transformation des aktuellen Eingangsvektors in den Frequenzbereich
X(1:C) = dspfft(xzp(kL+1:kL+C),C);
% Schnelle FFT-Faltung
YS = WS(1:C).*X(1:C) *C;
% Transformation des Filterausgangs in den Zeitbereich
yy = real(dspifft(YS,C));
% Abspeichern der letzten L Werte des Filterausgangs
ys(kL+1:kL+L) = yy(C-L+1:C);
% Berechnung des Fehlers e(k)
ee(kL+1:kL+L) = d(kL+1:kL+L) - ys(kL+1:kL+L);
% Transformation des Fehlers in den Frequenzbereich
E = dspfft([zeros(C-L,1); ee(kL+1:kL+L)],C);
% Schätzung der mittleren Eingangsleistung Px(k) aus x(k)
PX = abs((1-lambda)*conj(X(1:C)).*X(1:C) *C + lambda*PX);
% Berechnung der variablen Schrittweite mu(k)
% mu(k) wird niemals grösser als eins
mu(1:C) = (alpha*gamma) ./(PX+gamma);
% Filterkoeffizenten-Update
WS(1:C) = WS(1:C) + mu(1:C) .* conj(X(1:C)) .* E *C;
% Projektion der Filterkoeffizienten
wf(1:C) = real(dspifft(WS(1:C),C));
WS(1:C) = dspfft(wf(1:N),C);
end;
wf = [wf(1:C-L+1) ; zeros(L-1,1)]; % Filterkoeffizienten am Ende der Adaption
fpo=flops;
% -------------------------------------------------------------------------
% Ende FLMS.M
% -------------------------------------------------------------------------
common/flms1.m
Executable
+60
View File
@@ -0,0 +1,60 @@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% Fast LMS Algorithm %
% %
% Written By: Sundar Sankaran and A. A. (Louis) Beex %
% DSP Research Laboratory %
% Dept. of Electrical and Comp. Engg %
% Virginia Tech %
% Blacksburg VA 24061-0111 %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
randn('seed', 0) ;
rand('seed', 0) ;
NoOfData = 8000 ; % Set no of data points used for training
M = 32 ; % Set the adaptive filter order
Mu = 0.01 ; % Set the step-size constant
Gamma = 0.9 ; % Forgetting factor
Delta = 0.01 ; % R_est initialized to Delta*I
u = randn(NoOfData, 1) ;% Input assumed to be white
h = rand(M, 1) ; % System picked randomly
d = filter(h, 1, u) ; % Generate output (desired signal)
% Initialize fast-lms
W = zeros(2*M,1) ;
p = Delta*ones(2*M,1) ;
y = zeros(M, 1) ;
e = zeros(M, 1) ;
for k = 2 : floor(length(u)/M) - 1 ;
U = fft(u((k-1)*M:(k+1)*M-1)) ;
Y = ifft(U.*W) ;
y(k*M:(k+1)*M-1) = real(Y(M+1:2*M)) ;
e(k*M:(k+1)*M-1) = d(k*M:(k+1)*M-1) - y(k*M:(k+1)*M-1) ;
E = fft([zeros(M,1); e(k*M:(k+1)*M-1)]) ;
p = Gamma*p+(1-Gamma)*abs(U).^2 ;
p_inv = 1./p ;
PHI = ifft(p .* conj(U) .* E) ;
phi = real(PHI(1 : M )) ;
W = W + Mu / (2*M) * fft([phi; zeros(M,1)]) ;
end ;
% Plot results
figure ;
plot(20*log10(abs(e))) ;
title('Learning Curve') ;
xlabel('Iteration Number') ;
ylabel('Output Estimation Error in dB') ;
common/flms2.m
Executable
+99
View File
@@ -0,0 +1,99 @@
%===================================================================
%-------------------------------------------------------------------
%
% Adaptive Filter
%
% Simulationen
%
% [ee,w,dd,calc,Px]=flms2(mu,N,C,L,x,d,w_start)
%
% FLMS-Algorithmus
%
% ee = Fehlersignal
% w = Filterkoeffizienten am Ende der Adaption
% dd = Filterausgang, Schaetzung von d
% calc = Rechenzeit
% Px = Schaetzung des Leistungsdichtespektrums vom x
% mu = Schrittweite
% N = Anz. Filterkoeffizienten = Filterordnung+1
% X = Filtereingang x[.]
% d = erwuenschtes Signal d[.]
% w_start = Startwerte Filterkoeffizienten
%
%-------------------------------------------------------------------
%
% author: Markus Hofbauer
% ISI, ETH Zuerich (Switzerland)
%
% created: 7/2000
%
%
%-------------------------------------------------------------------
%
% File : flms2.m
%
% Startfile: sim5.m
%
%-------------------------------------------------------------------
%===================================================================
function [ee,w,dd,calc,PX]=flms2(mu,N,C,L,x,d,w_start)
% Initialisierungen
ee=zeros(lge(x),1); % Fehlervektor
dd=zeros(lge(x),1); % Filterausgang, Schaetzung von d
WS = zeros(C,1); % Gewichtsvektor im Frequenzbereich
w = zeros(C,1); % Gewichtsvektor im Zeitbereich
PX = C*ones(C,1); % Schaetzung des Leistungsdichtespektrums
X = zeros(C,1); % Eingangsvektor im Frequenzbereich
%% FLMS Parameter
numblk = floor(lge(x)/L); % Anzahl Verarbeitungsbloecke
begin=ceil(C/L)-1; % erster Blockindex
gamma = 0.6; % Vergessensfaktor
tic; % Stopuhr laeuft
%-------------------------------------------------------------------
% FLMS Update Loop
%-------------------------------------------------------------------
for j = begin: numblk-1
% DFT von x, Laenge C
X = fft(x((j+1)*L-C+1:(j+1)*L)); % aktuellster Wert
% des Blockes: (j+1)*L
% Filterung im Frequenzbereich
YS = (X .* WS);
ys = real(ifft(YS)); % IDFT, Filterausgang im Zeitbereich
% Fehlersignal im Zeitbereich
ee(j*L+1:(j+1)*L) = d(j*L+1:(j+1)*L) - ys(C-L+1:C);
% Overlap-Save-Verfahren: nur die letzten L Werte von ys
% werden verwendet um eine lineare Faltung zu erhalten
% Fehlersignal im Frequenzbereich
E = fft([zeros(C-L,1); ee(j*L+1:(j+1)*L)]);
% Update von PX
PX=abs((1-gamma)*conj(X).*X+ gamma * PX);
% Update von WS
WS = WS + mu * conj(X)./(PX+0.001) .* E ; % Adaption von WS
% Projektion (letzten L-1 Werte von w zu Null setzten)
w = real(ifft(WS));
WS = fft(w(1:C-L+1),C);
dd(j*L+1:(j+1)*L) = ys(C-L+1:C); % Abspeichern der Schaetzung
end;
calc=toc; % Stopuhr angehalten
w = [w(1:C-L+1) ; zeros(L-1,1)]; % Filterkoeffizienten am Ende der Adaption
common/flms3.m
Executable
+108
View File
@@ -0,0 +1,108 @@
%===================================================================
%-------------------------------------------------------------------
%
% Adaptive Filter
%
% Simulationen
%
% [ee,w,dd,calc,Px]=flms2(mu,N,C,L,x,d,w_start)
%
% FLMS-Algorithmus
%
% ee = Fehlersignal
% w = Filterkoeffizienten am Ende der Adaption
% dd = Filterausgang, Schaetzung von d
% calc = Rechenzeit
% Px = Schaetzung des Leistungsdichtespektrums vom x
% mu = Schrittweite
% N = Anz. Filterkoeffizienten = Filterordnung+1
% X = Filtereingang x[.]
% d = erwuenschtes Signal d[.]
% w_start = Startwerte Filterkoeffizienten
%
%-------------------------------------------------------------------
%
% author: Markus Hofbauer
% ISI, ETH Zuerich (Switzerland)
%
% created: 7/2000
%
%
%-------------------------------------------------------------------
%
% File : flms2.m
%
% Startfile: sim5.m
%
%-------------------------------------------------------------------
%===================================================================
function [ee,w,dd,calc,PX,u]=flms2(mu,N,C,L,x,d,w_start)
% Initialisierungen
ee=zeros(lge(x),1); % Fehlervektor
dd=zeros(lge(x),1); % Filterausgang, Schaetzung von d
WS = zeros(C,1); % Gewichtsvektor im Frequenzbereich
w = zeros(C,1); % Gewichtsvektor im Zeitbereich
PX = zeros(C,1); % Schaetzung des Leistungsdichtespektrums
X = zeros(C,1); % Eingangsvektor im Frequenzbereich
u = zeros(C,1);
%% FLMS Parameter
numblk = floor(lge(x)/L); % Anzahl Verarbeitungsbloecke
begin=ceil(C/L)-1; % erster Blockindex
gamma = 0.97; % Vergessensfaktor
alpha = 1.0; % 0 < alpha < 1
tic; % Stopuhr laeuft
dspMul = C
dspShift = log2(dspMul)
%-------------------------------------------------------------------
% FLMS Update Loop
%-------------------------------------------------------------------
for j = begin: numblk-1
% DFT von x, Laenge C
X = dspfft(x((j+1)*L-C+1:(j+1)*L),C); % aktuellster Wert
% des Blockes: (j+1)*L
% Filterung im Frequenzbereich
YS = ((X*dspMul) .* (WS*dspMul));
ys = real(dspifft(YS,C)); % IDFT, Filterausgang im Zeitbereich
% Fehlersignal im Zeitbereich
ee(j*L+1:(j+1)*L) = d(j*L+1:(j+1)*L) - ys(C-L+1:C);
% Overlap-Save-Verfahren: nur die letzten L Werte von ys
% werden verwendet um eine lineare Faltung zu erhalten
% Fehlersignal im Frequenzbereich
E = dspfft([zeros(C-L,1); ee(j*L+1:(j+1)*L)],C);
% Update von PX
PX=abs((1-gamma)*conj(X).*X*dspMul + gamma * PX);
% umax = alpha
u = (alpha*mu/dspMul) ./(PX+mu/dspMul);
% Update von WS
WS = WS + u .* conj(X).* E ; % Adaption von WS
% Projektion (letzten L-1 Werte von w zu Null setzten)
w = real(dspifft(WS,C));
WS = dspfft(w(1:C-L+1),C);
dd(j*L+1:(j+1)*L) = ys(C-L+1:C); % Abspeichern der Schaetzung
end;
calc=toc; % Stopuhr angehalten
w = [w(1:C-L+1) ; zeros(L-1,1)]; % Filterkoeffizienten am Ende der Adaption
common/flms_d.m
Executable
+142
View File
@@ -0,0 +1,142 @@
% Frequency LMS Adaptive Filter -FLMS- (DEBUG)
% --------------------------------------------
%
% Aufruf:
% Function [ys,ee,wf,fpo]=flms_d(x,d,alpha,N,C,L,wi)
%
% Parameter:
% x : Eingangsvektor
% d : Referenzvektor
% alpha: konstante Schrittweite 0 < alpha <= 1.0
% N : Anzahl Filterkoeffizienten
% C : FFT-Länge, idealerweise eine Zweier-Potenz (0=Auto)
% L : Länge eines Verarbeitungsblocks (idealerweise C=L+N=2N)
% wi : Startwerte der Filterkoeffizienten im Zeitbereich
%
% Rückgabewerte:
% ee : Adaptitionsfehler
% ys : Filterausgang
% wf : Filterkoeffizienten am Ende der Adaption
% fpo : Anzahl benötigten der Floating-Point Operationen
%
% Zu Debug-Zwecken werden folgende Variablen als Binär-Dateien gespeichert:
% wf.dat : Filterkoeffizienten am Ende der Adaption (Länge N)
% -------------------------------------------------------------------------
% Datum : 20.7.2001
% Autor : Jens Ahrensfeld
% Thema : Diplomarbeit
% Datei : flms_d.m
% Benötigte Dateien: dspfft.m, dspifft.m
%
% -------------------------------------------------------------------------
function [ys,ee,wf,fpo]=flms_d(x,d,alpha,N,C,L,wi)
% -------------------------------------------------------------------------
% Überprüfen der Parameter
% -------------------------------------------------------------------------
if (N ~= fix(N)),
error('Fehler: N muss eine ganze Zahl sein!');
end;
if (C ~= fix(C)),
error('Fehler: C muss eine ganze Zahl sein!');
end;
if (L ~= fix(L)),
error('Fehler: L muss eine ganze Zahl sein!');
end;
% -------------------------------------------------------------------------
% Automatik-Auswahl
% -------------------------------------------------------------------------
% Falls C=0 => Automatische Wahl von C=2^r
% Anahme: C = L + N
if (C==0)
C = 2^ceil(log2(L+N-1))
end;
% -------------------------------------------------------------------------
% FLMS Parameter
% -------------------------------------------------------------------------
gamma = 1.0/C; % Sicherheitskonstante vermeidet Division durch Null
lambda = 0.6; % Vergessensfaktor
% -------------------------------------------------------------------------
% Initialisierungen
% -------------------------------------------------------------------------
Lx = length(x); % Länge des Eingangsvektors
K = Lx/L; % Anzahl Verarbeitungsblöcke
ee=zeros(Lx,1); % Fehlervektor
ys=zeros(Lx,1); % Filterausgang, Schaetzung von d
wf = zeros(C,1); % Filter im Zeitbereich
PX = zeros(C,1); % Schaetzung des Leistungsdichtespektrums
WS = zeros(C,1); % Filterkoeff. im Frequenzbereich
X = zeros(C,1); % Eingangsvektor im Frequenzbereich
mu = zeros(C,1); % Variable Schrittweite
yy = zeros(C,1); % Filterausgang im Zeitbereich
YS = zeros(C,1); % Filterausgang im Frequenzbereich
xzp = zeros(Lx+C-L,1); % Eingangsvektor mit C-L führenden Nullen
xzp(C-L+1:Lx+C-L) = x; % Einfügen von Np führenden Nullen an den Eingangsvektor
% Anfangswerte der Filterkoeffienten in den Frequenzbereich transformieren
%WS(1:C) = dspfft(wi(1:N),C);
% -------------------------------------------------------------------------
% Algorithmus Start
% -------------------------------------------------------------------------
flops(0);
for k=1:K,
kL = (k-1)*L;
% Transformation des aktuellen Eingangsvektors in den Frequenzbereich
X(1:C) = dspfft(xzp(kL+1:kL+C),C);
% Schnelle FFT-Faltung
YS = WS(1:C).*X(1:C) *C;
% Transformation des Filterausgangs in den Zeitbereich
yy = real(dspifft(YS,C));
% Abspeichern der letzten L Werte des Filterausgangs
ys(kL+1:kL+L) = yy(C-L+1:C);
% Berechnung des Fehlers e(k)
ee(kL+1:kL+L) = d(kL+1:kL+L) - ys(kL+1:kL+L);
% Transformation des Fehlers in den Frequenzbereich
E = dspfft([zeros(C-L,1); ee(kL+1:kL+L)],C);
% Schätzung der mittleren Eingangsleistung Px(k) aus x(k)
PX = abs((1-lambda)*conj(X(1:C)).*X(1:C) *C + lambda*PX);
% Berechnung der variablen Schrittweite mu(k)
% mu(k) wird niemals grösser als eins
mu(1:C) = (alpha*gamma) ./(PX+gamma);
% Filterkoeffizenten-Update
WS(1:C) = WS(1:C) + mu(1:C) .* conj(X(1:C)) .* E *C;
% Projektion der Filterkoeffizienten
wf(1:C) = real(dspifft(WS(1:C),C));
WS(1:C) = dspfft(wf(1:N),C);
end;
wf = [wf(1:C-L+1) ; zeros(L-1,1)]; % Filterkoeffizienten am Ende der Adaption
% Speichern der Koeffizienten in Datei (Genauigkeit Float32)
fid = fopen('wf.dat','wb');
fwrite(fid,wf,'float32');
fclose(fid);
fpo=flops;
% -------------------------------------------------------------------------
% Ende FLMS_D.M
% -------------------------------------------------------------------------
common/fpoints.m
Executable
+11
View File
@@ -0,0 +1,11 @@
% fpoints.m
function fp = fpoints(dim,len, pos)
fp = randn(dim,len);
for d=1:dim,
fp(d,:) = fp(d,:) + pos(d);
end;
common/iirtp.m
Executable
+13
View File
@@ -0,0 +1,13 @@
% IIR-Tiefpass
% y = iirtp(fa,fg,Q,N,x)
%
% fa : Abtastfrequenz [Hz]
% fg : Grenzfrequenz [Hz] fg <= fa/2
% Q : Polgüte (Resonanz)
% N : Filterordnung (durch zwei teilbar)
% x : Eingangssignal
function y = iirtp(fa,fg,Q,N,x)
[b,a] = iirtpc(fa,fg,Q,N);
y = filter(b,a,x);
common/iirtp2.m
Executable
+13
View File
@@ -0,0 +1,13 @@
% IIR-Tiefpass
% [y,zf] = iirtp2(fa,fg,Q,N,x,zi)
%
% fa : Abtastfrequenz [Hz]
% fg : Grenzfrequenz [Hz] fg <= fa/2
% Q : Polgüte (Resonanz)
% N : Filterordnung (durch zwei teilbar)
% x : Eingangssignal
function [y,zf] = iirtp(fa,fg,Q,N,x,zi)
[b,a] = iirtpc(fa,fg,Q,N);
[y,zf] = filter(b,a,x,zi);
common/iirtpc.m
Executable
+33
View File
@@ -0,0 +1,33 @@
% IIRTPC generiert IIR-Tiefpass Koeffizienten für geradzahlige Ordnung
% [b,a] = iirtpc(fa,fg,Q,N)
%
% fa : Abtastfrequenz [Hz]
% fg : Grenzfrequenz [Hz] fg <= fa/2
% Q : Polgüte (Resonanz)
% N : Filterordnung (durch zwei teilbar)
%
function [b,a] = iirtpc(fa,fg,Q,N)
if (rem(N,2) > 0)
error('Filterordnung muss z.Zt. noch durch zwei teilbar sein!');
end;
sn = sin(2*pi*fg/fa);
cs = cos(2*pi*fg/fa);
ak = ones(N/2,3);
bk = ones(N/2,3);
a = 1;
b = 1;
for n = 1:N/2,
Qp = 1/(2*sin(pi*(n-0.5)/N));
alpha = sn/(2*Q*Qp);
a0 = 1+alpha;
ak(n,2) = -2*cs/a0;
ak(n,3) = (1-alpha)/a0;
bk(n,1) = 0.5*(1-cs)/a0;
bk(n,2) = (1-cs)/a0;
bk(n,3) = 0.5*(1-cs)/a0;
a = conv(a,ak(n,(1:3)));
b = conv(b,bk(n,(1:3)));
end;
common/l1.m
Executable
+48
View File
@@ -0,0 +1,48 @@
% ##################################################################################
% ## Loesung: Impulsfolge ##
% ##################################################################################
% ##### Teilaufgabe a: zeitdiskrete endliche Signale #####
% ### 1:
k = 1:20;
x1 = zeros(size(k));
x1(5) = 0.9;
figure; stem(k,x1); grid; xlabel('k'); ylabel('x1(k)');
% ### 2:
k = -15:15;
x2 = zeros(size(k));
x2(16) = 0.8;
figure; stem(k,x2); grid; xlabel('k'); ylabel('x2(k)');
% ### 3:
k = 300:350;
x3 = zeros(size(k));
x3(34) = 1.5;
figure; stem(k,x3); grid; xlabel('k'); ylabel('x3(k)');
% ### 4:
k = -10:0;
x4 = zeros(size(k));
x4(4) = 4.5;
figure; stem(k,x4); grid; xlabel('k'); ylabel('x4(k)');
% ##### Teilaufgabe b: Impulsfolge #####
P = 5;
M = 10;
k = 0:(M*P)-1;
x = [1; 0; 0; 0; 0] * ones(1,M);
s = x(:);
figure; stem(k',s); grid; xlabel('k'); ylabel('s(k)'); axis([0 49 0 1.2]);
% ##### Teilaufgabe c: Matlab Code #####
x = [0;1;1;0;0;0] * ones(1,7);
x = x(:);
figure; stem(x); xlabel('k'); ylabel('x(k)'); axis([0 42 0 1]);
% ##### EOF #####
common/l10.m
Executable
+32
View File
@@ -0,0 +1,32 @@
% ##################################################################################
% ## Loesung: Gleichverteilter zeitdiskreter stochastischer Prozess ##
% ##################################################################################
N=10000;
% ##### Teilaufgabe a: Rauschfolge #####
n = rand(N,1);
% ##### Teilaufgabe b: Histogramm #####
n = rand(N,1);
[H,x] = hist(n,30);
H = H/N; % Damit H eine Schaetzung der Wahrscheinlichkeitsdichte
% ist, muss die Flaeche eins sein
figure; bar(x,H);grid; xlabel('x'); ylabel('f_X(x)');
title(['Gleichvert. Mittelw.=',num2str(mean(n)),' Var.=',num2str(std(n).^2)]);
% ##### Teilaufgabe c: Mittelwert und Varianz #####
n = rand(N,1);
m = mean(n);
s = std(n);
% ##### Teilaufgabe d: Musterfunktion #####
for k=1:5
n = rand(N,1);
[H,x]=hist(n,30);
H = H/N;
figure; bar(x,H); grid; xlabel('x'); ylabel('f_X(x)');
title(['Gleichvert. Mittelw.=',num2str(mean(n)),' Var.=',num2str(std(n).^2)]);
end;
% ##### EOF #####
common/l11.m
Executable
+29
View File
@@ -0,0 +1,29 @@
% ##################################################################################
% ## Loesung: Korrelationsfolgen ##
% ## -------------------------------------------------------------------------- ##
% ## Benoetigte(s) m-File(s): ldtft.m ##
% ##################################################################################
% ##### Teilaufgabe a: weisse Rauschfolge #####
n = randn(800,1);
kappa = -799:799;
s_biased = xcorr(n,'biased');
s_unbiased = xcorr(n,'unbiased');
s_coeff = xcorr(n,'coeff');
figure; stem(kappa,s_biased); grid; xlabel('kappa'); ylabel('Amplitude');
title('Autokorrelationsfolge: Nicht erwartungstreu');
figure; stem(kappa,s_unbiased); grid; xlabel('kappa'); ylabel('Amplitude');
title('Autokorrelationsfolge: erwartungstreu');
figure; stem(kappa,s_coeff); grid; xlabel('kappa'); ylabel('Amplitude');
title('Autokorrelationsfolge: auf time-lag Null normiert');
% ##### Teilaufgabe b: Leistungsdichtespektrum #####
n = randn(200,1);
s = xcorr(n,'biased');
[S W] = ldtft(s,512);
figure; semilogy(W/pi, abs(S) ); % normierte Frequenz
grid; xlabel('Omega/pi'); ylabel('|S_xx(exp(j*Omega))|');
title('Leistungsdichtespektrum');
% ##### EOF #####
common/l12.m
Executable
+24
View File
@@ -0,0 +1,24 @@
% ##################################################################################
% ## Loesung: Filterstrukturen ##
% ## -------------------------------------------------------------------------- ##
% ## Benoetigte(s) m-File(s): lcascade.m ##
% ##################################################################################
% ##### Teilaufgabe b: Filterkoeffizienten berechnen #####
[b a] = ellip(7,0.1,40,0.4); % Filter entwerfen
[B A] = lcascade(b,a); % 3-te kanonische Form
[Hg W] = freqz(b,a,512); % Uebertragungsfunktion des Gesamtsystems
[m n] = size(B); % Produkt der Uebertragungsfunktionen der Teilsysteme
Hi = zeros(512,m);
for k=1:m;
Hi(:,k) = freqz(B(k,:),A(k,:),512);
end;
H3k = Hi(:,1) .* Hi(:,2) .* Hi(:,3) .* Hi(:,4);
figure;
plot(W/pi,20*log10(abs(H3k)),'--b'); hold on;
plot(W/pi,20*log10(abs(Hg)),'-.b'); hold off;
grid; xlabel('Omega/pi (Nyquist = 1)'); ylabel('|H(exp(j*Omega))| in dB');
title('-- Gesamtsystem, -. Produkt der Teilsysteme');
% ##### EOF #####
common/l13.m
Executable
+47
View File
@@ -0,0 +1,47 @@
% ##################################################################################
% ## Loesung: Entwurf rekursiver Filter ##
% ##################################################################################
fD = 1000; %Durchlassfrequenz (Hz)
fS = 1400; %Sperrfrequenz (Hz)
Rp = 0.5; %Durchlaßripple (dB)
Rs = 30; %Sperrdaempfung (dB)
fA = 8000; %Abtastfrequenz (Hz)
Wp = 2*fD/fA; %Umrechnung in normierte Grenzfrequenzen
Ws = 2*fS/fA;
for typ=1:4
if typ == 1;
[n,Wn] = buttord(Wp,Ws,Rp,Rs); %Butterworth
[b,a] = butter(n,Wn);
FTyp = 'Butterworth';
elseif typ == 2 ;
[n,Wn] = cheb1ord(Wp,Ws,Rp,Rs); %Tschebyscheff Typ I
[b,a] = cheby1(n,Rp,Wn);
FTyp = 'Tschebyscheff Typ I';
elseif typ == 3 ;
[n,Wn] = cheb2ord(Wp,Ws,Rp,Rs); %Tschebyscheff Typ II
[b,a] = cheby2(n,Rs,Wn);
FTyp = 'Tschebyscheff Typ II';
elseif typ == 4;
[n,Wn] = ellipord(Wp,Ws,Rp,Rs); %Cauer
[b,a] = ellip(n,Rp,Rs,Wn);
FTyp = 'Cauer';
else;
error('Irgendwas stimmt nicht...');
end;
[H,W]=freqz(b,a,512);
TitleString = sprintf('Filtertyp: %s Ordnung: %d', FTyp, n);
figure; plot(W/pi,abs(H)); grid; title(TitleString);
xlabel('Omega/pi');ylabel('|H(exp(j*Omega))|'); axis([0 1 0 1.2]);
xline=[Wp Wp];yline=[0 10.^(-Rp/20)]; line(xline,yline,'linestyle','--');
xline=[0 Ws]; yline=[1 1]; line(xline,yline,'linestyle','--');
xline=[0 Wp]; yline=[10.^(-Rp/20) 10.^(-Rp/20)];line(xline,yline,'linestyle','--');
xline=[Ws Ws];yline=[10.^(-Rs/20) 1];line(xline,yline,'linestyle','--');
xline=[Ws 1]; yline=[10.^(-Rs/20) 10.^(-Rs/20)];line(xline,yline,'linestyle','--');
figure; zplane(b,a); title(TitleString); xlabel('Realteil');
ylabel('Imaginaerteil');
end;
% ##### EOF #####
common/l14.m
Executable
+101
View File
@@ -0,0 +1,101 @@
% ##################################################################################
% ## Loesung: Quantisierung der Filterkoeffizienten ##
% ## -------------------------------------------------------------------------- ##
% ## Benoetigte(s) m-File(s): lfxquant.m, lcoefrnd.m, lcascade.m ##
% ##################################################################################
% ##### Teilaufgabe a: Cauer Tiefpass #####
[b a] = ellip(7, 0.1, 40, 0.4);
[H W] = freqz(b,a,512);
figure; plot(W/pi,20*log10(abs(H))); grid; xlabel('Omega/pi (Nyquist = 1)');
ylabel('|H(exp(j*Omega))| in dB'); title('Cauer-TP');
% ##### Teilaufgabe b: Filterkoeffizienten quantisieren #####
[b a] = ellip(7, 0.1, 40, 0.4);
[H W] = freqz(b,a,512);
[bq nb] = lcoefrnd(b,8);
[aq na] = lcoefrnd(a,8);
Hq = nb/na*freqz(bq,aq,512);
figure; plot(W/pi,20*log10(abs(H))); hold on; plot(W/pi,20*log10(abs(Hq)),'-.');
hold off; grid; title('- unquantisierte Koeff., -. 8 Bit quantisierte Koeff.');
xlabel('Omega/pi (Nyquist = 1)'); ylabel('|H(exp(j*Omega))| in dB');
% ##### Teilaufgabe c: minimale Wortlaenge bestimmen #####
[b a] = ellip(7,0.1,40,0.4); % Filter entwerfen
[H W] = freqz(b,a,512); % unquantisierte Uebertragungsfunktion
v_laenge=[16];
for l=v_laenge
[bq,nb] = lcoefrnd(b,l); % Koeffizienten mit l Bits quantisieren
[aq,na] = lcoefrnd(a,l);
Hq = nb/na*freqz(bq,aq,512); % quantisierte Uebertragungsfunktion
figure; % Durchlassbereich darstellen
plot(W(1:208)/pi,20*log10(abs(H(1:208)))); axis([0 0.5 -1.4 0.3]); grid; hold on;
plot(W(1:208)/pi,-0.15*ones(size(Hq(1:208))),'w' ); %Toleranzgrenzen darstellen
plot(W(1:208)/pi,+0.15*ones(size(Hq(1:208))),'w' );
plot(W(1:208)/pi,20*log10(abs(Hq(1:208))),'--'); hold off;
xlabel('Omega/pi (Nyquist = 1)');ylabel('|H(exp(j*Omega))| in dB');
string = sprintf('Durch.: - unquantisiert, -- quantisiert mit %d Bits', l);
title(string);
figure; % Sperrbereich darstellen
plot(W(215:512)/pi,20*log10(abs(H(215:512)))); hold on;
plot(W(215:512)/pi,20*log10(abs(Hq(215:512))),'--');
plot(W(215:512)/pi,-38*ones(size(Hq(215:512))),'w' ); grid;
hold off; xlabel('Omega/pi (Nyquist = 1)'); ylabel('|H(exp(j*Omega))| in dB');
string = sprintf('Sperr.: - unquantisiert, -- quantisiert mit %d Bits', l);
title(string);
end;
% ##### Teilaufgabe d: Filterkoeffizienten quantisieren #####
[b a] = ellip(7,0.1,40,0.4); % Filter entwerfen
[B A] = lcascade(b,a); % unquantisierte Uebertragungsfunktion in
% 3-ter kanonischer Form berechnen
[m n] = size(B); % Produkt der Uebertragungsfunkt. der Teilsysteme
Hi = zeros(512,m);
for k=1:m;
Hi(:,k) = freqz(B(k,:),A(k,:),512);
end;
H3k = Hi(:,1) .* Hi(:,2) .* Hi(:,3) .* Hi(:,4);
Bq = zeros(size(B)); % Vektoren initialisieren
Aq = Bq;
nb = zeros(m,1);
na = nb;
v_laenge=[12];
for l=v_laenge
for k = 1:m; % Koeffizienten der Teilsysteme mit l Bits quantisieren
[Bq(k,:),nb(k)] = lcoefrnd(B(k,:),l);
[Aq(k,:),na(k)] = lcoefrnd(A(k,:),l);
end;
Hq = zeros(512,m); % quantisierte Gesamtuebertragungsfunktion
for k=1:m
Hq(:,k) = nb(k)/na(k)*freqz(Bq(k,:),Aq(k,:),512);
end;
Hqg = Hq(:,1) .* Hq(:,2) .* Hq(:,3) .* Hq(:,4);
figure; % Durchlassbereich darstellen
plot(W(1:208)/pi,20*log10(abs(H3k(1:208))));axis([0 0.5 -1.4 0.3]); grid; hold on;
plot(W(1:208)/pi,-0.15*ones(size(Hqg(1:208))),'w' ); %Toleranzgrenzen darstellen
plot(W(1:208)/pi,+0.15*ones(size(Hqg(1:208))),'w' );
plot(W(1:208)/pi,20*log10(abs(Hqg(1:208))),'--'); hold off;
xlabel('Omega/pi (Nyquist = 1)'); ylabel('|H(exp(j*Omega))| in dB');
string = sprintf('Durch.: - unquantisiert, -- quantisiert mit %d Bits', l);
title(string);
figure; % Sperrbereich darstellen
plot(W(215:512)/pi,20*log10(abs(H3k(215:512)))); hold on;
plot(W(215:512)/pi,20*log10(abs(Hqg(215:512))),'--');
plot(W(215:512)/pi,-38*ones(size(Hqg(215:512))),'w' ); grid; hold off;
xlabel('Omega/pi (Nyquist = 1)'); ylabel('|H(exp(j*Omega))| in dB');
string = sprintf('Sperr.: - unquantisiert, -- quantisiert mit %d Bits', l);
title(string);
end;
% ##### EOF #####
common/l15.m
Executable
+111
View File
@@ -0,0 +1,111 @@
% ##################################################################################
% ## Loesung: Fensterfunktionen ##
% ## -------------------------------------------------------------------------- ##
% ## Benoetigte(s) m-File(s): ldtft.m ##
% ##################################################################################
% ##### Teilaufgabe a: Fenstertyp berechnen #####
window_length=[21 42];
for n=window_length %%%Rechteckfenster%%%
n_find = find(n==window_length);
tltstr = 'Rechteck-Fenster';
rw = boxcar(n);
[Rw W] = ldtft(rw,512);
i=find(abs(Rw)==0); % Vermeidung von Werten==0
Rw(i)=1e-100*ones(size(i));
if n_find==1
figure;plot(W/pi,20*log10(abs(Rw/max(Rw))));
axis([-1 1 -80 0]);grid;hold on;
end;
plot(W/pi, 20*log10(abs(Rw/max(Rw))),'--'); xlabel('Omega/pi');
ylabel('|F(exp(j*Omega))/F(exp(j*0))| in dB');title([tltstr,' m: - 21 -- 42']);
end;
hold off;
figure; stem(0:n-1,rw);grid; xlabel('k'); ylabel('f(k)'); title(tltstr);
for n=window_length %%%von Hann%%%
n_find = find(n==window_length);
tltstr = 'von Hann-Fenster';
rh = hanning(n);
[Rh W] = ldtft(rh,512);
i=find(abs(Rh)==0); % Vermeidung von Werten==0
Rh(i)=1e-100*ones(size(i));
if n_find==1
figure;plot(W/pi,20*log10(abs(Rh/max(Rh)))); axis([-1 1 -80 0]);grid;hold on;
end;
plot(W/pi,20*log10(abs(Rh/max(Rh))),'--'); xlabel('Omega/pi');
ylabel('|F(exp(j*Omega))/F(exp(j*0))| in dB');title([tltstr,' m: - 21 -- 42']);
end;
hold off;
figure; stem(0:n-1,rh);grid; xlabel('k'); ylabel('f(k)'); title(tltstr);
for n=window_length %%%Hamming%%%
n_find = find(n==window_length);
tltstr = 'Hamming-Fenster';
rhm = hamming(n);
[Rhm W] = ldtft(rhm,512);
i=find(abs(Rhm)==0); % Vermeidung von Werten==0
Rhm(i)=1e-100*ones(size(i));
if n_find==1
figure;plot(W/pi,20*log10(abs(Rhm/max(Rhm))));axis([-1 1 -80 0]);grid;hold on;
end;
plot(W/pi,20*log10(abs(Rhm/max(Rhm))),'--'); xlabel('Omega/pi');
ylabel('|F(exp(j*Omega))/F(exp(j*0))| in dB');title([tltstr,' m: - 21 -- 42']);
end;
hold off;
figure; stem(0:n-1,rhm);grid; xlabel('k'); ylabel('f(k)'); title(tltstr);
for n=window_length %%%Blackman%%%
n_find = find(n==window_length);
tltstr = 'Blackman-Fenster';
rhb = blackman(n);
[Rhb W] = ldtft(rhb,512);
i=find(abs(Rhb)==0); % Vermeidung von Werten==0
Rhb(i)=1e-100*ones(size(i));
if n_find==1
figure;plot(W/pi,20*log10(abs(Rhb/max(Rhb))));axis([-1 1 -80 0]);grid;hold on;
end;
plot(W/pi,20*log10(abs(Rhb/max(Rhb))),'--'); xlabel('Omega/pi');
ylabel('|F(exp(j*Omega))/F(exp(j*0))| in dB');title([tltstr,' m: - 21 -- 42']);
end;
hold off;
figure; stem(0:n-1,rhb);grid; xlabel('k'); ylabel('f(k)'); title(tltstr);
for n=window_length %%%Bartlett%%%
n_find = find(n==window_length);
tltstr = 'Bartlett-Fenster';
rhbt = bartlett(n);
[Rhbt W] = ldtft(rhbt,512);
i=find(abs(Rhbt)==0); % Vermeidung von Werten==0
Rhbt(i)=1e-100*ones(size(i));
if n_find==1
figure;plot(W/pi,20*log10(abs(Rhbt/max(Rhbt))));axis([-1 1 -80 0]);grid;
hold on;
end;
plot(W/pi,20*log10(abs(Rhbt/max(Rhbt))),'--'); xlabel('Omega/pi');
ylabel('|F(exp(j*Omega))/F(exp(j*0))| in dB');title([tltstr,' m: - 21 -- 42']);
end;
hold off;
figure; stem(0:n-1,rhbt);grid; xlabel('k'); ylabel('f(k)'); title(tltstr);
% ##### Teilaufgabe b: Kaiser-Fenster berechnen #####
w0 = kaiser(21,0); [W0 W] = ldtft(w0,512);
w3 = kaiser(21,3); W3 = ldtft(w3,512);
w6 = kaiser(21,6); W6 = ldtft(w6,512);
k=0:20;
figure; plot(W/pi,20*log10(abs(W0/max(W0)))); xlabel('Omega/pi');axis([-1 1 -80 0]);
ylabel('|F(exp(j*Omega))/F(exp(j*0))| in dB'); hold on;
plot(W/pi,20*log10(abs(W3/max(W3))),'--');plot(W/pi,20*log10(abs(W6/max(W6))),'-.');
hold off; title('Kaiser-Fenster: beta: - 0, -- 3, -. 6'); grid;
figure; plot(k,w0); xlabel('k');ylabel('f(k)');hold on; plot(k,w3,'--');
plot(k,w6,'-.'); axis([0 20 0 1.2]); hold off;
title('Kaiser-Fenster: beta: - 0, -- 3, -. 6 '); grid
% ##### EOF #####
common/l16.m
Executable
+35
View File
@@ -0,0 +1,35 @@
% ##################################################################################
% ## Loesung: Entwurf nichtrekursiver Filter mittels Fensterung ##
% ##################################################################################
% ##### Teilaufgabe a: Tiefpass entwerfen #####
bR = fir1(50,0.4,boxcar(51)); [HR W] = freqz(bR,1,512);
bH = fir1(50,0.4,hanning(51)); [HH W] = freqz(bH,1,512);
bHm = fir1(50,0.4,hamming(51)); [HHM W] = freqz(bHm,1,512);
bB = fir1(50,0.4,blackman(51)); [HB W] = freqz(bB,512);
bK = fir1(50,0.4,kaiser(51,8)); [HK W] = freqz(bK,512);
plot(W/pi,20*log10(abs(HR/max(HR)))); hold on;
plot(W/pi,20*log10(abs(HH/max(HH))),'--');
plot(W/pi,20*log10(abs(HHM/max(HHM))),'-.'); hold off;
xlabel('Omega/pi'); ylabel('|H(exp(j*Omega))/H(1)| in dB'); grid
title(['Tiefpass: - Rechteck -- von Hann -. Hamming']); axis([0 1 -150 0]); figure;
plot(W/pi,20*log10(abs(HB/max(HB))),'-'); hold on;
plot(W/pi,20*log10(abs(HK/max(HK))),'--'); hold off;
xlabel('Omega/pi'); ylabel('|H(exp(j*Omega))/H(1)| in dB'); grid
title(['Tiefpass: - Blackman -- Kaiser mit beta=8']); axis([0 1 -150 0]);
% ##### Teilaufgabe b: Hochpass entwerfen #####
b = fir1(33,0.4,'high'); [H W] = freqz(b,1,512);
figure;
plot(W/pi,20*log10(abs(H/max(H)))); grid;
xlabel('Omega/pi'); ylabel('|H(exp(j*Omega))/H(-1)| in dB'); title('Hochpass');
% ##### Teilaufgabe c: Gruppenlaufzeit bestimmen #####
figure;
b = fir1(50,0.4);
grpdelay(b,1,256);
title('Gruppenlaufzeit in Abtastwerten'); ylabel(''); xlabel('Omega/pi');
axis([0 1 24 26]);
% ##### EOF #####
common/l17.m
Executable
+51
View File
@@ -0,0 +1,51 @@
% ##################################################################################
% ## Loesung: Remez-Entwurf (Tschebyscheff-Approximation) ##
% ##################################################################################
% ##### Teilaufgabe a: Filter entwerfen #####
f = [0 0.3 0.5 1.0];
g = [1 1 0 0];
v_m=[9 10]; % Vektor mit den Filterordnungen
for m=v_m
b = remez(m,f,g); [H W] = freqz(b,1,512);
string = sprintf('Gewuenschte/Aktuelle Antwort - Filterordnung: %d', m);
figure;plot(f,g,W/pi,abs(H));
line([0 0.3],[ 2-max(abs(H)) 2-max(abs(H))],'linestyle','--');
line([0 0.5],[max(abs(H)) max(abs(H))],'linestyle','--');
line([0.5 1],[max(abs(H(400:length(H)))) max(abs(H(400:length(H))))],...
'linestyle','--');
line([0.3 0.3],[ 2-max(abs(H)) 0],'linestyle','--');
line([0.5 0.5],[ max(abs(H)) max(abs(H(400:length(H))))],'linestyle','--');
grid; xlabel('Omega/pi'); ylabel('|H(exp(j*Omega))|'); title(string);
end;
% ##### Teilaufgabe b: Frequenzgang wichten #####
f = [0 0.3 0.5 1.0];
g = [1 1 0 0];
w = [ 0.5 2 ];
v_m=[9 10]; % Vektor mit den Filterordnungen
for m=v_m
b = remez(m,f,g,w); [H W] = freqz(b,1,512);
string = sprintf('Gewuenschte/Aktuelle Antwort - Filterordnung: %d', m);
figure; plot(f,g,W/pi,abs(H));
line([0 0.3],[ 2-max(abs(H)) 2-max(abs(H))],'linestyle','--');
line([0 0.5],[max(abs(H)) max(abs(H))],'linestyle','--');
line([0.5 1],[max(abs(H(400:length(H)))) max(abs(H(400:length(H))))],...
'linestyle','--');
line([0.3 0.3],[ 2-max(abs(H)) 0],'linestyle','--');
line([0.5 0.5],[ max(abs(H)) max(abs(H(400:length(H))))],'linestyle','--');
grid; xlabel('Omega/pi'); ylabel('|H(exp(j*Omega))|'); title(string);
end;
% ##### Teilaufgabe c: Tiefpass-Bandpass Kombination #####
f = [0 0.2 0.26 0.44 0.5 0.7 0.76 1]; % Vektor der Eckfrequenzen
g = [1 1 0 0 1 1 0 0]; % Vektor der Frequenzgaenge
w = [ 1 4 1 4]; % Vektor mit den Gewichten
m = 128; % Filterordnung
b = remez(m,f,g,w); [H W] = freqz(b,1,512);
figure; plot(W/pi,20*log10(abs(H)) );grid; xlabel('Omega/pi');
ylabel('|H(exp(j*Omega))| in dB'); title('TP-BP-Kombination');
% ##### EOF #####
common/l18.m
Executable
+31
View File
@@ -0,0 +1,31 @@
% ##################################################################################
% ## Loesung: Entwurf eines Differenzieres (Remez-Verfahren) ##
% ##################################################################################
% ##### Teilaufgabe a: Differenzierer entwerfen #####
% ### 1:
f = [0 1]; m = [0 1]; b1 = remez(22,f,m);
f = [0 0.9]; m = [0 1]; b2 = remez(21,f,m);
figure; [H1 W] = freqz(b1,1,512); plot(W/pi,abs(H1) ); grid; xlabel('Omega/pi');
ylabel('|H(exp(j*Omega))|'); title('Filterordnung: 22, Typ I');
figure; [H2 W] = freqz(b2,1,512); plot(W/pi,abs(H2) ); grid; xlabel('Omega/pi');
ylabel('|H(exp(j*Omega))|'); title('Filterordnung: 21, Typ III');
figure; stem([0:22], b1); axis([0 22 -0.3 0.5]); grid; xlabel('k');
ylabel('Impulsantwort'); title('Filterordnung: 22, Typ I');
figure; stem([0:21], b2); axis([0 21 -0.3 0.5]); grid; xlabel('k');
ylabel('Impulsantwort'); title('Filterordnung: 21, Typ III');
% ##### Teilaufgabe b: Uebertragungsfunktion vergleichen #####
f = [0 1]; m = [0 1]; b2 = remez(21,f,m,'d');
f = [0 0.9]; m = [0 1]; b1 = remez(22,f,m,'d');
figure; [H1 W] = freqz(b1,1,512); plot(W/pi,abs(H1) ); grid; xlabel('Omega/pi');
ylabel('|H_D(exp(j*Omega))|'); title('Filterordnung: 22, Typ II');
figure; [H2 W] = freqz(b2,1,512); plot(W/pi,abs(H2)); grid; xlabel('Omega/pi');
ylabel('|H_D(exp(j*Omega))|'); title('Filterordnung: 21, Typ IV');
figure; stem([0:22], b1); axis([0 22 -0.4 0.5]); grid; xlabel('k');
ylabel('Impulsantwort'); title('Filterordnung: 22, Typ II');
figure;stem([0:21], b2); axis([0 21 -0.4 0.5]); grid; xlabel('k');
ylabel('Impulsantwort'); title('Filterordnung: 21, Typ IV');
% ##### EOF #####
common/l19.m
Executable
+40
View File
@@ -0,0 +1,40 @@
% ##################################################################################
% ## Loesung: Entwurf eines Hilbert-Transformators (Remez-Verfahren) ##
% ##################################################################################
% ##### Teilaufgabe a: Hilbert-Transformator entwerfen #####
b1 = remez(30,[0.05 0.95],[1 1],'h');
b2 = remez(31,[0.05 1],[1 1],'h');
figure; [H1 W] = freqz(b1,1,512);plot(W/pi,abs(H1)); grid; xlabel('Omega/pi');
ylabel('|H_H(exp(j*Omega))|'); title('Filterordnung: 30 Typ II');
figure; [H2 W] = freqz(b2,1,512);plot(W/pi,abs(H2)); grid; xlabel('Omega/pi');
ylabel('|H_H(exp(j*Omega))|'); title('Filterordnung: 31 Typ IV');
figure; stem([0:30], b1); axis([0 30 -0.8 0.8]); grid; xlabel('k');
ylabel('Impulsantwort'); title('Filterordnung: 30 Typ II');
figure; stem([0:31], b2); axis([0 31 -0.8 0.8]); grid; xlabel('k');
ylabel('Impulsantwort'); title('Filterordnung: 31 Typ IV');
% ##### Teilaufgabe b: Ausgangssignal filtern #####
b = remez(30,[0.05 0.95],[1 1],'h');
Fs = 1000;
t = (0:1/Fs:2)';
x = sin(2*pi*50*t);
xh = filter(b,1,x);
figure, zplane(b); xlabel('Realteil'); ylabel('Imaginaerteil');
title('Pol-Nullstellen-Diagramm');
xd = [zeros(15,1); x(1:length(x)-15)]; % delay 15 samples
figure; plot(t(1:50),xd(1:50),t(1:50),xh(1:50),'--'); grid; xlabel('Zeit (sek)');
ylabel('Amplitude'); title(' - Eingangssig. -- Ausgangssig.');
% ##### Teilaufgabe c: Hilbert-Tranformierte berechnen #####
Fs = 1000;
t = (0:1/Fs:2)';
x = sin(2*pi*50*t);
y = hilbert(x);
figure; plot(t(1:50), real(y(1:50))); grid; hold on;
plot(t(1:50), imag(y(1:50)),'--'); xlabel('Zeit (sek)'); ylabel('Amplitude');
title('-- Hilbert-Transform. - Original');
% ##### EOF #####
common/l2.m
Executable
+48
View File
@@ -0,0 +1,48 @@
% ##################################################################################
% ## Loesung: Trigonometrische Folge ##
% ## -------------------------------------------------------------------------- ##
% ## Benoetigte(s) m-File(s): ldsin.m ##
% ##################################################################################
% ##### Teilaufgabe a: Graphische Darstellung von Signalen #####
% ### 1:
k = 0:25;
x1 = sin((pi/17)*k);
figure; stem(k,x1);grid; xlabel('k'); ylabel('x1(k)');
% ### 2:
k = -15:25;
x2 = sin((pi/17)*k);
figure; stem(k,x2); grid; xlabel('k'); ylabel('x2(k)');
set(gca,'XLim',[-15 25]); set(gca,'XTick',[-15 -10 -5 0 5 10 15 20 25]);
% ### 3:
k = -10:10;
x3 = sin(3*pi*k + (pi/2) );
figure; stem(k,x3); grid; xlabel('k'); ylabel('x3(k)');
% ### 4:
k = 0:50;
x4 = cos( pi/sqrt(23) * k );
figure; stem(k,x4); grid; xlabel('k'); ylabel('x4(k)');
% ### 5:
k = 0:20;
x5 = cos( k );
figure; stem(k,x5); grid; xlabel('k'); ylabel('x5(k)');
% ##### Teilaufgabe b: function m-file #####
[y,k] = ldsin(2,pi/11,pi/2,-20,20);
figure; stem(k,y); grid; xlabel('k'); ylabel('x(k)');
% ##### Teilaufgabe c: Modifizierung #####
[y,k] = ldsin(2,pi/11,pi/2,-20,20);
figure; stem(k,y); grid; title('Teilaufgabe c'); xlabel('k'); ylabel('Amplitude');
% ##### EOF #####
common/l20.m
Executable
+39
View File
@@ -0,0 +1,39 @@
% ##################################################################################
% ## Loesung: Diskrete Fouriertransformation (DFT) ##
% ##################################################################################
% ##### Teilaufgabe a: DFT von x(k) berechnen #####
kk = 0:15;
x = kk + j*(7-kk); xr=real(x); xi=imag(x);
X = fft(x); Xr=real(X); Xi=imag(X);
figure; stem(kk,Xr); title('Re(X(n))'); xlabel('n'); grid;
figure; stem(kk,Xi); title('Im(X(n))'); xlabel('n'); grid;
input('....Fuer naechste Teilaufgabe: RETURN druecken');
% ##### Teilaufgabe b: DFT von Re{x(k)} und Im{x(k)} #####
figure; stem(kk,real(fft(xr))); title('Re(FFT(Re(x(k))))'); xlabel('n'); grid;
figure; stem(kk,imag(fft(xr))); title('Im(FFT(Re(x(k))))'); xlabel('n'); grid;
figure; stem(kk,real(fft(j*xi))); title('Re(FFT(j*Im(x(k))))'); xlabel('n'); grid;
figure; stem(kk,imag(fft(j*xi))); title('Im(FFT(j*Im(x(k))))'); xlabel('n'); grid;
input('....Fuer naechste Teilaufgabe: RETURN druecken');
% ##### Teilaufgabe c: Zyklische Verschiebung #####
xtmp = [x x];
x1_04 = xtmp(kk+5); X1_04 = fft(x1_04);
x1_08 = xtmp(kk+9); X1_08 = fft(x1_08);
figure; stem(kk,Xr); title('Re(X(n))'); xlabel('n'); grid;
figure; stem(kk,Xi); title('Im(X(n))'); xlabel('n'); grid;
figure; stem(kk,real(X1_04)); title('Re(X1(n)), lambda=4'); xlabel('n'); grid;
figure; stem(kk,imag(X1_04)); title('Im(X1(n)), lambda=4'); xlabel('n'); grid;
figure; stem(kk,real(X1_08)); title('Re(X1(n)), lambda=8'); xlabel('n'); grid;
figure; stem(kk,imag(X1_08)); title('Im(X1(n)), lambda=8'); xlabel('n'); grid;
input('....Fuer naechste Teilaufgabe: RETURN druecken');
% ##### Teilaufgabe d: Multiplikation mit exp(j*...) #####
x2 = x.*exp(-j*2*pi*3*kk/16);
X2 = fft(x2);
figure; stem(kk,Xr); title('Re(X(n))'); xlabel('n'); grid;
figure; stem(kk,Xi); title('Im(X(n))'); xlabel('n'); grid;
figure; stem(kk,real(X2)); title('Re(X2(n))'); xlabel('n'); grid;
figure; stem(kk,imag(X2)); title('Im(X2(n))'); xlabel('n'); grid;
% ##### EOF #####
common/l21.m
Executable
+13
View File
@@ -0,0 +1,13 @@
% ##################################################################################
% ## Loesung: DFT: Interpolation ##
% ##################################################################################
N = 64;
x = 1-cos(2*pi/N*(0:N-1)); X = fft(x);
x0 = [x zeros(1,N)]; X0 = fft(x0);
figure; stem(0:N-1,abs(X));axis([0 N-1 0 max(X)]);title('abs(X(n))');
xlabel('n');
figure; stem(0:2*N-1,abs(X0)); axis([0 2*N-1 0 max(X)]);title('abs(X0(n))');
xlabel('n');
% ##### EOF #####
common/l22.m
Executable
+16
View File
@@ -0,0 +1,16 @@
% ##################################################################################
% ## Loesung: Alternative Berechnung der IFFT ##
% ##################################################################################
N = 64;
x = 1 - cos(2*pi/N*(0:N-1));
x0 = [x zeros(1,N)];
X0 = fft(x0); % FFT
X1 = imag(X0) + j*real(X0); % Re() und Im() vertauschen
x1 = fft(X1); % Nochmalige FFT
x2 = imag(x1) + j*real(x1); % Re() und Im() vertauschen
figure; bar(0:2*N-.5,x0); title('x0(k)'); xlabel('k'); axis([-.5 2*N-1 0 2.1]);
figure; bar(0:2*N-.5,x2); title('x2(k)'); xlabel('k'); axis([-.5 2*N-1 0 269]);
% ##### EOF #####
common/l23.m
Executable
+12
View File
@@ -0,0 +1,12 @@
% ##################################################################################
% ## Loesung: DFT reeller Datenfolgen ##
% ## -------------------------------------------------------------------------- ##
% ## Benoetigte(s) m-File(s): lfft.m ##
% ##################################################################################
N = 2^10;
x = randn(1,N);
X1 = fft(x);
X2 = lfft(x);
differenz = mean(abs(X1-X2).^2)
% ##### EOF #####
common/l24.m
Executable
+19
View File
@@ -0,0 +1,19 @@
% ##################################################################################
% ## Loesung: Spektraltransformation reeller Bandpass-Signale ##
% ## -------------------------------------------------------------------------- ##
% ## Benoetigte(s) m-File(s): lband.m ##
% ##################################################################################
NFFT = 2^10;
b1 = lband(1000,0.2,0.02); fT = 0:1/NFFT:1-1/NFFT;
% Originalsignal
b2 = b1; lb = length(b2); aB2_hn=abs(fft(b2.*hanning(lb),NFFT));
figure; plot(fT, aB2_hn); axis([0 1 0 1.1*max(aB2_hn)]); xlabel('Omega/2pi = f T');
ylabel('|B(exp(j*Omega))|');
for k=[9 10 11 12] %Unterabtastung um Faktor k
b2 = b1(1:k:1000); lb = length(b2); aB2_hn=abs(fft(b2.*hanning(lb),NFFT));
figure; plot(fT,aB2_hn); axis([0 1 0 1.1*max(aB2_hn)]); xlabel('Omega/2pi = f T');
ylabel('|B_M(exp(j*Omega))|'); title(sprintf('Unterabtastung um Faktor M=%d',k));
end;
% ##### EOF #####
common/l25.m
Executable
+31
View File
@@ -0,0 +1,31 @@
% ##################################################################################
% ## Loesung: DFT: Abbruchfehler, Unterabtastung ##
% ##################################################################################
kk08 = 0:7;
kk64 = 0:63;
x1_08 = sin(kk08*pi/8); x1_64 = sin(kk64*pi/8);
x2_08 = sin(kk08*pi/2); x2_64 = sin(kk64*pi/2);
x3_08 = sin(kk08*pi*3/2); x3_64 = sin(kk64*pi*3/2);
figure; kk100=0:8/100:8; plot(kk100,sin(kk100*pi/8),':'); hold on;
stem(kk08,x1_08); axis([0 8 -1.2 1.2]); title('x1(k)=sin(k*pi/8), k=0...7');
figure;stem(kk08,abs(fft(x1_08))); axis([0 7 -1 6]); title('abs(X1(n)),n=0...7');
figure;stem(kk64,x1_64);axis([0 64 -1.2 1.2]);title('x1(k)=sin(k*pi/8),k=0...63');
figure;stem(kk64,abs(fft(x1_64)));axis([0 64 -1 40]);title('abs(X1(n)),n=0...63');
input('....Zum Fortfahren: RETURN druecken');
figure; kk100=0:8/100:8; plot(kk100,sin(kk100*pi/2),':'); hold on;
stem(kk08,x2_08); axis([0 8 -1.2 1.2]); title('x2(k)=sin(k*pi/2), k=0...7');
figure;stem(kk08,abs(fft(x2_08))); axis([0 7 -1 6]); title('abs(X2(n)),n=0...7');
figure;stem(kk64,x2_64);axis([0 64 -1.2 1.2]);title('x2(k)=sin(k*pi/2),k=0...63');
figure;stem(kk64,abs(fft(x2_64)));axis([0 64 -1 40]);title('abs(X2(n))),n=0...63');
input('....Zum Fortfahren: RETURN druecken');
figure; kk100=0:8/100:8; plot(kk100,sin(kk100*pi*3/2),':'); hold on;
stem(kk08,x3_08); axis([0 8 -1.2 1.2]); title('x3(k)=sin(k*pi*3/2), k=0...7');
figure;stem(kk08,abs(fft(x3_08))); axis([0 8 -1 6]); title('abs(X3(n)), n=0...7');
axis([0 7 -1 6]);
figure;stem(kk64,x3_64);axis([0 64 -1.2 1.2]);title('x3(k)=sin(k*pi*3/2),k=0...63');
figure;stem(kk64,abs(fft(x3_64)));axis([0 64 -1 40]);title('abs(X3(n)),n=0...63');
% ##### EOF #####
common/l26.m
Executable
+69
View File
@@ -0,0 +1,69 @@
% ##################################################################################
% ## Loesung: Vergleich versch. Fensterfunktionen ##
% ##################################################################################
N = 63; NFFT = 2^9;
f_re = boxcar(N); aF_re = abs(fft(f_re,NFFT)/sum(f_re));
f_hn = hanning(N); aF_hn = abs(fft(f_hn,NFFT)/sum(f_hn));
f_hm = hamming(N); aF_hm = abs(fft(f_hm,NFFT)/sum(f_hm));
f_bl = blackman(N); aF_bl = abs(fft(f_bl,NFFT)/sum(f_bl));
a_d1=48.6; f_d1=chebwin(N,a_d1); aF_d1 = abs(fft(f_d1,NFFT)/sum(f_d1));
a_d2=76.1; f_d2=chebwin(N,a_d2); aF_d2 = abs(fft(f_d2,NFFT)/sum(f_d2));
kk = 0:N-1; fT = 0:1/NFFT:1-1/NFFT;
% Berechnung von a_{min} (fsT:=Omega_s/(2*pi); Sperrber.: n_s+1<=n<=NFFT+1-n_s)
fsT=1/N; n_s=round(NFFT*fsT); a_re=20*log10(max(aF_re(n_s+1:NFFT+1-n_s)));
fsT=2/N; n_s=round(NFFT*fsT); a_hn=20*log10(max(aF_hn(n_s+1:NFFT+1-n_s)));
fsT=2/N; n_s=round(NFFT*fsT); a_hm=20*log10(max(aF_hm(n_s+1:NFFT+1-n_s)));
fsT=3/N; n_s=round(NFFT*fsT); a_bl=20*log10(max(aF_bl(n_s+1:NFFT+1-n_s)));
figure; % RECHTECK-Fenster
bar(kk,f_re); axis([-.5 N-.5 0 1.1]); title('Rechteck-Fenster'); ylabel('f(k)');
xlabel('k');
figure; plot(fT,20*log10(aF_re)); hold on; axis([0 1 -150 10]);
text(.3,a_re+13,sprintf('a_{min} = %3.1f dB',-a_re));
plot([0 1.9],[a_re a_re],'--'); title('|Normierte Spektralfunktion|');
ylabel('|F(exp(j*Om.))/F(exp(j*0))| in dB'); xlabel('Omega/2pi = f T');
input('....Zum Fortfahren: RETURN druecken');
figure; % HANNING-Fenster
bar(kk,f_hn); axis([-.5 N-.5 0 1.1]); title('Hanning-Fenster'); ylabel('f(k)');
xlabel('k');
figure; plot(fT,20*log10(aF_hn)); hold on; axis([0 1 -150 10]);
text(.3,a_hn+15,sprintf('a_{min} = %3.1f dB', -a_hn));
plot([0 1.9],[a_hn a_hn],'--'); title('|Normierte Spektralfunktion|');
ylabel('|F(exp(j*Om.))/F(exp(j*0))| in dB'); xlabel('Omega/2pi = f T');
input('....Zum Fortfahren: RETURN druecken');
figure; % HAMMING-Fenster
bar(kk,f_hm); axis([-.5 N-.5 0 1.1]); title('Hamming-Fenster'); ylabel('f(k)');
xlabel('k');
figure; plot(fT,20*log10(aF_hm)); hold on; axis([0 1 -150 10]);
text(.3,a_hm+15,sprintf('a_{min} = %3.1f dB', -a_hm));
plot([0 1.9],[a_hm a_hm],'--'); title('|Normierte Spektralfunktion|');
ylabel('|F(exp(j*Om.))/F(exp(j*0))| in dB'); xlabel('Omega/2pi = f T');
input('....Zum Fortfahren: RETURN druecken');
figure; % BLACKMAN-Fenster
bar(kk,f_bl); axis([-.5 N-.5 0 1.1]); title('Blackman-Fenster'); ylabel('f(k)');
xlabel('k');
figure; plot(fT,20*log10(aF_bl)); hold on; axis([0 1 -150 10]);
text(.3,a_bl+15,sprintf('a_{min} = %3.1f dB', -a_bl));
plot([0 1.9],[a_bl a_bl],'--'); title('|Normierte Spektralfunktion|');
ylabel('|F(exp(j*Om.))/F(exp(j*0))| in dB'); xlabel('Omega/2pi = f T');
input('....Zum Fortfahren: RETURN druecken');
figure; % DOLPH-TSCHEBYSCHEFF-1
bar(kk,f_d1); axis([-.5 N-.5 0 1.1]);title(sprintf('Dolph-Tscheby.,%3.1fdB',a_d1));
ylabel('f(k)'); xlabel('k');
figure; plot(fT,20*log10(aF_d1)); hold on; axis([0 1 -150 10]);
text(.3,-a_d1+15,sprintf('a_{min} = %3.1f dB',a_d1));
title('|Normierte Spektralfunktion|'); ylabel('|F(exp(j*Om.))/F(exp(j*0))| in dB');
xlabel('Omega/2pi = f T'); input('....Zum Fortfahren: RETURN druecken');
figure; % DOLPH-TSCHEBYSCHEFF-2
bar(kk,f_d2); axis([-.5 N-.5 0 1.1]);title(sprintf('Dolph-Tscheby.,%3.1fdB',a_d2));
ylabel('f(k)'); xlabel('k');
figure; plot(fT,20*log10(aF_d2)); hold on; axis([0 1 -150 10]);
text(.3,-a_d2+15,sprintf('a_{min} = %3.1f dB',a_d2));
title('|Normierte Spektralfunktion|'); ylabel('|F(exp(j*Om.))/F(exp(j*0))| in dB');
xlabel('Omega/2pi = f T');
% ##### EOF #####
common/l27.m
Executable
+33
View File
@@ -0,0 +1,33 @@
% ##################################################################################
% ## Loesung: Seitenbanddaempfung des Blackman-Fenster ##
% ##################################################################################
NFFT=2^10;
f_bl032= blackman(32); aF_bl032= abs(fft(f_bl032,NFFT)/sum(f_bl032));
f_bl064= blackman(64); aF_bl064= abs(fft(f_bl064,NFFT)/sum(f_bl064));
f_bl128= blackman(128); aF_bl128= abs(fft(f_bl128,NFFT)/sum(f_bl128));
fT = 0:1/NFFT:1-1/NFFT;
% Berechnung der minimalen Sperrdaempfung a_{min}:
% Os := Omega_s/(2*pi); n_s: Sperrbereich-Indices: n_s+1<=n<=NFFT+1-n_s
Os=3/32; n_s=round(NFFT*Os); a032=20*log10(max(aF_bl032(n_s+1:NFFT+1-n_s)));
Os=3/64; n_s=round(NFFT*Os); a064=20*log10(max(aF_bl064(n_s+1:NFFT+1-n_s)));
Os=3/128; n_s=round(NFFT*Os); a128=20*log10(max(aF_bl128(n_s+1:NFFT+1-n_s)));
figure; plot(fT, 20*log10(aF_bl032)); hold on; axis([0 1 -180 10]);
text(0.41,a032,sprintf('a_{min} = %3.1f dB',-a032));
plot([0 0.39], [a032 a032], '--');
title('|Norm. Spektralfunktion| des Blackmanfensters: N=32');
ylabel('|F(exp(j*Om.))/F(exp(j*0))| in dB'); xlabel('Omega/2pi = f T');
figure; plot(fT, 20*log10(aF_bl064)); hold on; axis([0 1 -180 10]);
text(0.41,a064,sprintf('a_{min} = %3.1f dB',-a064));
plot([0 0.39], [a064 a064], '--');
title('|Norm. Spektralfunktion| des Blackmanfensters: N=64');
ylabel('|F(exp(j*Om.))/F(exp(j*0))| in dB'); xlabel('Omega/2pi = f T');
figure; plot(fT, 20*log10(aF_bl128)); hold on; axis([0 1 -180 10]);
text(0.41,a128,sprintf('a_{min} = %3.1f dB',-a128));
plot([0 0.39], [a128 a128], '--');
title('|Norm. Spektralfunktion| des Blackmanfensters: N=128');
ylabel('|F(exp(j*Om.))/F(exp(j*0))| in dB'); xlabel('Omega/2pi = f T');
% ##### EOF #####
common/l28.m
Executable
+10
View File
@@ -0,0 +1,10 @@
% ##################################################################################
% ## Loesung: Dolph-Tschebyscheff-Fenster ##
% ## -------------------------------------------------------------------------- ##
% ## Benoetigte(s) m-File(s): lcheby.m ##
% ##################################################################################
%
[f,F,a_min]=lcheby(32, 0.1*pi, 2*pi/256);
[f,F,a_min]=lcheby(64, 0.1*pi, 2*pi/256);
[f,F,a_min]=lcheby(32, 0.4*pi, 2*pi/256);
% ##### EOF #####
common/l29.m
Executable
+32
View File
@@ -0,0 +1,32 @@
% ##################################################################################
% ## Loesung: Verminderung des Leckeffektes durch Fensterung ##
% ##################################################################################
N = 64;
kk = (0:N-1); kk2 = (0:2*N-1);
x1 = sin(kk*pi/8); X1 = fft(x1);
x1Hm = x1.*hamming(N).'; X1Hm = fft(x1Hm);
x2 = sin(kk*pi/10); X2 = fft(x2);
x2Hm = x2.*hamming(N).'; X2Hm = fft(x2Hm);
figure; stem(kk2, [x1 x1]); axis([0 2*N -1.1 1.1]); ylabel('x1((k))');
title('x1(k)=sin(k*pi/8), k=0..63, zweifach periodisch fortgesetzt'); xlabel('k');
figure; stem(kk, abs(X1)); axis([0 N 0 1.1*N/2]); ylabel('|X1(n)|');
title('Betragsspektrum von x1(k)'); xlabel('n');
figure; stem(kk2, [x1Hm x1Hm]); axis([0 2*N -1.1 1.1]); ylabel('x1_Hm((k))');
title('Hamming-gefenstertes x1(k), zweifach periodisch fortgesetzt'); xlabel('k');
figure; stem(kk, abs(X1Hm)); axis([0 N 0 1.1*N/2]); ylabel('|X1_Hm(n)|');
title('Betragsspektrum bei Hamming-Fensterung'); xlabel('n');
input('......fuer 2.Datenfolge: RETURN druecken');
figure; stem(kk2, [x2 x2]); axis([0 2*N -1.1 1.1]); ylabel('x2((k))');
title('x2(k)=sin(k*pi/10), k=0..63, zweifach periodisch fortgesetzt'); xlabel('k');
figure; stem(kk, abs(X2)); axis([0 N 0 1.1*N/2]); ylabel('|X2(n)|');
title('Betragsspektrum von x2(k)'); xlabel('n');
figure; stem(kk2, [x2Hm x2Hm]); axis([0 2*N -1.1 1.1]); ylabel('x2_Hm((k))');
title('Hamming-gefenstertes x2(k), zweifach periodisch fortgesetzt'); xlabel('k');
figure; stem(kk, abs(X2Hm)); axis([0 N 0 1.1*N/2]); ylabel('|X2_Hm(n)|');
title('Betragsspektrum bei Hamming-Fensterung'); xlabel('n');
% ##### EOF #####
common/l3.m
Executable
+29
View File
@@ -0,0 +1,29 @@
% ##################################################################################
% ## Loesung: Reellwertige Exponentialfolge ##
% ## -------------------------------------------------------------------------- ##
% ## Benoetigte(s) m-File(s): lgenexp.m ##
% ##################################################################################
% ##### Teilaufgabe a: Exponentialfolge erzeugen #####
[y,k] = lgenexp(0.9, 0, 21);
figure; stem(k,y); grid; xlabel('k'); ylabel('x(k)');
% ##### Teilaufgabe b: Summenformel ueberpruefen #####
a = 0.9;
k0 = 0;
L = 30;
y = lgenexp(a, k0, L);
y1 = sum(y);
y2 = (1-a^L)/(1-a);
% ##### Teilaufgabe c: filter()-Funktion anwenden #####
a = [1 -0.9];
b = 1;
d = [1; zeros(20,1)];
y = filter(b,a,d);
k=0:20;
figure; stem(k,y); grid; xlabel('k'); ylabel('Amplitude');
% ##### EOF #####
common/l30.m
Executable
+53
View File
@@ -0,0 +1,53 @@
% ##################################################################################
% ## Loesung: Effizienz des Raderverfahrens ##
% ## -------------------------------------------------------------------------- ##
% ## Benoetigte(s) m-File(s): lrader.m, lsum.m, lakffft.m ##
% ##################################################################################
% Anhand der verwendeten Rechenoperationen (flops) sowie der Rechen-
% zeit wird ein Vergleich der Rechengeschwindigkeit einer AKF-
% Schaetzung nach Rader mit einer direkten Berechnung (Summenformel)
% durchgefuehrt. Die Ergebnisse werden mit diesem m-File aufgetragen.
N = 2^10;
x = randn(1,N)+j*randn(1,N);
loop = 1:6;
for l = loop
flops(0);
zeit = cputime;
rxx1 = lrader(2^l,x);
time_rader(l) = cputime-zeit;
flops_rader(l) = flops;
flops(0);
zeit = cputime;
rxx2 = lsum(2^l,x);
time_sum(l) = cputime-zeit;
flops_sum(l) = flops;
flops(0);
zeit = cputime;
rxx3 = lakffft(2^l,x);
time_fft(l) = cputime-zeit;
flops_fft(l) = flops;
end;
disp ('Mean square error (MSE) der AKF-Sch. bzgl. Summenformel:');
disp (sprintf(' mse_rader: %g', mean(abs(rxx1-rxx2).^2)));
disp (sprintf(' mse_fft : %g', mean(abs(rxx3-rxx2).^2)));
MM = (2*ones(1,length(loop))).^loop; time_max = max(time_rader);
kflops_max = 300;
figure; plot(MM, time_sum); hold on; plot(MM, time_rader,'--');
plot(MM, time_fft,':'); axis([0 2^max(loop) 0 1.1*time_max]); xlabel('M');
title('Zur AKF-Schaetzung benoetigte Rechenzeit'); ylabel('CPU-Zeit in Sek.');
pos=0.9*time_max; text(38,pos,'___'); text(45,pos,'Summe');
pos=0.64*time_max; text(38,pos,'- -'); text(45,pos,'Rader');
pos=0.46*time_max; text(38,pos,'. . .'); text(45,pos,'FFT');
figure; plot(MM, flops_sum/1000); hold on; plot(MM, flops_rader/1000,'--');
plot(MM, flops_fft/1000,':'); axis([0 2^max(loop) 0 1.1*300]);
title('Erforderlicher Rechenaufwand in kflops'); ylabel('kflops'); xlabel('M');
pos=0.22*kflops_max; text(38,pos, '- -'); text(45,pos,'Rader');
pos=0.95*kflops_max; text(38,pos, '___'); text(45,pos,'Summe');
pos=0.67*kflops_max; text(38,pos,'. . . '); text(45,pos,'FFT');
% ##### EOF #####
common/l31.m
Executable
+45
View File
@@ -0,0 +1,45 @@
% ##################################################################################
% ## Loesung: Schaetzung des Leistungsdichtespektrums mit Periodogramm ##
% ## -------------------------------------------------------------------------- ##
% ## Benoetigte(s) m-File(s): lper.m ##
% ##################################################################################
% Teilaufg. a: Lineare Filterung
N = 2^12; % mittelwertfreies, gaussvert., weisses Rauschen
N_vor=500; %Anzahl der Abtastwerte um das System in den eingeschw.
%Zustand zu setzen
n = randn(1,N+N_vor);% der Leistung eins
h1 = [1 -4 6 -4 +1]; x1_all = filter(h1,1,n); x1=x1_all(N_vor+1:length(x1_all));
h2 = [1 0.8]; x2_all = filter(1,h2,n); x2=x2_all(N_vor+1:length(x2_all));
% Teilaufg. b: "Wahres" Leistungsdichtespektrum fuer die beiden Filter
NFFT = 2^12;
Sx1x1 = abs(fft(h1,NFFT)).^2; axis_Sx1=[0 1 0 2*max(Sx1x1)];
Sx2x2 = ones(1,NFFT)./abs(fft(h2,NFFT)).^2; axis_Sx2=[0 1 0 1.5*max(Sx2x2)];
fT = 0:1/NFFT:1-1/NFFT;
figure; plot(fT,Sx1x1); axis([0 1 0 1.1*max(Sx1x1)]);xlabel('Omega/2pi = f T');
title('Wahres Leistungsdichtespektrum Sx1x1 von x1');ylabel('Sxx(exp(j*Omega))');
figure; plot(fT,Sx2x2); axis([0 1 0 1.1*max(Sx2x2)]);xlabel('Omega/2pi = f T');
title('Wahres Leistungsdichtespektrum Sx2x2 von x2');ylabel('Sxx(exp(j*Omega))');
input('....Fuer naechste Teilaufgabe: RETURN druecken');
% Teilaufg. c: Periodogramme und wahre Leistungsdichtespektren zeichnen
fT = 0:1/NFFT:1-1/NFFT;
for k=[2^6, 2^8, 2^10, 2^12]
Sxx=lper(x1(1:k) ,NFFT);
figure; plot(fT,Sxx); hold on; ylabel('Per(Om)');
plot(fT,Sx1x1,'--'); xlabel('Omega/2pi = f T');
title(sprintf('Periodogramm von Sx1x1, N=%d', k)); axis(axis_Sx1);
end;
input('....Zum Fortfahren: RETURN druecken');
for k=[2^6, 2^8, 2^10, 2^12]
Sxx=lper(x2(1:k) ,NFFT);
figure; plot(fT,Sxx); hold on; ylabel('Per(Om)');
plot(fT,Sx2x2,'--'); xlabel('Omega/2pi = f T');
title(sprintf('Periodogramm von Sx2x2, N=%d', k)); axis(axis_Sx2);
end;
% ##### EOF #####
common/l32.m
Executable
+53
View File
@@ -0,0 +1,53 @@
% ##################################################################################
% ## Loesung: Schaetzung des Leistungsdichtespektrums nach Blackman-Tuckey ##
% ## -------------------------------------------------------------------------- ##
% ## Benoetigte(s) m-File(s): lblack.m und darin: lrader.m ##
% ##################################################################################
N = 2^12;
N_vor=500; %Anzahl der Abtastwerte um das System
%in den eingeschw. Zustand zu setzen
n = randn(1,N); % Modellrauschprozesse
h1 = [1 -4 6 -4 +1]; x1_all = filter(h1,1,n); x1=x1_all(N_vor+1:length(x1_all));
h2 = [1 0.8]; x2_all = filter(1,h2,n); x2=x2_all(N_vor+1:length(x2_all));
% "Wahres" Leistungsdichtespektrum zum Vergleich berechnen
NFFT = 2^12;
Sx1x1 = abs(fft(h1,NFFT)).^2; axis_Sx1=[0 1 0 1.35*max(Sx1x1)];
Sx2x2 = ones(1,NFFT)./abs(fft(h2,NFFT)).^2; axis_Sx2=[0 1 0 1.35*max(Sx2x2)];
fT = 0:1/NFFT:1-1/NFFT;
% Schaetzung des Leistungsdichtespektrums fuer M=8, 32, 128
win = 'triang';
Sxx=lblack(x1, 8,win,NFFT);
figure; plot(fT,Sx1x1,'--'); xlabel('Omega/2pi = f T');
hold on; plot(fT,Sxx); ylabel('Sxx(exp(j*Omega))');
title('Bl.-Tukey-Sch. von Sx1x1(exp(j*Omega)), M=8 (Dreieck)');axis(axis_Sx1);
Sxx=lblack(x1, 32,win,NFFT);
figure; plot(fT,Sx1x1,'--'); xlabel('Omega/2pi = f T');
hold on; plot(fT,Sxx); ylabel('Sxx(exp(j*Omega))');
title('Bl.-Tukey-Sch. von Sx1x1(exp(j*Omega)), M=32 (Dreieck)'); axis(axis_Sx1);
Sxx=lblack(x1, 128,win,NFFT);
figure; plot(fT,Sx1x1,'--'); xlabel('Omega/2pi = f T');
hold on; plot(fT,Sxx); ylabel('Sxx(exp(j*Omega))');
title('Bl.-Tukey-Sch. von Sx1x1(exp(j*Omega)), M=128 (Dreieck)'); axis(axis_Sx1);
input('....Zum Fortfahren: RETURN druecken');
Sxx=lblack(x2, 8,win,NFFT);
figure; plot(fT,Sx2x2,'--'); xlabel('Omega/2pi = f T');
hold on; plot(fT,Sxx); ylabel('Sxx(exp(j*Omega))');
title('Bl.-Tukey-Sch. von Sx2x2(exp(j*Omega)), M=8 (Dreieck)');axis(axis_Sx2);
Sxx=lblack(x2, 32,win,NFFT);
figure; plot(fT,Sx2x2,'--'); xlabel('Omega/2pi = f T');
hold on; plot(fT,Sxx); ylabel('Sxx(exp(j*Omega))');
title('Bl.-Tukey-Sch. von Sx2x2(exp(j*Omega)), M=32 (Dreieck)'); axis(axis_Sx2);
Sxx=lblack(x2, 128,win,NFFT);
figure; plot(fT,Sx2x2,'--'); xlabel('Omega/2pi = f T');
hold on; plot(fT,Sxx); ylabel('Sxx(exp(j*Omega))');
title('Bl.-Tukey-Sch. von Sx1x1(exp(j*Omega)), M=128 (Dreieck)'); axis(axis_Sx2);
% ##### EOF #####
common/l33.m
Executable
+52
View File
@@ -0,0 +1,52 @@
% ##################################################################################
% ## Loesung: Schaetzung des Leistungsdichtespektrums nach Bartlett und Welch ##
% ## -------------------------------------------------------------------------- ##
% ## Benoetigte(s) m-File(s): lwelch.m ##
% ##################################################################################
N = 2^10; N_vor=500; n = randn(1,N+N_vor); % Modellrauschprozesse
h1 = [1 -4 6 -4 +1]; x1_all = filter(h1,1,n); x1=x1_all(N_vor+1:length(x1_all));
h2 = [1 0.8]; x2_all = filter(1,h2,n); x2=x2_all(N_vor+1:length(x2_all));
NFFT = 2^10; % "Wahres" Leistungsdichtespektrum zum Vergleich
Sx1x1 = abs(fft(h1,NFFT)).^2; axis_Sx1=[0 1 0 1.5*max(Sx1x1)];
Sx2x2 = ones(1,NFFT)./abs(fft(h2,NFFT)).^2; axis_Sx2=[0 1 0 1.5*max(Sx2x2)];
fT = 0:1/NFFT:1-1/NFFT;
v_K = [1 4 16 64];
win='boxcar'; % BARTLETT fuer x1
for k=v_K
S_xx=lwelch(x1,k,win,NFFT);
figure; plot(fT,S_xx); hold on; ylabel('Sxx(exp(j*Omega))');
plot(fT,Sx1x1,'--'); axis(axis_Sx1); xlabel('Omega/2pi = f T');
title(sprintf('Bartlett-Sch. von Sx1x1(exp(j*Om.)); K=%d und L=%d/K',k, N));
text(0.73,900,'== Periodogramm');
end;
input('......zum Fortfahren: RETURN druecken');
win='hamming'; % WELCH-Verf. mit Hamming fuer x1
for k=v_K
S_xx=lwelch(x1,k,win,NFFT);
figure; plot(fT,S_xx); hold on; ylabel('Sxx(exp(j*Omega))');
plot(fT,Sx1x1,'--'); axis(axis_Sx1); xlabel('Omega/2pi = f T');
title(sprintf('Bartlett-Sch. von Sx1x1(exp(j*Om.)); K=%d und L=%d/K',k, N));
end;
input('......zum Fortfahren: RETURN druecken');
win='boxcar'; % BARTLETT fuer x2
for k=v_K
S_xx=lwelch(x2,k,win,NFFT);
figure; plot(fT,S_xx); hold on; ylabel('Sxx(exp(j*Omega))');
plot(fT,Sx2x2,'--'); axis(axis_Sx2); xlabel('Omega/2pi = f T');
title(sprintf('Bartlett-Sch. von Sx2x2(exp(j*Om.)); K=%d und L=%d/K',k, N));
text(0.73,900,'== Periodogramm');
end;
input('......zum Fortfahren: RETURN druecken');
win='hamming'; % WELCH-Verf. mit Hamming fuer x2
for k=v_K
S_xx=lwelch(x2,k,win,NFFT);
figure; plot(fT,S_xx); hold on; ylabel('Sxx(exp(j*Omega))');
plot(fT,Sx2x2,'--'); axis(axis_Sx2); xlabel('Omega/2pi = f T');
title(sprintf('Bartlett-Sch. von Sx2x2(exp(j*Om.)); K=%d und L=%d/K',k, N));
end;
% ##### EOF
common/l34.m
Executable
+90
View File
@@ -0,0 +1,90 @@
% ##################################################################################
% ## Loesung: Yule-Walker und Burg-Algorithmus ##
% ## -------------------------------------------------------------------------- ##
% ## Benoetigte(s) m-File(s): lywex.m, lburg.m ##
% ##################################################################################
NFFT = 2^10; N = 2^12;
p=[1 8 32]; MA = [1 -4 6 -4 1]; AR = 1;
% Teilaufg. a
q = length(MA)-1;
disp(sprintf('Wahre AKF (rxx(-%d),...,rxx(0),...,rxx(%d)):', q, q));
rxx = xcorr(MA).'
% Teilaufg. b und c:
%%%%%%%%%%%%%%%%%%%%%%%%%% Yule-Walker %%%%%%%%%%%%%%%%%%%%%%%%%
% Ausgabe des tatsaechlichen ARMA- und des "geschaetzten" AR-Betragspektrums
Omega_norm = 0:1/NFFT:1-1/NFFT;
for k=1:3
[Sxx_ar, Sxx_arma, ar]=lywex(MA,AR,p(k),NFFT);
figure; plot(Omega_norm, abs(Sxx_arma),'--'); hold on;
plot(Omega_norm, abs(Sxx_ar)); hold off;
axis([0 1 0 1.25*max(Sxx_arma)]); ylabel('Sxx(Omega)');
title(sprintf('LDS von YW-AR(%d)', p(k))); xlabel('Omega/2pi');
figure; zplane(MA,ar); title(sprintf('Pole von YW-AR(%d)',p(k)));
xlabel('Realteil'); ylabel('Imaginaerteil');
end;
input('....naechste Teilaufgabe: RETURN druecken');
% Teilaufg. d:
%%%%%%%%%%%%%%%%%%%%%%%%%% Burg-Methode %%%%%%%%%%%%%%%%%%%%%%%%%
% Ausgabe des tatsaechlichen ARMA- und des geschaetzten AR-Betragspektrums
Omega_norm = 0:1/NFFT:1-1/NFFT;
Sxx_arma = abs(fft(MA,NFFT)./fft(AR,NFFT)).^2;
for k=1:3
ar=lburg(N,p(k),MA,AR,NFFT);
Sxx_ar = abs(ones(1,NFFT)./fft(ar,NFFT)).^2;
Sxx_ar = Sxx_ar/sum(Sxx_ar).*sum(Sxx_arma);
figure; plot(Omega_norm, Sxx_arma,'--'); hold on;
plot(Omega_norm, Sxx_ar); hold off;
axis([0 1 0 1.25*max(Sxx_arma)]); ylabel('Sxx(Omega)');
title(sprintf('LDS von Burg-AR(%d)', p(k))); xlabel('Omega/2pi');
figure; zplane(MA,ar); title(sprintf('Pole von Burg-AR(%d)',p(k)));
xlabel('Realteil'); ylabel('Imaginaerteil');
end;
input('....naechste Teilaufgabe: RETURN druecken');
% Teilaufg. e:
MA=1; AR = [1 0.8];
%%%%%%%%%%%%%%%%%%%%%%%%%% Yule-Walker %%%%%%%%%%%%%%%%%%%%%%%%%
% Ausgabe des tatsaechlichen ARMA- und des "geschaetzten" AR-Betragspektrums
Omega_norm = 0:1/NFFT:1-1/NFFT;
for k=1:3
[Sxx_ar, Sxx_arma, ar]=lywex(MA,AR,p(k),NFFT);
figure; plot(Omega_norm, abs(Sxx_arma),'--'); hold on;
plot(Omega_norm, abs(Sxx_ar)); hold off;
axis([0 1 0 1.25*max(Sxx_arma)]); ylabel('Sxx(Omega)');
title(sprintf('LDS von YW-AR(%d)', p(k))); xlabel('Omega/2pi');
figure; zplane(MA,ar); title(sprintf('Pole von YW-AR(%d)',p(k)));
xlabel('Realteil'); ylabel('Imaginaerteil');
end;
input('....Zum Fortfahren: RETURN druecken');
%%%%%%%%%%%%%%%%%%%%%%%%%% Burg-Methode %%%%%%%%%%%%%%%%%%%%%%%%%
% Ausgabe des tatsaechlichen ARMA- und des geschaetzten AR-Betragspektrums
Omega_norm = 0:1/NFFT:1-1/NFFT;
Sxx_arma = abs(fft(MA,NFFT)./fft(AR,NFFT)).^2;
for k=1:3
ar=lburg(N,p(k),MA,AR,NFFT);
Sxx_ar = abs(ones(1,NFFT)./fft(ar,NFFT)).^2;
Sxx_ar = Sxx_ar/sum(Sxx_ar).*sum(Sxx_arma);
figure; plot(Omega_norm, Sxx_arma,'--'); hold on;
plot(Omega_norm, Sxx_ar); hold off;
axis([0 1 0 1.25*max(Sxx_arma)]); ylabel('Sxx(Omega)');
title(sprintf('LDS von Burg-AR(%d)', p(k))); xlabel('Omega/2pi');
figure; zplane(AR,ar); title(sprintf('Pole von Burg-AR(%d)',p(k)));
xlabel('Realteil'); ylabel('Imaginaerteil');
end;
% ##### EOF #####
common/l4.m
Executable
+21
View File
@@ -0,0 +1,21 @@
% ##################################################################################
% ## Loesung: Komplexwertige Exponentialfolge ##
% ## -------------------------------------------------------------------------- ##
% ## Benoetigte(s) m-File(s): lgenexp.m ##
% ##################################################################################
% ##### Teilaufgabe a: komplexe Exponentialfolge erzeugen #####
z0 = 0.9*( cos(pi/4) + j*sin(pi/4) );
[x,k] = lgenexp(z0, 0, 21);
figure; stem(k,real(x)); xlabel('k'); ylabel('Amplitude'); title('Realteil'); grid;
figure; stem(k,imag(x)); xlabel('k'); ylabel('Amplitude'); title('Imaginaerteil');
grid;
% ##### Teilaufgabe b: Imaginaerteil ueber Realteil #####
z0 = 0.9*( cos(pi/4) + j*sin(pi/4) );
x = lgenexp(z0, 0, 21 );
figure; plot(x); grid; xlabel('Realteil'); ylabel('Imaginaerteil');
title('Phi = 45 [Grad]');
% ##### EOF #####
common/l5.m
Executable
+12
View File
@@ -0,0 +1,12 @@
% ##################################################################################
% ## Loesung: Differenzengleichungen ##
% ##################################################################################
% ##### Teilaufgabe c: 128 Werte der Impulsantwort #####
b = [0.3 0.6 0.3];
a = [1 0 0.9];
k=[0:127]';
impz(b,a,k); %Berechnung der Impulsantwort
title('Impulsantwort'); grid; xlabel('k'); ylabel('Amplitude');
% ##### EOF #####
common/l6.m
Executable
+83
View File
@@ -0,0 +1,83 @@
% ##################################################################################
% ## Loesung: Impuls-, Sprungantworten, Frequenzgang ##
% ##################################################################################
% ##### Teilaufgabe a: Bestimmung der Impulsantwort #####
x = zeros(111,1);
x(11) = 1;
b = [1 0.5];
a = [1 -(1.8*cos(pi/16)) 0.81];
y = filter(b,a,x);
k=[-10:100]';
figure; stem(k,y); axis([-10 100 -1 5]); grid; xlabel('k');
ylabel('Amplitude'); title('Impulsantwort');
% ##### Teilaufgabe b: Bestimmung der Sprungantwort #####
x = [zeros(10,1) ; ones(101,1)];
b = [1 0.5];
a = [1 -(1.8*cos(pi/16)) 0.81];
y = filter(b,a,x);
k=[-10:100]';
figure; stem(k,y); axis([-10 100 0 40]); grid; xlabel('k');
ylabel('Amplitude'); title('Sprungantwort');
% ##### Teilaufgabe c: Erste Differenz der Sprungfunktion #####
d = zeros(111,1);
d(11) = 1;
b = [1 0.5];
a = [1 -(1.8*cos(pi/16)) 0.81];
h = filter(b,a,d);
s = [zeros(10,1) ; ones(101,1)];
g = filter(b,a,s);
h2 = diff(g,1);
k = [-10:100]';
figure; stem(k(2:length(k)),h2); grid; xlabel('k'); ylabel('Amplitude');
title('Erste Differenz der Sprungantwort'); axis([-10 100 -1 5]);
disp('Zum Fortfahren: Druecken Sie eine beliebige Taste...'); pause;
% ##### Teilaufgabe d: Ausgangssignal #####
x = exp(j*[1:100]*(pi/3));
b = [1 0.5];
a = [1 -(1.8*cos(pi/16)) 0.81];
y = filter(b,a,x);
figure; plot(real(y)); grid; xlabel('k'); title('Realteil');
figure; plot(imag(y)); grid; xlabel('k'); title('Imaginaerteil');
% ##### Teilaufgabe e: Uebertragungsfunktionen von LTI Systemen #####
% ### 2:
b = [1 0.5];
a = [1 -(1.8*cos(pi/16)) 0.81];
[H w] = freqz(b,a,128);
figure; semilogy(w/pi,abs(H)); grid; xlabel('Omega/pi');
ylabel('| H(exp(j*Omega)) |');
figure; plot(w/pi,angle(H)); grid; xlabel('Omega/pi');
ylabel('b(Omega)');
% ### 3:
b = [1 0.5];
a = [1 -(1.8*cos(pi/16)) 0.81];
[H w] = freqz(b,a,128,'whole');
figure; semilogy(w/pi,abs(H)); grid; xlabel('Omega/pi');
ylabel('| H(exp(j*Omega)) |');
figure; plot(w/pi,angle(H)); grid; xlabel('Omega/pi');
ylabel('b(Omega)');
% ##### Teilaufgabe f: Pol-Nullstellen-Berechnung #####
b = [1 0.5];
a = [1 -(1.8*cos(pi/16)) 0.81];
Nullstellen = roots(b);
Polstellen = roots(a);
% ##### Teilaufgabe h: Pol-Nullstellen-Diagramm #####
b = [1 0.5];
a = [1 -(1.8*cos(pi/16)) 0.81];
figure; zplane(b,a);title('Pol-Nullstellen-Diagramm');
xlabel('Realteil'); ylabel('Imaginaerteil');
% ##### EOF #####
common/l7.m
Executable
+65
View File
@@ -0,0 +1,65 @@
% ##################################################################################
% ## Loesung: Fourier-Transformation zeitdiskreter Signale ##
% ## -------------------------------------------------------------------------- ##
% ## Benoetigte(s) m-File(s): ldtft.m ##
% ##################################################################################
% ##### Teilaufgabe a: Betrag und Phase #####
a = 0.88 * exp( j * 2*pi/5 );
k = 0:40;
s = a.^k;
[S W] = ldtft(s, 128);
figure; plot(W/pi, abs(S) ); grid; title('Betrag'); xlabel('Omega/pi');
figure; plot(W/pi, angle(S) ); grid; title('Phase'); xlabel('Omega/pi');
ylabel('Radian');
% ##### Teilaufgabe b: Rechteckimpulsfolge #####
% ### 1:
r =[ones(12,1); zeros(12,1)]';
k=0:23;
figure; stem(k,r); grid; xlabel('k'); ylabel('Amplitude');
title('Rechteckimpulsfolge');
% ### 3:
r =[ones(12,1); zeros(12,1)]';
[R,W]=ldtft(r,256);
figure; plot(W/pi, abs(R) ); grid; title('Betrag'); xlabel('Omega/pi');
figure; plot(W/pi, angle(R) ); grid; title('Phase'); xlabel('Omega/pi');
ylabel('Radian');
% ##### Teilaufgabe c: Dreieckimpulsfolge #####
r =[ones(12,1); zeros(12,1)]';
d = conv(r,r);
[D,W]=ldtft(d,256);
figure; plot(W/pi, abs(D) ); grid; title('Betrag'); xlabel('Omega/pi');
figure; plot(W/pi, angle(D) ); grid; title('Phase'); xlabel('Omega/pi');
ylabel('Radian');
% ##### Teilaufgabe d: Komplexe Modulation #####
r =[ones(12,1); zeros(12,1)]';
k = 0:23;
W0 = 2*pi/4;
M = exp( sqrt(-1)*W0*k );
r = r.*M;
[R,W]=ldtft(r,256);
figure; plot(W/pi, abs(R) ); grid; title('Betrag'); xlabel('Omega/pi');
figure; plot(W/pi, angle(R) ); grid; title('Phase'); xlabel('Omega/pi');
ylabel('Radian');
% ##### Teilaufgabe e: Reelle Modulation #####
r =[ones(12,1); zeros(12,1)]';
k = 0:23;
W0 = 2*pi/4;
M = exp( sqrt(-1)*W0*k );
r = r.* real(M);
[R,W]=ldtft(r,256);
figure; plot(W/pi, abs(R) ); grid; title('Betrag'); xlabel('Omega/pi');
figure; plot(W/pi, angle(R) ); grid; title('Phase'); xlabel('Omega/pi');
ylabel('Radian');
% ##### EOF #####
common/l8.m
Executable
+11
View File
@@ -0,0 +1,11 @@
% ##################################################################################
% ## Loesung: Abtastung ##
% ## -------------------------------------------------------------------------- ##
% ## Benoetigte(s) m-File(s): lcsin.m ##
% ##################################################################################
[y,t]= lcsin(50, 1200, pi/4, 0, 7e-3, 8000); %Zeitdiskretes Sinussignal
figure; stem(t,y);grid;xlabel('Zeit [sek]');ylabel('Amplitude');title('s_k(kT_A)');
figure; stem(y); grid;xlabel('k'); ylabel('Amplitude');title('s(k)');
% ##### EOF #####
common/l9.m
Executable
+84
View File
@@ -0,0 +1,84 @@
% ##################################################################################
% ## Loesung: Abtastung und Rekonstruktion ##
% ## -------------------------------------------------------------------------- ##
% ## Benoetigte(s) m-File(s): lzerofill.m, lafplot.m, ldtft.m ##
% ##################################################################################
% ##### Teilaufgabe a: Analoges Signal #####
fsim = 80000;
delta_t = (0:1/fsim:0.02)';
f0 = 2000;
s = cos(2*pi*f0*delta_t);
figure; plot(delta_t,s); xlabel('Zeit (sek)'); ylabel('Amplitude');
title('Analoges Signal');
% ##### Teilaufgabe b: Spektrum des analogen Signals #####
fsim = 80000;
delta_t = (0:1/fsim:0.02)';
f0 = 2000;
s = cos(2*pi*f0*delta_t);
figure; lafplot(s,1/80000);
% ##### Teilaufgabe c: Abtastung #####
fsim = 80000;
delta_t = (0:1/fsim:0.02)';
f0 = 2000;
s = cos(2*pi*f0*delta_t);
fa = 8000;
l = fsim/fa;
index = (1:l:length(s))-1;
index(1) = [];
sd = s(index);
figure; stem(sd(1:50)); grid; xlabel('k'); ylabel('Amplitude');
title('Diskretes Signal');
% ##### Teilaufgabe d: Spektrum des zeitdisk. Signals #####
fsim = 80000;
delta_t = (0:1/fsim:0.02)';
f0 = 2000;
s = cos(2*pi*f0*delta_t);
fa = 8000;
l = fsim/fa;
index = (1:l:length(s))-1;
index(1) = [];
sd = s(index);
[H,W] = ldtft(sd,512);
figure; plot(W/pi,abs(H)); grid; xlabel('Omega/pi'); ylabel('Amplitude');
title('Zeitdiskrete Fourier-Transformation (Betrag)');
% ##### Teilaufgabe e: Rekonstruktions-TP #####
fa = 8000;
fsim = 80000;
fcut = fa/fsim;
[b,a] =cheby2(9,60,fcut);
[H,W]=freqz(b,a,128,fsim);
figure; semilogy(W,abs(H)); grid; xlabel('Frequenz in Hz'); ylabel('Betrag');
title('Rekonstruktions-Tschebyscheff-TP');
figure; plot(W,angle(H)); grid; xlabel('Frequenz in Hz'); ylabel('Phase');
title('Rekonstruktions-Tschebyscheff-TP');
% ##### Teilaufgabe f: Analoges Signal #####
fsim = 80000; % analoges Signal
delta_t = (0:1/fsim:0.02)';
f0 = 2000;
s = cos(2*pi*f0*delta_t);
fa = 8000; % Abtastung
l = fsim/fa;
index = (1:l:length(s))-1;
index(1) = [];
sd = s(index); % diskretes Signal
sa = lzerofill(sd,l); % Rekonstruktion/Einfuegen von Nullen
fsim = 80000; % Tiefpass entwerfen
fcut = fa/fsim; % siehe Loesung
[b,a]=cheby2(9,60,fcut);
sr = filter(b,a,sa); % Rekonstruktion
figure; plot(sr); title('Rekonstruierter Sinus'); xlabel...
('Zeit in Abtastwerten'); ylabel('Amplitude');
figure; lafplot(sr,1/80000); ylabel('Amplitude');
% ##### EOF #####
common/lafplot.m
Executable
+20
View File
@@ -0,0 +1,20 @@
% ##################################################################################
% ## Funktion lafplot.m ##
% ##################################################################################
% AFPLOT Stellt die Fourier-Transformierte eines "ANALOGEN" Signals dar.
% Aufruf: lafplot( xa, dt )
% xa : "ANALOGES" Signal
% dt : Abtastinterval fuer die Simulation von xa(t)
function lafplot( xa, dt )
l = length(xa);
Nfft = round( 2 .^ nextpow2(5*l) );
Xa = fft(xa, Nfft);
range = 0:(Nfft/4);
ff = range/Nfft/dt;
plot( ff/1000, abs( Xa(1+range) ) );
title('Zeitkontinuierliche Fourier-Transformation (Betrag)');
xlabel('Frequenz (kHz)'); grid
% ##### EOF #####
common/lakffft.m
Executable
+24
View File
@@ -0,0 +1,24 @@
% ##################################################################################
% ## Funktion: lakffft AKF-Schaetzung nach IDFT{|DFT{x}|^2} ##
% ##################################################################################
%
% function rxx = lakffft(M,x)
%
% Nicht erwartungstreue AKF-Schaetzung nach IDFT{|DFT{x}|^2}.
% Der Parameter M entspricht dem Maximalwert fuer lambda.
% Der Vektor x mit den Signalwerten darf eine beliebige Dimension
% annehmen und kann als Spalten- oder Zeilenvektor uebergeben werden.
% Die Ausgabe erfolgt als Spaltenvektor der Dimension M sowie nur fuer
% positive lambda-Werte: rxx = [rxx(0), ..., rxx(M-1)].
% Fuer negative lambda ist eine konj. gerade Ergaenzung vorzunehmen.
function rxx = lakffft(M,x)
x = x(:); % Spaltenvektoren erzeugen
N = length(x);
NFFT = pow2(nextpow2(N+M));
X = fft(x,NFFT);
Sxx = abs(X.^2);
rxx = ifft(Sxx)./N;
rxx = rxx(1:M);
% ##### EOF #####
common/lband.m
Executable
+18
View File
@@ -0,0 +1,18 @@
% ##################################################################################
% ## Funktion: lband.m; Erzeugung eines reellen Bandpass-Signals ##
% ##################################################################################
%
% function b = lband(N,fm_norm,b_norm);
%
% N Datenwerte eines reellen Bandpass-Signals mit der normierten
% Mittenfrequenz fm_norm=fm/fa und der normierten Bandbreite
% b_norm=b/fa werden erzeugt.
function b = lband(N,fm_norm,b_norm);
b = zeros(1,N);
for nu = -5:5
b = b + (1+nu/10)*cos(2*pi*(fm_norm + b_norm*nu/10)*(1:N));
end
b = b.'/11;
% ##### EOF #####
common/lblack.m
Executable
+24
View File
@@ -0,0 +1,24 @@
% ##################################################################################
% ## Funktion: lblack.m; Berechnung des Blackman-Tuckey-Leistungsdichtespektrums ##
% ## -------------------------------------------------------------------------- ##
% ## Benoetigte(s) m-File(s): lrader.m ##
% ##################################################################################
%
% function Sxx = lblack(x,M,windowtype[,NFFT]);
%
% Schaetzung der spektralen Leistungsdichte nach Blackman-Tukey (1958)
% x Datenfolge (Zeilen- oder Spaltenvektor)
% M Anzahl der verwendeten Autokorrelationswerte
% (sollte Zweierpotenz sein): rxx(-(M-1)), ..., rxx(M-1)
% windowtype Fensterfunktion (String, z.B. 'hamming'),
% [NFFT] FFT-Laenge (optional)
function Sxx = lblack(x,M,windowtype,NFFT)
rxx = lrader(M,x); % rxx = [rxx(0); ...; rxx(M-1)]
rxx = [flipud(conj(rxx(2:M))); rxx]; % Konj. gerade Ergaenzung
% => Laenge 2M-1
eval(['fenster= ', windowtype,'(2*M-1);']); % Fensterfunktion der Laenge
if nargin<4, NFFT=nextpow2(length(x)); end; % 2M-1 berechnen
Sxx = abs(fft(rxx.*(fenster),NFFT));
% ##### EOF #####
common/lburg.m
Executable
+43
View File
@@ -0,0 +1,43 @@
% ##################################################################################
% ## Funktion: lburg.m; Burg-Algorithmus ##
% ##################################################################################
%
% function [ARcoeff,g] = lburg(N,q,MA,AR[,NFFT,[,N_vor]]);
%
% Spektralschaetzung auf der Grundlage des Burg-Algorithmus'
% Input-Argumente:
% N : Laenge des Datenblockes
% q : Grad des Praediktorfehlerfilters
% AR,MA : Koeffizienten des ARMA-Modellfilters
% [NFFT] : FFT-Laenge
% [N_vor]: Anzahl Abtastwerte fuer eingschw. Zustand
% Output-Argumente:
% ARcoeff: Koeffizienten des Burg-AR-Modells (Zeilenvektor)
% g : PARCOR-Koeffizienten
function [ARcoeff,g] = lburg(N,q,MA,AR,NFFT,N_vor)
if nargin<5, NFFT=2^10; N_vor=0; end;
if nargin<6, N_vor=0; end;
x = randn(1,N+N_vor);
y_all= filter(MA,AR,x);
y = y_all(N_vor+1:length(y_all));
% Initialisierung
e = y; % Vorwaerts-Praediktorfehler
b = y; % Rueckwaerts-Praediktorfehler
% Burg-Algorithmus
for ii = 1:q
g(ii) = 2*e(2:N+1-ii)*b(1:N-ii)'/(e(2:N+1-ii)*e(2:N+1-ii)'+...
b(1:N-ii)*b(1:N-ii)');
e2 = e(2:N+1-ii) - g(ii)*b(1:N-ii);
b = b(1:N-ii)-conj(g(ii))*e(2:N+1-ii);
e = e2;
end;
ARcoeff = [1 -g(1)]; % Levinson-Durbin-Algorithmus
for i = 2:q
ARcoeff = [ARcoeff 0]-fliplr(conj([ARcoeff 0]))*g(i);
end
% ##### EOF #####
common/lcascade.m
Executable
+15
View File
@@ -0,0 +1,15 @@
% ##################################################################################
% ## Funktion [B,A]=lcascade(b,a) ##
% ##################################################################################
% Kaskadierung eines durch seine Uebertragungsfunktion gegebenes System in eine
% Kaskadenstruktur aus Systemen zweiter Ordnung. Die Zeilen von B und A beinhalten
% die Koeffizienten des Nenners bzw. des Zaehlers der zugehoerigen Systeme
% zweiter Orndung.
function [B,A]=lcascade(b,a)
[z,p,k] = tf2zp(b,a);
sos = zp2sos(z,p,k);
B = sos(:,1:3);
A = sos(:,4:6);
% ##### EOF #####
common/lcheby.m
Executable
+41
View File
@@ -0,0 +1,41 @@
% ##################################################################################
% ## Funktion: lcheby.m; Berechnung der kausalen Chebychev-Fensterfunktion ##
% ##################################################################################
%
% function [f_dt,F_dt,a_min_dB] = lcheby(N,Omega_s,delta_Omega)
%
% Berechnung der kausalen Chebychev-Fensterfunktion mittels Ruecktrafo
% aus dem Spektralbereich. Diese Routine liefert im Gegensatz zur
% Matlab-Funktion "chebwin" auch fuer gerade N das richtige Ergebnis.
% Inputs: N : Fensterlaenge im Zeitbereich
% Omega_s : Sperrbereichs-Grenzfrequenz
% delta_Omega: Stuetzstellenabstand im Frequenzbereich
% Outputs: f_dt : Kausale Fensterfunktion (reell)
% F_dt : Spektralfunktion des Fensters (komplex)
% a_min_dB : Erreichte Sperrdaempfung in dB.
% Bsp.: N=34; lcheby(N,0.1*pi,2*pi/N/8)
function [f_dt,F_dt,a_min_dB] = lcheby(N,Omega_s,delta_Omega)
Omega = 0:delta_Omega:2*pi-delta_Omega;
F_dt = [cosh((N-1)*acosh(cos(Omega/2)/cos(Omega_s/2)))];
F_dt = F_dt .*exp(-j*(N-1)*Omega/2); % damit f_dt kausal wird
f_dt = real(ifft(F_dt)); % Imaginaerteile (=1e-14) abschneiden
fn_dt = f_dt/max(f_dt); % reell, max{fn_dt}=1
Fn_dt = F_dt/max(abs(F_dt)); % kompl, max{|Fn_dt|}=1 = 0dB
aFn_dt_dB= 20*log10(abs(Fn_dt));
a_min_dB = 20*log10(cosh((N-1)*acosh(1/cos(Omega_s/2))));
figure; fT = Omega/(2*pi); f_sT = Omega_s/(2*pi); y_axis = [-a_min_dB-35 10];
plot(fT, aFn_dt_dB); hold on; ylabel('|F(exp(j*Om.))/F(exp(j*0))| in dB');
title(sprintf('|Norm. DT-Spektralfunktion|: N=%d, Om_s/2pi=%.2f,dOm/2pi=1/%d',...
N, f_sT, round(2*pi/delta_Omega))); xlabel('Omega/2pi = f T');
textstring = sprintf('a_{min} = %.1f dB', a_min_dB);
text(0.22, -0.8*(a_min_dB-5), textstring); axis([0 1 y_axis]);
plot([f_sT f_sT],y_axis,':');
text(f_sT+0.01,-0.1*(a_min_dB-5),'\Omega_{s}/2\pi=f_{s} T');
figure; bar(0:length(fn_dt)-1, fn_dt); hold on; plot([N-1 N-1],[0 1.1],':');
title('Normierte Koeffizienten des Dolph-Tschebyscheff-Fensters');
ylabel('f(k)'); xlabel('k'); axis([-0.5 2*N-0.5 0 1.1]);
% ##### EOF #####
common/lcoefrnd.m
Executable
+14
View File
@@ -0,0 +1,14 @@
% ##################################################################################
% ## Funktion [aq,nfa]=lcoefrnd(a,w) ##
% ##################################################################################
% Quantisierung eines Koeffizientenvektors A auf eine gewuenschte Wortlaenge W.
function [aq,nfa]=lcoefrnd(a,w)
f = log(max(abs(a)))/log(2); % Normierung von A
n = 2^ceil(f); % durch n (Potenz von 2), so dass,
an = a/n; % 1 >= an >= -1.
aq = lfxquant(an,w); % Quantisierung von a, so dass,
% 1 > aq >= -1;
nfa = n; % Normierungsfaktor
% ##### EOF #####
common/lcsin.m
Executable
+21
View File
@@ -0,0 +1,21 @@
% ##################################################################################
% ## Funktion: lcsin.m; Abtastwerte generieren ##
% ##################################################################################
%
% function [y,t]=lcsin(A,f,phi,t1,t2,Fs)
%
% Generiert Abtastwerte eines zeitkontinuierlichen
% Sinussignals.
% A: Amplitude t1: Startzeit in Sekunden
% f: Frequenz in Hertz t2: Stopzeit in Sekunden
% phi: Initialisierungsphase Fs: Abtatstfrequenz in Hertz
function [y,t]=lcsin(A,f,phi,t1,t2,Fs)
if nargin ~= 6 % Ueberpruefen der Eingabeparameter
error('Falsche Anzahl an Eingabeparameter!')
end
t = (t1:1/Fs:t2)';
y = A*sin(2*pi*f*t+phi);
% ##### EOF #####
common/ldsin.m
Executable
+14
View File
@@ -0,0 +1,14 @@
% ##################################################################################
% ## Funktion [y,k]=ldsin(A,w,phi,k1,k2) ##
% ##################################################################################
% Generiert ein Sinussignal endlicher Laenge mit Amplitude A, Frequenz W, Phase PHI
% und Zeitindex k1<= k <= k2: y = A*sin(W*k+PHI).
function [y,k]=ldsin(A,w,phi,k1,k2)
if nargin ~= 5 % Ueberpruefen der Eingabeparameter
error('Falsche Anzahl an Eingabeparametern!')
end
k = k1:k2;
y = A*sin(w*k+phi);
% ##### EOF #####
common/ldtft.m
Executable
+24
View File
@@ -0,0 +1,24 @@
% ##################################################################################
% ## Funktion [H, W] = ldtft(h, N) ##
% ##################################################################################
% DTFT Berechnet die DTFT an N aequidistanten Frequenzstuetzstellen.
% Aufruf: [H, W] = ldtft(h, N)
% h : Eingabevektor der Laenge L
% N : Anzahl der Frequenzen im Intervall [-pi,pi); (N >= L)
% H : DTFT Werte (komplexwertig)
% W : Vektor der Stuetzstellen, an denen die DTFT berechnet wurde
function [H, W] = ldtft(h, N)
N = fix(N);
L = length(h);
h = h(:); % nur Vektoren
if( N < L )
error('DTFT: Anzahl Datenwerte muss kleiner sein als Anzahl Stuetzstellen')
end;
W = (2*pi/N) * [ 0:(N-1) ]';
mid = ceil(N/2) + 1;
W(mid:N) = W(mid:N) - 2*pi; % <--- Verschiebung [pi,2pi) to [-pi,0)
W = fftshift(W);
H = fftshift( fft( h, N ) ); % <--- Verschiebung der negativen Frequenzen
% ##### EOF #####
common/lfft.m
Executable
+32
View File
@@ -0,0 +1,32 @@
% ##################################################################################
% ## Funktion: lfft.m; Fouriertransformation einer reellen Folge ##
% ##################################################################################
%
% function X1 = lfft(x1)
%
% Transformation einer reellen Folge x1(k) der Laenge 2N durch eine
% N-Punkte FFT
% N.B.: x1 muss ein Zeilenvektor sein.
function X1 = lfft(x1)
lx = length(x1);
if rem(lx,2)==1 % Ungerade Anzahl von Datenwerten
disp('WARNING: Eine gerade Anzahl von Datenwerten ist notwendig:')
disp(' das letzte Datum wird nicht verwendet.')
x1(lx) = [];
lx = lx-1;
end
N = lx/2; % Laenge von reellem x1: 2N
kk = 1:N;
y = x1(2*kk-1); % Gl. (6.1.7a)
z = x1(2*kk); % Gl. (6.1.7b)
x = y + j*z; % Gl. (6.1.8)
% Laenge von komplexem x: N
X = fft(x); % Laenge von X: N
X = [X X(1)]; % Laenge von X: N+1
Y = (X + conj(fliplr(X)))/2; % Gl. (6.1.5a)
Z = (X - conj(fliplr(X)))/2/j; % Gl. (6.1.5b)
X1 = Y + exp(-j*pi*(0:N)/N).*Z; % Gl. (6.1.12)
X1 = [X1 fliplr(conj(X1(2:N)))]; % Laenge von X1: 2N
% ##### EOF #####
common/lfxquant.m
Executable
+22
View File
@@ -0,0 +1,22 @@
% ##################################################################################
% ## Funktion X=lfxquant(s,bit) ##
% ##################################################################################
% Funktion quantisiert das Signal S auf eine Wortlaenge von BIT bits auf das
% Intervall [-1,1). Dabei wird auf den naechst hoeheren Wert innerhalb des
% Intervalls (Saettigung) aufgerundet.
function X=lfxquant(s,bit)
if nargin ~= 2;
error('Aufruf: lfxquant( S, BIT ).');
end;
if bit <= 0 | abs(rem(bit,1)) > eps;
error('Wortlaenge muss ein positiver Integer sein');
end;
Plus1 = 2^(bit-1);
X = s * Plus1;
X = round(X);
X = min(Plus1 - 1,X); % Saettigung
X = max(-Plus1,X);
X = X / Plus1;
% ##### EOF #####
common/lge.m
Executable
+18
View File
@@ -0,0 +1,18 @@
%-------------------------------------------------------------------
%
% [l]=lge(x);
%
% alias fuer length(x): l=max(size(x));
%
%-------------------------------------------------------------------
%
% author: Markus Hofbauer,
% ISI, ETH Zuerich (Switzerland)
%
% created: 7/2000
%
%-------------------------------------------------------------------
function [l]=lge(x);
l=max(size(x));
common/lgenexp.m
Executable
+26
View File
@@ -0,0 +1,26 @@
% ##################################################################################
% ## Funktion: lgenexp.m; Exponentialfolge ##
% ##################################################################################
%
% function [y,k]=lgenexp(a,k0,l)
%
% Generiert eine Exponentialfolge b^k
% a: Eingabeskalar
% k0: Startindex
% l: Laenge der Exponentialfolge
function [y,k]=lgenexp(a,k0,l)
if nargin ~= 3
error('Aufruf ist: Y = GENEXP( B, K0, L)');
end;
if l<=0
error('Signallaenge muss positiv sein');
end;
if abs(a)>1
error('|a| muss kleiner Eins sein');
end;
k = k0 + [1:l]' - 1;
y = a .^ k;
% ##### EOF #####
common/lms.m
Executable
+48
View File
@@ -0,0 +1,48 @@
% LMS-Algorithmus
% ---------------
% function [ys,e,wf,fpo] = lms(x,d,N,mu,wi)
%
% Parameter:
% x : Eingangssignal
% d : erwünschtes Signal (Referenzsignal)
% N : Filterordnung
% mu : konstante Schrittweite
% wi : Startwerte der Filterkoeffizienten im Zeitbereich
%
% Rückgabewerte:
% ys : Schätzung des erwünschten Signals d aus x
% e : Fehler d - y
% wf : Filterkoeffizienten am Ende der Adaption im Zeitbereich
% fpo : Anzahl benötigten der Floating-Point Operationen
% -------------------------------------------------------------------------
% Datum : 20.7.2001
% Autor : Jens Ahrensfeld
% Thema : Diplomarbeit
% Datei : lms.m
% Benötigte Dateien: keine
%
% -------------------------------------------------------------------------
function [ys,e,wf,fpo] = lms(x,d,N,mu,wi)
% -------------------------------------------------------------------------
% Initialisierung LMS
% -------------------------------------------------------------------------
wf = wi;
y = zeros(length(x),1);
e = zeros(length(x),1);
flops(0);
% -------------------------------------------------------------------------
% LMS Adaptation
% -------------------------------------------------------------------------
for n = N : length(x)
xs = x(n:-1:n-N+1);
ys(n) = xs'*wf;
e(n) = d(n) - ys(n);
wf = wf + mu*e(n)*xs;
end ;
fpo = flops;
% -------------------------------------------------------------------------
% Ende lms.m
common/lms1.m
Executable
+53
View File
@@ -0,0 +1,53 @@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% LMS Algorithm %
% %
% Written By: Sundar Sankaran and A. A. (Louis) Beex %
% DSP Research Laboratory %
% Dept. of Electrical and Comp. Engg %
% Virginia Tech %
% Blacksburg VA 24061-0111 %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
randn('seed', 0) ;
rand('seed', 0) ;
NoOfData = 8000 ; % Set no of data points used for training
Order = 32 ; % Set the adaptive filter order
Mu = 0.01 ; % Set the step-size constant
x = randn(NoOfData, 1) ;% Input assumed to be white
h = rand(Order, 1) ; % System picked randomly
d = filter(h, 1, x) ; % Generate output (desired signal)
% Initialize LMS
w = zeros(Order,1) ;
% LMS Adaptation
for n = Order : NoOfData
D = x(n:-1:n-Order+1) ;
d_hat(n) = w'*D ;
e(n) = d(n) - d_hat(n) ;
w = w + Mu*e(n)*D ;
w_err(n) = norm(h - w) ;
end ;
% Plot results
figure ;
plot(20*log10(abs(e))) ;
title('Learning Curve') ;
xlabel('Iteration Number') ;
ylabel('Output Estimation Error in dB') ;
figure ;
semilogy(w_err) ;
title('Weight Estimation Error') ;
xlabel('Iteration Number') ;
ylabel('Weight Error in dB') ;
common/lms2.m
Executable
+67
View File
@@ -0,0 +1,67 @@
%===================================================================
%-------------------------------------------------------------------
%
% Adaptive Filter
%
% Simulationen
%
% [E,W,w,DD]=lms(mu, N, X, D, w_start)
%
% LMS-Algorithmus
%
% E = Fehlersignal E[.]
% W = Filterkoeffizienten im zeitlichen Verlauf
% w = Filterkoeffizienten am Ende der Adaption
% DD = Filterausgang, Schaetzung von D
% mu = Schrittweite
% N = Anz. Filterkoeffizienten = Filterordnung+1
% X = Filtereingang X[.]
% D = erwuenschtes Signal D[.]
% w_start = Startwerte Filterkoeffizienten
%
%-------------------------------------------------------------------
%
% author: Peter Wellig, Martin Haenggi, Markus Hofbauer
% ISI, ETH Zuerich (Switzerland)
%
% created: 7/2000
%
%
%-------------------------------------------------------------------
%
% File : lms.m
%
% Startfile: simX.m
%
%-------------------------------------------------------------------
%===================================================================
function [E,W,w,DD]=lms2(mu, N, X, D, w_start)
% Initialisierungen
adaptlen=length(X);
w = w_start;
W=zeros(N,adaptlen);
DD=zeros(adaptlen,1);
E=zeros(adaptlen,1);
% Loop
flops(0);
for i=N:adaptlen
W(:,i) = w;
x = X(i:-1:i-N+1); % Eingangsvektor (x[k],x[k-1],..,x[k-N+1])
y = x'*w; % Filterausgang
e = D(i)-y; % Fehler
w = w+mu*e*x; % Aufdatierung der Filterkoeffizienten
E(i) = e;
DD(i) = y;
end;
flops
common/lper.m
Executable
+17
View File
@@ -0,0 +1,17 @@
% ##################################################################################
% ## Funktion: lper.m; Berechnung des Periodogramms ##
% ##################################################################################
%
% function Sxx = lper(x[,NFFT])
%
% Schaetzung der spektralen Leistungsdichte mittels Periodogramm
% x Datenfolge (Zeilen- oder Spaltenvektor)
% [NFFT] FFT-Laenge (optional)
function Sxx = lper(x,NFFT)
N = length(x);
if nargin<2, NFFT=pow2(nextpow2(N)); end;
X = fft(x,NFFT);
Sxx = (abs(X).^2)./N;
% ##### EOF #####
common/lrader.m
Executable
+44
View File
@@ -0,0 +1,44 @@
% ##################################################################################
% ## Funktion: lrader.m ; AKF-Schaetzung mit Raderverfahren ##
% ##################################################################################
%
% function rxx = lrader(M,x)
%
% Nicht erwartungstreue AKF-Schaetzung nach dem Rader-Verfahren laut
% Kammeyer/Kroschel "Digitale Signalverarbeitung", S. 240-247.
% Der Parameter M muss eine Zweierpotenz sein und entspricht dem
% (Maximalwert+1) fuer lambda. Der Vektor x mit den Signalwerten
% darf eine beliebige Dimension annehmen und kann als Spalten- oder
% Zeilenvektor uebergeben werden. Die Ausgabe erfolgt als Spalten-
% vektor der Dimension M sowie nur fuer positive lambda-Werte:
% rxx = [rxx(0), ..., rxx(M-1)].
% Fuer negative lambda ist eine konj. gerade Ergaenzung vorzunehmen.
function rxx = lrader(M,x)
x = x(:); % Spaltenvektoren erzeugen
N = length(x);
u = zeros(2*M,1);
u(1:M) = x(1:M);
U = fft(u);
K = floor(N/M);
v = zeros(2*M,1);
Sxx = zeros(2*M,1);
pm = (-1).^(0:(2*M-1)).';
for ii = 1:(K-1) % Iteration und Akkumulation
v(1:M) = x((ii*M+1):((ii+1)*M));
V = fft(v);
Sxx = Sxx + (conj(U) .*(U + (pm .*V)));
U = V;
end;
if K < N/M
b = N - K*M;
v = zeros(2*M,1);
v(1:b) = x((K*M+1):N);
V = fft(v);
Sxx = Sxx + (conj(U) .*(U + (pm .*V)));
end;
Sxx = Sxx + abs(V.^2);
rxx = ifft(Sxx)/N;
rxx = rxx(1:M);
% ##### EOF #####
common/lrader2.m
Executable
+50
View File
@@ -0,0 +1,50 @@
% ##################################################################################
% ## Funktion: lrader.m ; AKF-Schaetzung mit Raderverfahren ##
% ##################################################################################
%
% function rxx = lrader(M,x)
%
% Nicht erwartungstreue AKF-Schaetzung nach dem Rader-Verfahren laut
% Kammeyer/Kroschel "Digitale Signalverarbeitung", S. 240-247.
% Der Parameter M muss eine Zweierpotenz sein und entspricht dem
% (Maximalwert+1) fuer lambda. Der Vektor x mit den Signalwerten
% darf eine beliebige Dimension annehmen und kann als Spalten- oder
% Zeilenvektor uebergeben werden. Die Ausgabe erfolgt als Spalten-
% vektor der Dimension M sowie nur fuer positive lambda-Werte:
% rxx = [rxx(0), ..., rxx(M-1)].
% Fuer negative lambda ist eine konj. gerade Ergaenzung vorzunehmen.
function rxx = lrader2(M,x,y)
x = x(:); % Spaltenvektoren erzeugen
y = y(:); % Spaltenvektoren erzeugen
N = length(x);
u = zeros(2*M,1);
u(1:M) = x(1:M);
U = fft(u);
w = zeros(2*M,1);
w(1:M) = y(1:M);
W = fft(w);
K = floor(N/M);
v = zeros(2*M,1);
Sxx = zeros(2*M,1);
pm = (-1).^(0:(2*M-1)).';
for ii = 1:(K-1) % Iteration und Akkumulation
v(1:M) = y((ii*M+1):((ii+1)*M));
V = fft(v);
Sxx = Sxx + (conj(U) .*(W + (pm .*V)));
W = V;
u(1:M) = x((ii*M+1):((ii+1)*M));
U = fft(u);
end;
if K < N/M
b = N - K*M;
v = zeros(2*M,1);
v(1:b) = y((K*M+1):N);
V = fft(v);
Sxx = Sxx + (conj(U) .*(W + (pm .*V)));
end;
Sxx = Sxx + 0*abs(V.^2);
rxx = ifft(Sxx)/N;
rxx = rxx(1:M);
% ##### EOF #####
common/lsum.m
Executable
+26
View File
@@ -0,0 +1,26 @@
% ##################################################################################
% ## Funktion: lsum.m; AKF-Schaetzung mit Summenformel ##
% ##################################################################################
%
% function rxx = lsum(M,x)
%
% Nicht erwartungstreue AKF-Schaetzung durch Vektormultiplikation
% Der Parameter M entspricht dem (Maximalwert-1) fuer lambda.
% Der Vektor x mit den Signalwerten darf eine beliebige Dimension
% annehmen und kann als Spalten- oder Zeilenvektor uebergeben werden.
% Die Ausgabe erfolgt als Spaltenvektor der Dimension M sowie nur fuer
% positive lambda-Werte: rxx = [rxx(0), ..., rxx(M-1)].
% Fuer negative lambda ist eine konj. gerade Ergaenzung vorzunehmen.
function rxx = lsum(M,x)
x = x(:); % Spaltenvektoren erzeugen
N = length(x);
r0 = x'*x;
r = zeros(M-1,1);
for ii = 1:M-1
r(ii) = [zeros(1,ii) x'] * [x; zeros(ii,1)];
end
rxx=[r0; r]./N; % Nicht erwartungstreue AKF-Schaetzung
% rxx=[r0; r]./(N:-1:N-(M-1)); % Erwartungstreue AKF-Schaetzung
% ##### EOF #####
common/lwelch.m
Executable
+45
View File
@@ -0,0 +1,45 @@
% ##################################################################################
% ## Funktion: lwelch.m; Welch- bzw. Bartlettverfahren ##
% ##################################################################################
%
% function Sxx = lwelch(x,K,windowtype[,NFFT[,overlap]])
%
% Schaetzung der spektralen Leistungsdichte nach dem Welch-Ansatz
% x Datenfolge (Zeilenvektor)
% K Anzahl der zu mittelnden Periodogramme = #Teilfolgen
% windowtype Fensterfunktion (z.B. 'hamming'=> Welch-Verfahren,
% 'boxcar' => Bartlett-Verfahren).
% [NFFT] FFT-Laenge (optional)
% [overlap] zusaetzliche Mittelung mit den Periodogrammen der
% um fix(L/2) verschobenen Teilfolgen (falls das
% optionale Argument vorhanden ist)
% Beispiel: Sxx = lwelch(x,4,'boxcar',1024);
function Sxx = lwelch(x,K,windowtype,NFFT,overlap)
L = floor(length(x)/K);
if nargin<4, NFFT=nextpow2(L); end;
% Fensterfunktion der Laenge
eval(['fenster =',windowtype,'(L);']); % L berechnen (Spaltenvektor)
AL = fenster.'*fenster; % Normierungskonstante
Sxx = zeros(1,NFFT);
kk = (1:L);
for i = 0:K-1 % Addition der Periodogramme
yi = fenster.' .* x(kk+i*L); % der nicht-ueberlappenden
Yi = fft(yi,NFFT); % Teilfolgen von x
Sxx = Sxx + abs(Yi).^2;
end
if nargin > 4 % zusaetzliche Addition der
kk = (1:L) + fix(L/2); % Periodogramme der ueber-
for i = 0:K-2 % lappenden Teilfolgen von x
yi = fenster' .* x(kk+i*L);
Yi = fft(yi,NFFT);
Sxx = Sxx + abs(Yi).^2;
end
Sxx = Sxx/AL/(2*K-1); % Normierung auf AL und
else % Anzahl der Mittelungen (=2K-1)
Sxx = Sxx/AL/K; % Normierung auf AL und
end % Anzahl der Mittelungen (=K)
% ##### EOF #####
common/lywex.m
Executable
+42
View File
@@ -0,0 +1,42 @@
% ##################################################################################
% ## Funktion: lywex.m; AR-(p)-Approximation eines ARMA-Modelles nach Yule-Walker
% ##################################################################################
%
% function [ARcoeff] = lywex(MA,AR,p[,NFFT])
%
% Berechnung der Koeffizienten eines AR-Modelles aus den exakten
% Autokorrelationskoeffizienten
% Input-Argumente:
% MA,AR : Parameter des ARMA-Modells
% p : Grad des zu bestimmenden AR-Modells
% [NFFT] : FFT-Laenge
% Output-Argument:
% ARcoeff : Koeffizienten des Yule-Walker-AR-Modells (Zeilenvektor)
% Sxx_ar : geschaetztes AR-Betragspektrum
% Sxx_arma : wahres LDS des ARMA-Modells
function [Sxx_ar, Sxx_arma, ARcoeff] = lywex(MA,AR,p,NFFT)
if nargin<4, NFFT = 2^10; end;
delta = [1 zeros(1,NFFT-1)];
h_arma = filter(MA,AR,delta);
H_arma = fft(h_arma);
Sxx_arma = abs(H_arma).^2; % LDS des ARMA-Modells
% Wahre AKF des ARMA-Modells:
r0_arma = h_arma*h_arma'; % rxx(0)
for ii = 1:p % rxx(1)..rxx(p)
r_arma(ii) = [zeros(1,ii) h_arma]*[h_arma zeros(1,ii)]';
end
R_arma = toeplitz([r0_arma r_arma(1:length(r_arma)-1)]);
ARcoeff = -inv(R_arma)*r_arma';
ARcoeff = [1 ARcoeff.'];
h_ar = filter(1, ARcoeff, delta);
H_ar = fft(h_ar);
if p == 0
sigmak2 = 1;
else
sigmak2 = R_arma(1,1)-r_arma*inv(R_arma)*r_arma';
end
Sxx_ar = sigmak2 * abs(H_ar).^2; %geschaetztes AR-Betragspektrum
% ##### EOF #####
common/lzerofill.m
Executable
+24
View File
@@ -0,0 +1,24 @@
% ##################################################################################
% ## Funktion: lzerofill.m; Sequenz mit Nullen fuellen ##
% ##################################################################################
%
% function y = lzerofill(x,l)
%
% Die Funktion fuellt eine Sequenz X mit l-1 Nullen zwischen jedem Wert von X auf.
% x : Eingangssignalvektor
% l : l-1 Nullen zwischen jedem Abtastwert
% y : Ausgangssignalvektor ==> Laenge(y) = l*Laenge(x)
% NOTE: Falls X eine Matrix ist, wird zerofill auf
% jede Spalte angewendet.
function y = lzerofill(x,l)
[M,N] = size(x);
if M==1 % <--- fuer Vektoren
y = zeros(1, N*l);
y(1,1:l:N*l) = x;
else % <--- Fuer Matrizen
y = zeros(M*l, N);
y(1:l:M*l,:) = x;
end
% ##### EOF #####
common/lzp1.m
Executable
+10
View File
@@ -0,0 +1,10 @@
% ##################################################################################
% ## Funktion v = zp1(M,N) ##
% ##################################################################################
% Die Funktion erzeugt eine M*N-Matrix mit Zufallswerten
function v = zp1(M,N)
Mc = ones(M,1)*cos((1:N)/2);
v = (rand(M,N)-0.5) .* Mc;
% ##### EOF #####
common/mx.m
Executable
+36
View File
@@ -0,0 +1,36 @@
% Magnitude Estimation von x
% Schätzung des mittleren Betrages von x
% mit kombinierter Anstiegs- und Abfallzeit trf
% ---------------------------------------------
%
% Aufruf:
% function [mx,mxf] = mx(x,trf,mxi)
%
% Parameter:
% x : Eingangsvektor
% trf : Zeitkonstante Anstiegs- und Abfallzeit
% mxi : Initial Condition Anfangsbetrag von x
%
% Rückgabewerte:
% mx : Ausgang mittlerer Betrag von x
% mxf : Endbetrag von x
% -------------------------------------------------------------------------
% Datum : 26.07.2001
% Autor : Jens Ahrensfeld
% Thema : Diplomarbeit
% Datei : mx.m
% Benötigte Dateien: filter, lge, abs
%
% -------------------------------------------------------------------------
function [mx,mxf] = mx(x,trf,mxi)
N = lge(x);
x(1) = x(1) + mxi*(1/trf-1);
%x = abs(x);
a = [1,-(1-trf)];
mx = filter(trf,a,x);
mxf = mx(N);
% -------------------------------------------------------------------------
% Ende mx.m
common/mx2.m
Executable
+42
View File
@@ -0,0 +1,42 @@
% Magnitude Estimation von x
% Schätzung des mittleren Betrages von x
% mit getrennter Anstiegs- und Abfallzeit tr, tf
% ----------------------------------------------
%
% Aufruf:
% function [mx,mxf] = mx2(x,tr,tf,mxi)
%
% Parameter:
% x : Eingangsvektor
% tr : Zeitkonstante Anstiegszeit
% tf : Zeitkonstante Abfallzeit
% mxi : Initial Condition Anfangsbetrag von x
%
% Rückgabewerte:
% mx : Ausgang mittlerer Betrag von x
% mxf : Endbetrag von x
% -------------------------------------------------------------------------
% Datum : 27.03.2002
% Autor : Jens Ahrensfeld
% Thema : Diplomarbeit
% Datei : mx2.m
%
% -------------------------------------------------------------------------
function [mx,mxf] = mx2(x,tr,tf,mxi)
N = lge(x);
x = abs(x);
mx(1) = mxi;
for n = 2:N,
if(x(n) > mx(n-1))
mx(n) = tr*x(n) + (1-tr)*mx(n-1);
else
mx(n) = tf*x(n) + (1-tf)*mx(n-1);
end;
end;
mxf = mx(N);
% -------------------------------------------------------------------------
% Ende mx2.m
common/newfunc.m
Executable
+18
View File
@@ -0,0 +1,18 @@
% Neue Function
% ------------------------------------
%
% Aufruf:
% Function []=NeueFunktion()
%
% Parameter:
%
% Rückgabewerte:
% -------------------------------------------------------------------------
% Datum : ..2001
% Autor : Jens Ahrensfeld
% Thema : Diplomarbeit
% Datei : newfunc.m
% Benötigte Dateien:
%
% -------------------------------------------------------------------------
common/nlms.m
Executable
+48
View File
@@ -0,0 +1,48 @@
% NLMS-Algorithmus
% ---------------
% function [ys,e,wf,fpo] = nlms(x,d,N,mu,wi)
%
% Parameter:
% x : Eingangssignal
% d : erwünschtes Signal (Referenzsignal)
% N : Filterordnung
% mu : konstante Schrittweite
% wi : Startwerte der Filterkoeffizienten im Zeitbereich
%
% Rückgabewerte:
% ys : Schätzung des Referenzsignals d aus x
% e : Fehler d - ys
% wf : Filterkoeffizienten am Ende der Adaption im Zeitbereich
% fpo : Anzahl der benötigten Floating-Point Operationen
% -------------------------------------------------------------------------
% Datum : 20.7.2001
% Autor : Jens Ahrensfeld
% Thema : Diplomarbeit
% Datei : nlms.m
% Benötigte Dateien: keine
%
% -------------------------------------------------------------------------
function [ys,e,wf,fpo] = nlms(x,d,N,mu,wi)
% -------------------------------------------------------------------------
% Initialisierung NLMS
% -------------------------------------------------------------------------
wf = wi;
ys = zeros(length(x),1);
e = zeros(length(x),1);
flops(0);
% -------------------------------------------------------------------------
% NLMS Adaptation
% -------------------------------------------------------------------------
for n = N : length(x)
xs = x(n:-1:n-N+1);
ys(n) = xs'*wf;
e(n) = d(n) - ys(n);
wf = wf + mu*e(n)*xs/(xs'*xs+0.001);
end ;
fpo = flops;
% -------------------------------------------------------------------------
% Ende nlms.m

Some files were not shown because too many files have changed in this diff Show More