ZAJÊCIA

ZAJĘCIA

WPROWADZENIE DO INFORMATYKI II

MATLA

FUNKCJE GRAFICZNE 2D

I ELEMENTY PROGRAMOWANIA

PLAN ZAJEĆ:

• WSTĘP

• GRAFIKA DWUWYMIAROWA-ELEMENTARNE

WYKRESY DWUWYMIAROWE

• ZARZĄDZANIE WIELOMA RYSUNKAMI-OKNA GRAFICZNE I OPISY-

WANIE WYKRESÓW

• NAKŁADANIE RYSUNKÓW W JEDNYM UKŁADZIE WSPÓŁRZĘDNYCH
• WYKRESY DANYCH DYSKRETNYCH

WSTĘP

Funkcje graficzne w programie MATLAB dzielą się na:

a. funkcje przeznaczone do prezentacji danych
b. funkcje umożliwiające edycję rysunków
c. funkcja pozwalające rysować różne obiekty

GRAFIKA DWUWYMIAROWA - ELEMENTARNE WYKRESY
DWUWYMIAROWE

Podstawowe instrukcje rysowania wykresu dwuwymiarowego z automatycznym

skalowaniem osi można zapisać następująco:

funkcja(y)

funkcja(x, y)

funkcja(x, y, s)

funkcja(x1, y1, x2, y2,..)

funkcja(x1, y1, s1, x2, y2, s2,..)

gdzie zamiast wyrazu funkcja należy wstawić jedno z poniższych poleceń:
plot

– tworzenie wykresu o obu osiach wyskalowanych liniowo,

loglog

– tworzenie wykresu o obu osiach wyskalowanych logarytmicznie,

semilogx – tworzenie wykresu o skali logarytmicznej w osi x i liniowej w osi y
semilogy – tworzenie wykresu o skali logarytmicznej w osi y i liniowej w osi x
x

– wektor danych na osi odciętych,

– wektor lub macierz danych dla osi rzędnych (jeżeli X jest wektorem wier-
szowym, to liczba kolumn macierzy Y musi być taka sama jak liczba ele-
mentów wektora X lub gdy X jest wektorem kolumnowym, to liczba wier-
szy macierzy Y musi być równa liczbie elementów wektora X),

– łańcuch tekstowy jedno-, dwu- lub trój elementowy umieszczony w apo-
strofach, określający sposób kreślenia krzywych; łańcuch ten zawiera in-
formację o kolorze na ekranie, rodzaju lini i znaczniku na lini, np. ‘b-o’
oznacza linię niebieską, ciągłą z kółkiem w każdym punkcie; poniżej przed-
stawione są odpowiednie symbole.

Symbol Kolor

Symbol Rodzaj lini

y
m
c
r
g
b
w
k

żółty
purpurowy
niebiesko-zielony
czerwony
zielony
niebieski
biały
czarny

.
o
x
+
*
-
:
-.
--

pnktowa
kółkowa
iksowa
plusowa
gwiazdkowa
ciągła
kropkowana
kropkowo-kreskowa
przerywana

Przykład 1. Przykład użycia funkcji plot

x=-pi:0.1:pi;
y=sin(x);
plot(x, y)

Przykład 2. Przykład tworzenia wykresy dwuwymiarowego z dwóch wektorów

X=[1 2 3 4 5];
Y=[2 4 6 7 8 ];
plot(X, Y)

Zadanie 1. Proszę narysować wykres funkcji cosinus i tangens.

Zadanie 2. Należy wykonać wykresy w skali liniowej, logarytmicznej i semilogaryt-
micznej dla dowolnej serii danych (min 10 punktów).

Zadanie 3. Należy wykonać wykresy funkcji sinus i cosinus.

Pytanie 1.
Co oznacza taki opis lini – ‘wo’ ?
fplot

Funkcja fplot – służy do rysowania wykresów zależności funkcyjnych, tzn. rysuje wy-
kres funkcji o nazwie określonej przez parametr f.

fplot(f, granice)
fplot(f, granice, n)
fplot(f, granice, n, kąt)
fplot(f, granice, n, kąt, podprzedziały)
[x, y]=fplot(...)

gdzie:
f

–

łańcuch znaków stanowiący nazwę pliku zawierającego rysowaną funkcję,

