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

- refactored

Browse Source
This commit is contained in:
jens
2022-06-30 13:32:40 +02:00
parent 77cd5261b1
commit 776932e5d1
144 changed files with 0 additions and 38 deletions
Download Patch File Download Diff File Expand all files Collapse all files
common/buch/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/buch/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/buch/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/buch/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/buch/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/buch/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/buch/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/buch/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/buch/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/buch/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/buch/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/buch/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/buch/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/buch/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/buch/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/buch/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/buch/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/buch/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/buch/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/buch/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/buch/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/buch/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/buch/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/buch/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/buch/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/buch/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/buch/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/buch/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/buch/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/buch/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/buch/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/buch/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/buch/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/buch/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/buch/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/buch/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/buch/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/buch/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/buch/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/buch/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/buch/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/buch/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/buch/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/buch/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/buch/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/buch/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/buch/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/buch/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/buch/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/buch/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/buch/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/buch/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/buch/ltrack.m
Executable
+50
View File
@@ -0,0 +1,50 @@
## Copyright (C) 2017 Jens Ahrensfeld
##
## This program is free software; you can redistribute it and/or modify it
## under the terms of the GNU General Public License as published by
## the Free Software Foundation; either version 3 of the License, or
## (at your option) any later version.
##
## This program is distributed in the hope that it will be useful,
## but WITHOUT ANY WARRANTY; without even the implied warranty of
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
## GNU General Public License for more details.
##
## You should have received a copy of the GNU General Public License
## along with this program. If not, see <http://www.gnu.org/licenses/>.
## -*- texinfo -*-
## @deftypefn {Function File} {@var{retval} =} ltrack (@var{input1}, @var{input2})
##
## @seealso{}
## @end deftypefn
## Author: Jens Ahrensfeld <ahrensfeld@w2ess001vm>
## Created: 2017-05-29
function ltrack (d)
N = 101
phi = (-(N-1)/2:((N-1)/2))/(N-1)*pi/2;
k=1;
for k=1:length(d)
err(:,k) = tan(phi)*d(k);
end
close all;
plot(phi, err); grid; xlabel('error(phi)')
err = (-(N-1)/2:((N-1)/2))/(N-1);
phi = [];
k=1;
for k=1:length(d)
phi(:,k) = atan(err/d(k));
end
figure;
plot(err, 180*phi/pi); grid; xlabel('phi(err)')
endfunction
common/buch/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/buch/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/buch/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/buch/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 #####