granice – dwuelementowy wektor opisujący granice przedziału w jaki m ma być
narysowany wykres,
n – liczba określająca minimalną liczbę punktów, uwzględnianych przy sporzą-
dzaniu wykresu,
kąt – liczba określająca kąt w stopniach między sąsiednimi odcinkami wykresu
powyżej jakiego zwiększana jest liczba punktów próbkowania,
poprzedzały – skalar określający maksymalną liczbę punktów próbkowania, jaka
może zostać dodana w gwałtownie zmieniających się miejscach wykresu.

Przykład 3. Przykład użycia funkcji fplot

Należy utworzyć m – plik fff.m zawierający funkcję:

function y=fff(x)

y=sin(3*pi*atan(x));

A następnie:
[xx, yy]=fplot(‘fff’, [-10 10]);
x=-10:0.5:10; y=fff(x);
subplot(2, 1, 1)
plot(x, y)
title(‘plot’)
subplot(2, 1, 2)
plot(xx, yy)
title(‘fplot’)

Pytanie 2. Jaka jest różnica pomiędzy funkcją plot, a fplot?

linspace
v=linspace(x1, x2, N)
v=linspace(x1, x2)

Funkcja linspace – generuje wierszowy wektor N liczb rozłożonych równomiernie w
przedziale od x1 do x2. Wywołana z dwoma parametrami funkcja wygeneruje 100 liczb.

logspace

v=logspace(d1, d2, N)
v=logspace(d1, d2)

Funkcja linspace – generuje wierszowy wektor N liczb rozłożonych logarytmicznie w
przedziale od 10

do 10

włącznie. Wywołana z dwoma parametrami funkcja wygene-

ruje 50 liczb.

Zadanie 4. Należy wykonać wykres przy pomocy funkcji plot z wykorzystaniem wekto-
rów wygenerowanych przy pomocy funkcji linspace i logspace.

ZARZĄDZANIE WIELOMA RYSUNKAMI - OKNA GRAFICZNE I OPISYWANIE

WYKRESÓW

W oknie graficznym programu MATLAB można umieścić maksymalnie cztery układy

współrzędnych (cztery rysunki) dzieląc okno na dwa wiersze i dwie kolumny.

Podziału okna graficznego dokonuje się przy pomocy funkcji:

subplot

subplot(m, n, p)

subplot(mnp)

gdzie:
m – liczba wykresów które mają się zmieścić w pionie,
n – liczba wykresów które mają się zmieścić w poziomie,

p – numer wykresu, który zostanie narysowany najbliższym wywołaniem funkcji

plot, wykresy są numerowane w wierszach od lewej do prawej, a wiersze od góry
do dołu.

Wykresy można uzupełnić, opisując osie, dodając siatkę współrzędnych, nadając

tytuł względnie umieszczając tekst lub opis krzywych na wykresie. Służą do tego n
pujące polecenia umieszczone za instrukcją rysowania:

astę-

grid

grid
grid on
grid off

Funkcja grid umożliwia naniesienie na wykres pomocniczej siatki współrzędnych.

xlabel

xlabel(tekst)

Funkcja ta wpisuje łańcuch tekstowy pod poziomą osią aktywnego układu w
nych.

spółrzęd-

ylabel

ylabel(tekst)

Funkcja ta wpisuje łańcuch tekstowy obok osi y aktywnego układu współrzędnych.

title

title(tekst)

Funkcja ta umieszcza tytuł nad wykresem.

text

text(x, y, tekst)

Umieszczenie tekstu w miejscu bieżącego wykresu; x, y, wyznaczają punkt początku
tekstu w takich jednostkach, w jakich wyskalowane są osie x i y.

gtext
gtext(tekst)

Umieszczenie łańcucha tekstowego tekst za pomocą myszy komputerowej.

Zadanie 5. Należy wykreślić cztery wykresy w jednym oknie graficznym, a następnie
opisać tytuły i osie.

NAKŁADANIE RYSUNKÓW W JEDNYM UKŁADZIE WSPÓŁRZĘDNYCH

Wykreślenie kilku krzywych w jednym układzie współrzędnych jest możliwe na dwa

sposoby:

• przez umieszczenie danych do rysowania w macierzy,

• przez nakładanie kolejno generowanych wykresów.

plot(x, Y)

Wykreślanie w jednym układzie współrzędnych kolumn lub wierszy macierzy Y w
funkcji argumentów zawartych w wektorze x.

plot(Y)

Wykreślenie krzywych dla danych zawartych w poszczególnych kolumnach Y w funkcji
kolejnych numerów wierszy tej macierzy,
plot(X, Y)

Wykreślenie kolumn macierzy X w funkcji kolumn macierzy Y w jednym układzie
współrzędnych, jeżeli obie macierze mają te same wymiary.

plot(X1, Y1, X2, Y2,...)

Wykreślenie lini dla poszczególnych par X, Y, przy czym wymiary par mogą być w
jemnie różne.

za-

Drugą możliwością jest wykreślenie w jednym układzie współrzędnych krzywych, któ-
rych dane są zawarte w osobnych macierzach lub wektorach. Stosuję się do tego celu
instrukcję hold.

hold

hold

hold on
hold off

Sterowanie nakładaniem kolejno generowanych wykresów przy zatrzymaniu skalowania
osi i miejsca w oknie graficznym.

Zadanie 6. Należy wykreślić wykresy funkcji sinus i cosinus w jednym układzie współ-
rzędnych.

5. WYKRESY DANYCH DYSKRETNYCH

bar(y)

Funkcja bar(y) wykreśla słupki wartości zawartych w wektorze y; rozmieszczenie słup-
ków jest równomierne.

bar(x, y, S)

Funkcja bar(x, y, S) wykreśla słupki wartości wektora y w funkcji wartości wektora x,
które muszą mieć wartości rosnące, równomiernie odległe; S jest łańcuchem tekstowym,
np. dla określenia koloru lini.

[xb, yb]=bar(x, y)

Funkcja [xb, yb]=bar(x, y) zwraca wektory xb i yb w taki sposób, że instrukcją plot(xb,
yb) można wykreślić wykres słupkowy.;

Stem

ZADANIA DO WYKONANIA

Proszę wpisać poniższe przykłady wykresów 2D:

1. Algorytm:

y=sin(t)

clear;
t=0:0.001:1.023;
y=sin(20*t);
plot(t,y);

2. Transformata Fouriera dla y=sin(wt).

clear;
t=0:0.001:1.023;

y=sin(2*pi*10*t);
y_f=fft(y);
a_y=abs(y_f);
plot(a_y);

Widmo transformaty Fouriera - generatory liczb losowych okresowych.

clear;
t=0:0.001:1.023
x(1)=5;
a=52;
m=112;
for i=2:1024;
x(i)=rem(a*x(i-1),m);
end
y_f=fft(x);
df=1000/1024;
a_y=abs(y_f);
f=0:df:1000-df;
yc=a_y/max(a_y);
subplot(2,1,1);
plot(yc);
subplot(2,1,2);
plot(x);

Widmo transformaty Fouriera - generatory liczb losowych nieokresowych.

clear;
t=0:0.001:1.023
x(1)=5;
a=48;
m=886;
for i=2:1024;
x(i)=rem(a*x(i-1),m);
end
y_f=fft(x);
df=1000/1024;
a_y=abs(y_f);
f=0:df:1000-df;
yc=a_y/max(a_y);
subplot(2,1,1);
plot(yc);
subplot(2,1,2);

plot(x);

Algorytmy: A =exp(t); y = A * cos( t );

%sterowanie
fp =

100;

fs1 =

fs2 =

Tmax =

= 0:1/fp:Tmax;

A1 =

10;

A2 =

fi0 =

%algorytmy
A= A1 * exp(-t);
y= A .* cos(2 * pi * fs1 * t + fi0);
%demonstracja
figure(1);
clf;
hold on;
grid on;
plot(t, y, 'g');

Algorytmy: s = rand(size(t)); y = cos( t ); y1 = cos (t ) + s;

%sterowanie
fp =

1000;

fs =

Tmax =

0.5;

= 0:1/fp:Tmax;

A =

fi0 =

%algorytmy
s

= rand(size(t));

= A * cos(2 * pi * fs * t + fi0 );

= A * cos(2 * pi * fs * t + fi0 ) + s;

%demonstracja
figure(1);
clf;
hold on;
grid on;
plot(t, y, 'g', t, y1, 'r');

Algorytmy: Amod = exp(-t); y = Amod * sin(t ); y2 = sin( t); x = [y y2];

% --- STEROWANIE ---
fp

= 1000;

= 10;

fs2 =

Tmax = 2;
A

= 1;

fi0

= 0;

fi02 =

= 0:1/fp:Tmax;

t2 =

0:1/fp:2*Tmax+1/fp;

% --- ALGORYTM ---
Amod = A * exp(-t);
y

= Amod .* sin(2 * pi * fs * t +fi0);

= A * sin(2 * pi * fs2 * t + fi02);

x =

y2];

% --- PREZENTACJA ---
figure(1);
clf
hold on;
grid on;
plot(t2, x, 'r')
xlabel('t');
ylabel('y, y2, x');

Algorytm: y1 = A * sin(t ); y2 = A2 * sin( t); y=y1+y2;

% --- STEROWANIE ---
fp

= 1000;

= 10;

fs2 =

Tmax = 0.1;
A = 1;
A2 =

fi0

= 0;

fi02 =

= 0:1/fp:Tmax;

% --- ALGORYTM ---
y

= A * sin(2 * pi * fs * t + fi0);

= A2 * sin(2 * pi * fs2 * t +fi02);

% --- PREZENTACJA ---
figure(1);
clf
hold on;
grid on;
plot(t, y, 'g');
plot(t, y2, 'b');
plot(t, y+y2, 'r');

xlabel('t');
ylabel('A, A2, A+A2');
legend('+g', 'przebieg pierwszy', '+b', 'przebieg drugi', '+r',
'suma', 10);
plot(t, y, '+g');
plot(t, y2, '+b');
plot(t, y+y2, '+r');

9. Algorytm: Amod = A * exp(-t); - exp modulująca

y = Amod .* sin(t); - sin modulowany

% --- STEROWANIE ---
fp = 1000;
fs = 10;
Tmax = 2;
A = 1;
fi0 = 0;
t = 0:1/fp:Tmax;
% --- ALGORYTM ---
Amod = A * exp(-t);
y

= Amod .* sin(2 * pi * fs * t + fi0);

% --- PREZENTACJA ---
figure(1);
clf
hold on;
grid on;
plot(t, y, 'r');
plot(t, Amod, 'g');
xlabel('t');
ylabel('A, exponenta');
legend('r', 'sin zmodulowany', 'g', 'exponenta');

10. Algorytm: Amod = A * cos( t); - cos modulujący

y = Amod .* sin( t); - sin zmodulowany

% --- STEROWANIE ---
fp = 1000;
fs = 10;
fs2 =

Tmax

= 0.5;

A = 1;
fi0 = 0;
fi02 = 10;
t

= 0:1/fp:Tmax;

% --- ALGORYTM ---
Amod

= A * cos(2 * pi * fs2 * t + fi02);

= Amod .* sin(2 * pi * fs * t + fi0);

% --- PREZENTACJA ---
figure(1);
clf
hold on;
grid on;
plot(t, y, 'r');
plot(t, Amod, 'g');
plot(t, -Amod, 'b');
xlabel('t');
ylabel('A, exponenta');
legend('r', 'sin zmodulowany', 'g', 'cos modulujacy', 'b', 'cos modula-
jacy', 50);

11. Algorytm:

y1 = X * sin (2 * pi * fs * t + fi0); y2 = Y * sin (2 * pi * fs2 * t +fi02);
y3 = y1 + y2; fy3 = fft(y3); y31 = ifft(fy3); dy = (y3 - y31) .* (y3 - y31);

% --- STEROWANIE ---
X

.5;

1000;

10;

fs2

= 40;

fi0

= 0;

fi02 =

Tmax =

0:1/fp:Tmax;

% --- ALGORYTM ---
y1

= X * sin (2 * pi * fs * t + fi0);

= Y * sin (2 * pi * fs2 * t +fi02);

= y1 + y2;

fy3

= fft(y3);

y31

= ifft(fy3);

= (y3 - y31) .* (y3 - y31);

% --- PREZENTACJA ---
figure(1);
clf
hold on;
grid on;
%plot(t, y1, 'g');
%plot(t, y2, 'b');

plot(t, y3, 'r'); title('Przebieg');
figure(2);
clf
hold on;
grid on;
F = fft(y3);
subplot(2, 1, 1), plot(t, abs(F), 'b'); title('Amplituda'); grid on;
subplot(2, 1, 2), plot(t, angle(F), 'r'); title('faza'); grid on;
figure(3);
clf
subplot(2,1,1),plot(t, y3,'g', t, y31, '.r');
subplot(2,1,2),plot(t, dy);

13. Algorytmy: y1 = X * sin (2 * pi * fs * t + fi0 );

y2 = rand(size(t)); przebieg jednostajny
y3 = randn(size(t)); przebiegnormalny

% --- STEROWANIE ---
X

1000;

10;

fi0 =

Tmax = 1;
t =

0:1/fp:Tmax;

0:1/fp:2*Tmax;

% --- ALGORYTM ---
y1

= X * sin (2 * pi * fs * t + fi0 );

y2 =

rand(size(t));

%jednostajny

y3 =

randn(size(t));

%normalny

% --- PREZENTACJA ---
figure(1);
clf
subplot(3,1,1), plot(t, y1, 'g'); grid on;
subplot(3,1,2), plot(t, y2, 'r'); grid on;
subplot(3,1,3), plot(t, y3, 'b'); grid on;
figure(2);
clf;
subplot(3,1,1), hist(y1);title('sygnał z pkt. 1');
subplot(3,1,2), hist(y2);title('szum o rozkładzie jednostajnym');
subplot(3,1,3), hist(y3);title('szum o rozkładzie normalnym');
figure(3);
clf;
subplot(3,1,1), plot(t1, xcorr(y1),'g'); title('syganł z pkt. 1');grid on;

subplot(3,1,2), plot(t1, xcorr(y2),'g'); title('szum o rozkładzie jednostajny
');grid on;
subplot(3,1,3), plot(t1, xcorr(y3),'g'); title('szum o rozkładzie normalnym');grid
on;
figure(4);
clf;
subplot(3,1,1), plot(t1, xcov(y1),'r'); title('syganł z pkt. 1');grid on;
subplot(3,1,2), plot(t1, xcov(y2),'r'); title('szum o rozkładzie jednostajny
');grid on;
subplot(3,1,3), plot(t1, xcov(y3),'r'); title('szum o rozkładzie normalnym');grid
on;

14. Algorytmy: s = rand(size(t); y1 = X * sin ( t ); y2 = Y * sin ( t );
y3 = y1 + y2; y3s = y1 + y2 + s;

% --- STEROWANIE ---
X =

Y =

.5;

fp =

1000;

fs =

10;

fs2

40;

fi0

fi02

Tmax

.5;

t =

0:1/fp:Tmax;

% --- ALGORYTM ---
s =

rand(size(t/6));

= X * sin (2 * pi * fs * t + fi0);

= Y * sin (2 * pi * fs2 * t +fi02);

= y1 + y2;

y3s

= y1 + y2 + s;

% --- PREZENTACJA ---
figure(1);
clf
hold on;
grid on;
%plot(t, y1, 'g');
%plot(t, y2, 'b');
subplot(2, 1, 1), plot(t, y3, 'r'); title('Przebieg "czysty"');
subplot(2, 1, 2), plot(t, y3s, 'g'); title('Przebieg "zaszumiony"');
figure(2);
clf
hold on;
grid on;
F =

fft(y3);

Fs =

fft(y3s);

subplot(4, 1, 1), plot(t, abs(F), 'b'); title('Amplituda przebiegu "czystego"'); grid on;
subplot(4, 1, 2), plot(t, abs(Fs), 'b'); title('Amplituda przebiegu "zaszumionego"'); grid
on;
subplot(4, 1, 3), plot(t, angle(F), 'r'); title('faza przebiegu "czystego"'); grid on;

subplot(4, 1, 4), plot(t, angle(Fs), 'r'); title('faza przebiegu "zaszu-
mionego"'); grid on;

15. Porównanie

FFT

podziałem czasowym z ''FFT'' wbudowanym

% dane
clear all;
close all;
t = 0:0.01:2;
%t = 0:0.001:1;
f = 5;
x = 1 * sin(2 * pi * f * t + 0);
%x = 1 * sin(2 * pi * f * t + 0) + 1 * sin(2 * pi * 10 * f * t + 0);
%%% uzupełnienie do 2^n %%%
a = log2(length(x));
b = floor(log2(length(x)));
if (a - b)
for lp1 = length(x):1:2^(b+1)
x(lp1) = 0;
end
end
e = log2(length(x));
kr = length(x)/2;
p = 0;
krkr = 1;
% obliczenia
lb = log2(length(x));
in = 0:length(x)-1;

q = p + 2^(ee - 1);
X(p + 1) = xo(p + 1) + exp(-i * 2 * pi * r / length(x)) * xo(q + 1);
X(q + 1) = xo(p + 1) - exp(-i * 2 * pi * r / length(x)) * xo(q + 1);
r = r + 2^(e - ee);
fR = fR - 1;
if fR == 0
r = 0;
fR = lr;
end
end
end
p = 0; xo = X;
end
XX = fft(x);
% prezentacja
scrsz = get(0,'ScreenSize');
xx = scrsz(3)*0.075;
x_ = scrsz(3)*0.87;
yy = scrsz(4)*0.06;
y_ = scrsz(4)*0.9;
figure(1); clf;
set(1,'Position', [xx yy x_ y_], 'MenuBar', 'none', 'Name', ' porównanie FFT z
podziauem czasowym z ''FFT'' wbudowanom', 'NumberTitle', 'off');
axes('Position', [0.07 0.71 0.9 0.25]); plot(x);
ylim = get(gca, 'YLim'); axis([0 length(x) ylim]);
xlabel('k'); ylabel('x(k)'); title(sprintf('sygnau uzupełniony do 2^%d, czyli %d', e,
length(x)));
axes('Position', [0.07 0.285 0.4 0.35]); plot(abs(X), 'r');
ylim = get(gca, 'YLim'); axis([0 length(x) ylim]);
xlabel('k'); ylabel('|X(k)|'); title('widmo amplitudowe obliczone FFT z podziauem');

axes('Position', [0.57 0.285 0.4 0.35]); plot(abs(XX), 'g');
ylim = get(gca, 'YLim'); axis([0 length(x) ylim]);
xlabel('k'); ylabel('|XX(k)|'); title('widmo amplitudowe FFT wbudowanej');
axes('Position', [0.07 0.07 0.9 0.15]); plot(abs(XX) - abs(X));
ylim = get(gca, 'YLim'); axis([0 length(x) ylim]);
xlabel('k'); ylabel('[|X(k)|-|XX(k)|]'); title('wska nik różnic pomiędzy FFT z podzi-
auem a FFT wbudowanym');

16. Transformata Fourier'a

% dane
clear all;
f = 10;
N = 99;
t = 0:0.005:10;
x = 1 * sin(2 * pi * f * t + 0);
for i = 1:1:(3 * N + 1)
X(i) = 0;
end
% obliczenia
for k = 0:1:(3 * N - 1)
for n = 0:1:(N - 1)
X(k + 1) = X(k + 1) + x(n + 1) * exp(-j * ( (2 * pi) / N ) * k * n);
end
end
XX = fft(x, N);
adif = abs(XX(1:1:99)) - abs(X(1:1:99));
fdif = unwrap(angle(XX(1:1:99))) - unwrap(angle(X(1:1:99)));
% prezentacja
scrsz = get(0,'ScreenSize');

xx = scrsz(3)*0.125;
x_ = scrsz(3)*0.87;
yy = scrsz(4)*0.06;
y_ = scrsz(4)*0.9;
figure(1); clf;

set(1,'Position', [xx yy x_ y_], 'MenuBar', 'none', 'Name', ' transformata Fourier''a',
'NumberTitle', 'off');
subplot(3, 1, 1); plot(100 * t, x); hold on; plot(100 * t, x, '.r');
xlabel('n'); ylabel('x(n)'); axis([0 100 -1.1 1.1]); title('Sygnał');
set(gca, 'Position', [0.05 0.71 0.9 0.2238]);
subplot(3, 1, 2); plot(1:1:100, abs(X(1:1:100))); hold on; plot(101:1:298,
abs(X(101:1:298)), 'g');
xlabel('k'); ylabel('|X(k)|'); axis([0 300 0 60]); title('widmo amplitudowe');
set(gca, 'Position', [0.05 0.405 0.9 0.2238]);
subplot(3, 1, 3); plot(1:1:100, unwrap(angle(X(1:1:100)))); hold on;
plot(100:1:298, unwrap(angle(X(100:1:298))), 'g');
xlabel('k'); ylabel('arg(X(k))'); title('widmo fazowe');
set(gca, 'Position', [0.05 0.1 0.9 0.2238]);
figure(2); clf;
set(2,'Position', [xx yy x_ y_], 'MenuBar', 'none', 'Name', ' porównanie transfor-
maty ze wzoru z funkcja ''fft''', 'NumberTitle', 'off');
axes('Position', [0.05 0.77 0.4 0.20]); plot(abs(X(1:1:101)), 'r'); axis([0 100 0 55]);
xlabel('k'); ylabel('|X(k)|'); title('widmo amplitudowe ''wzór''');
axes('Position', [0.55 0.77 0.4 0.20]); plot(abs(XX), 'g'); axis([0 100 0 55]);
xlabel('k'); ylabel('|XX(k)|'); title('widmo amplitudowe ''fft''');
axes('Position', [0.05 0.58 0.9 0.1]); plot(adif.*adif, '.'); hold on; plot(adif.*adif,
'm'); axis([0 100 0 5e-26]);
xlabel('k'); ylabel('[|X(k)|-|XX(k)|]^2'); title('wska nik różnic pomiędzy fft a
''wzorem''');
axes('Position', [0.05 0.25 0.4 0.25]); plot(unwrap(angle(X(1:1:99))), 'r');

xlabel('k'); ylabel('arg(X(k))'); title('widmo fazowe ''wzór''');
axes('Position', [0.55 0.25 0.4 0.25]); plot(unwrap(angle(XX)), 'g');
xlabel('k'); ylabel('arg(XX(k))'); title('widmo fazowe ''fft''');
axes('Position', [0.05 0.08 0.9 0.1]); plot(fdif.*fdif, '.'); hold on; plot(fdif.*fdif, 'm');
axis([0 100 0 1e-24]);
xlabel('k'); ylabel('[arg(X(k))-arg(XX(k))]^2'); title('wska nik różnic pomiędzy fft a
''wzorem''');
figure(3); clf;
set(3,'Position', [10 10 60 90], 'MenuBar', 'none', 'Name', ' :)', 'NumberTitle', 'off');
p(1) = uicontrol('Style', 'pushbutton', 'String', 'Close All', 'Position', [25 5 50 30],
'Callback', 'sw');
p(2) = uicontrol('Style', 'pushbutton', 'String', 'Fourier', 'Position', [17 40 70 20],
'Callback', 'sw');
p(3) = uicontrol('Style', 'pushbutton', 'String', 'Porównanie', 'Position', [17 65 70
20], 'Callback', 'sw');

figure(1);

17. Liniowa

zmiana

częstotliwości, dewiacja częstotliwości

%%% dane
f = 10;
df = 15;
fp = 1000;
w0 = 2 * pi * f;
dw0 = 2 * pi * df;
n = 1:2048;
t = 1/fp.*n;
N = 700;
k = (dw0/N)*fp;
wm = 10;
Df = 150;

%%% obliczenia
%% punkt (1a) %%
y1a = sin(w0*t+(1/2)*k*(t.*t));
%% punkt (1b) %%
y1b = sin(w0*t - (Df/(2*pi*wm))*cos(wm*t));
%% punkt (2a) %%
X2a = fft(y1a);
X2b = fft(y1b);
%% punkt (2b) %%
%%% prezentacja
scrsz = get(0,'ScreenSize');
xx = scrsz(3)*0.15;
x_ = scrsz(3)*0.8;
yy = scrsz(4)*0.1;
y_ = scrsz(4)*0.8;
figure(1); clf;
set(1,'Position', [xx yy x_ y_], 'MenuBar', 'none', 'Name', ' liniowa zmiana czestot-
liwosci', 'NumberTitle', 'off');
subplot(2, 1, 1); plot(y1a); axis([0 2048 get(gca, 'YLim')]);
title('liniowa zmiana f');
subplot(2, 2, 3); plot(abs(X2a)); axis([0 300 get(gca, 'YLim')]);
title('FFT sygnau');
subplot(2, 2, 4); specgram(y1a); axis([get(gca, 'XLim') 0 0.2]);
title('SPECGRAM sygnau');
figure(2); clf;
set(2,'Position', [xx yy x_ y_], 'MenuBar', 'none', 'Name', ' dewiacja czestotliwo-
sci', 'NumberTitle', 'off');
subplot(2, 1, 1); plot(y1b); axis([0 2048 get(gca, 'YLim')]);
title('dewuiacyjna zmiana f');