Lastnosti Fourierove transformacije

Hide code cell source

 
import numpy as np
from scipy import signal
import matplotlib.pyplot as plt
plt.rcParams["figure.figsize"] = (15, 5)

Lastnosti Fourierove transformacije#

Na tej vaji si bomo iz praktičnega vidika pogledali lastnosti Fourierove transformacije, s katerimi imamo pogosto opravka pri merjenju signalov:

  • linearnost,

  • časovno skaliranje,

  • (časovni obrat),

  • časovni premik,

  • (amplitudna modulacija - frekvenčni premik),

  • odvajanje in integriranje,

  • konvolucija in produkt funkcij.

Naloga#

Domača naloga

Z uporabo generatorja signalov in zajemnega sistema Arduino pripravite signale, s katerimi boste demonstrirali lastnosti Fourierove transformacije, določene v podatkih naloge.

Priprave in zajema signalov se lotite v skupini s kolegi, ki imajo enake podatke. LabView program za zajem lahko prenesete v obliki zip arhiva.

Pripravite kratko poročilo (obseg od 3 do 10 celic s kodo v okolju Jupyter Notebook), iz katerega naj bodo razvidni podatki naloge (iz tabele), ter da ste vse parametre in zahteve naloge naloge tudi upoštevali. Demonstrirajte vpliv izbrane lastnosti Fourierove transformacije na zajeta signala (zglede poiščite v predlogah za predavanja in vaje).

Poročilo oddajte v .pdf obliki (glejte navodila za oddajo domačih nalog).

Dodatek: Raziščite lastnost konvolucije / množenja signalov v povezavi s Fourierovo transformacijo in jo prikažite ter komentirajte na primeru uporabe oken (uporabite scipy.signal.windows) z enim izmed signalov, zajetih na vaji.

Linearnost#

Linearnost

\[ \mathcal{F}\{a\,x(t)+b\,y(t)\} = a\,X(f) + b\,Y(f). \]
fs = 100 # Hz
dt = 1 / fs
t = np.arange(0, 2, dt)
A = 5
p = 4
o = 2

x = A * np.sin(2*np.pi*t * p) + o*2
y = 2*A * signal.square(2*np.pi*t * p/2) + o

Hide code cell source

 
plt.figure()
plt.plot(t, x, label='sin')
plt.plot(t, y, label='square')
plt.xlabel('t [s]')
plt.ylabel('x [/]')
plt.legend(loc=(1.01, 0));
../_images/256ecbe57ceb511583197c14694644c2223a664ff1c8f274a1d195c247eaa196.png 
X = np.fft.rfft(x) / len(t) * 2
Y = np.fft.rfft(y) / len(t) * 2
freq = np.fft.rfftfreq(len(t), dt)

Hide code cell source

 
plt.figure()
plt.plot(freq, np.abs(X), label='X')
plt.plot(freq, np.abs(Y), label='Y')
plt.xlabel('f [Hz]')
plt.ylabel('$|\\mathcal{F}(x)|$ [/]')
plt.legend(loc=(1.01, 0));
../_images/97072c6bf88ff0bafbe05441a977cea1aeb4e1906d324ae2e81878e7ef4bc3bb.png

Prikaz lastnosti linearnosti:

v = x + y
V = np.fft.rfft(v) / len(t) * 2

Hide code cell source

 
plt.figure()
plt.plot(freq, np.abs(V), label='$\\mathcal{F}(x+y)$')
plt.plot(freq, np.abs(X + Y), label='$\\mathcal{F}(x) + \\mathcal{F}(y)$')
plt.xlabel('f [Hz]')
plt.ylabel('$|\\mathcal{F}(x)|$ [/]')
plt.legend(loc=(1.01, 0));
../_images/1368adcc9405b4427089bced764dfc2561093efd468fd6115feac85bbdf34216.png

Uporaba linearnosti pri korekciji naloženega signala:

V_Y = V - Y

Hide code cell source

 
plt.figure()
plt.plot(freq, np.abs(V_Y), label='$\\mathcal{F}(x+y) - \\mathcal{F}(y)$')
plt.plot(freq, np.abs(X), label='$\\mathcal{F}(x)$')
plt.xlabel('f [Hz]')
plt.ylabel('$|\\mathcal{F}(x)|$ [/]')
plt.legend(loc=(1.01, 0));
../_images/9c21a565503f80171275081e3755ce177707a50800d9e35ae58f89d3312ca933.png

Inverzna FFT razlike vsote signalov in naloženega signala:

v_y = np.fft.irfft(V_Y/2*len(t))

Hide code cell source

 
plt.figure()
plt.plot(t, x, label='x')
plt.plot(t, v_y, label='$\\mathrm{IFFT}(\\mathcal{F}(x+y) - \\mathcal{F}(y))$')
plt.xlabel('t [s]')
plt.ylabel('x [/]')
plt.legend(loc=(1.01, 0));
../_images/1f41b15cf17d68c779b825d7ec4cc6217fce454a89a1ae1d41640f3e4e5d5e87.png

Časovno skaliranje#

Časovno skaliranje

\[ \mathcal{F}\{x(a\,t)\} = \frac{1}{|a|}\,X(f/a). \]

Primer 1: Gaussov impulz#

a = 2         # faktor časovnega skaliranja: a>1: "kompresija" v časovni domeni, "raztezanje" na frekvenčni osi (in obratno)                                                                                                                                                            
sigma = 0.15  # Širina gaussovega okna[s]
t0 = 1.0      # Center pulza

# Osnovni signal: Gaussov impulz
x = np.exp(-(t - t0)**2 / (2*sigma**2))                   

# Saignal pri skaliranem času a*t
y = np.exp(-(a*t - t0)**2 / (2*sigma**2))

Hide code cell source

 
fig, ax = plt.subplots(2, 1, figsize=(7, 5))                                                                                                                                                                                              

ax[0].plot(t, x, label='$x(t)$')                                                                                                                                                                                                          
ax[0].plot(t, y, label=f'$x(a\\,t),\\ a={a}$')
ax[0].set_xlabel('t [s]')                                                                                                                                                                                                                 
ax[0].set_ylabel('x [/]')
if a >= 1:                                
    ax[0].set_title('Časovna domena — časovna kompresija za $a>1$')
else:
    ax[0].set_title('Časovna domena — časovni razteg za $a<1$')
ax[0].legend()                                                                                                                                                                                                                            

X = np.fft.rfft(x) / len(t)
Y = np.fft.rfft(y) / len(t)

freq = np.fft.rfftfreq(len(t), dt)                                                                                                                                                                                                        

ax[1].plot(freq, np.abs(X), label='$X(f)$')                                                                                                                                                                                               
ax[1].plot(freq, np.abs(Y), label=f'$\\mathcal{{F}}\\{{x(at)\\}},\\ a={a}$')
ax[1].set_xlabel('f [Hz]')                                                                                                                                                                                                                
ax[1].set_ylabel('$|\\mathcal{F}(x)|$ [/]')
ax[1].set_xlim(0, fs/2)
if a >= 1:
    ax[1].set_title('Frekvenčna domena — razširitev spektra in zmanjšanje amplitude')
else:
    ax[1].set_title('Frekvenčna domena — kompresija spektra in povečanje amplitude')                                                                                                                                                       
ax[1].legend()

plt.tight_layout()
../_images/3f4286a2712e7465633905ad6a8a3f6a03668046fbebe0f5c542c7a14fed1354.png

Gaussov pulz je aperiodičen signal s končno energijo, zato časovna kompresija dejansko zmanjša njegovo “površino” in s tem amplitudo spektra za faktor \(1/|a|\).

Pri periodičnem, didskretnem sinusnem signalu v naslendjem primeru bomo imeli z demonstracijo tega vpliva malo več težav.

Primer 2: Simulacija meritve sinusnega signala#

A = 1
p = 2
o = 0
a = 2

sin = lambda t, A, p, o: A*np.sin(2*np.pi*t*p) + o
x = sin(t, A, p, o)

at = np.arange(0, 2, a*dt)
y = sin(at, A, p, o)

Hide code cell source

 
plt.figure()
plt.plot(t, x, label='x(t)')
plt.plot(at, y, label='x(at)')
plt.xlabel('t [s]')
plt.ylabel('x [/]')
plt.legend(loc=(1.01, 0));
../_images/6fe0163155ce6b32bbc4d1e8f8d94bc1c9e57389ac23bf1d5c6c7366cf771889.png

Trajanje meritve je enako, a pri časovno skaliranem koraku \(a \, \Delta t\):

Hide code cell source

 
plt.figure()
plt.plot(x, label='x(t)')
plt.plot(y, label='x(at)')
plt.xlabel('vzorec [/]')
plt.ylabel('x [/]')
plt.legend(loc=(1.01, 0));
../_images/007012e515142ecca41f791ae0c5d8bb77b4ac8e453e96a5c9e22647e87aeafc.png 
X = np.fft.rfft(x)
Y = np.fft.rfft(y)
freq = np.fft.rfftfreq(len(t), dt)
freq_a = np.fft.rfftfreq(len(at), a*dt)

Če časovno skaliranje poznamo in upoštevamo pri pretvorbi je rezultat pravilen:

Hide code cell source

 
plt.figure()
plt.plot(freq, np.abs(X/len(t)*2), label='X')
plt.plot(freq_a, np.abs(Y/len(at)*2), label='Y')
plt.xlabel('f [Hz]')
plt.ylabel('$|\\mathcal{F}(x)|$ [/]')
plt.legend(loc=(1.01, 0));
../_images/bae483c5a70f904d833aae878323a10db6d400fe29354a2586f498a3ce818355.png

Časovno skaliranje nam v tem primeru povzroča težave, če se ga pri meritvi ne zavedamo:

freq_a_s = np.fft.rfftfreq(len(at), dt)

Za demonstracijo efekta časovnega skaliranja podobno “napako” naredimo tudi pri normiranju spektrov:

Nevede smo merili z vzorčno frekvenco a*fs namesto fs. Rezultat bomo torej (neustrezno) normirali z N=T/fs.

(Jasno je, da v praksi take napake ne bi naredili - dejanjsko število vzorcev je očitno razvidno iz pomerjenega signala. Težave s časovnim skaliranjem imamo, kadar se ga ne zavedamo - gre za hipotetičen scenarij.)

X = X / len(t)
X[1:-1] *= 2
Y = Y / len(t) # tukaj nastane težava - dejanjska dolžina signala y je krajša od vektorja t
Y[1:-1] *= 2

Hide code cell source

 
plt.figure()
plt.plot(freq, np.abs(X), label='X')
plt.plot(freq_a_s, np.abs(Y), label='Y')
plt.xlabel('f [Hz]')
plt.ylabel('$|\\mathcal{F}(x)|$ [/]')
plt.xlim(0, 10)
plt.legend(loc=(1.01, 0));
../_images/66cbd25ec368acce27573495e863f1f1110baa1d2aa79bcd26b6198be47d4e6e.png

Korekcija časovnega skaliranja

\[ \mathcal{F}\{x(a\,t)\} = \frac{1}{|a|}\,X(f/a). \]

Signal smo pretvorili v frekvenčno domeno pri frekvencah \(f/a\), sedaj ga še narišimo pri \(f/a\):

freq_a_popravek = freq_a_s / a

Popravek amplitude:

Y_popravek = np.abs(a) * Y

Hide code cell source

 
plt.figure()
plt.plot(freq, np.abs(X), label='X')
plt.plot(freq_a_popravek, np.abs(Y_popravek), label='Y_popravljen')
plt.xlabel('f [Hz]')
plt.ylabel('$|\\mathcal{F}(x)|$ [/]')
plt.xlim(0, 10)
plt.legend(loc=(1.01, 0));
../_images/6b3062422ff49246e36185b28d78499a60895e8c797f7f71544c632a73b0ffa6.png

Časovni premik#

Časovni premik

\[ \mathcal{F}\{x(t-t_0)\} = e^{-\textrm{i}\,2\pi\,f\,t_0}\,X(f). \]
A = 1
p = 2
o = 0
t_0 = 0.55

square = lambda t, A, p, o: A*signal.square(2*np.pi*t*p) + o

x = square(t, A, p, o)
y = square(t-t_0, A, p, o)

Hide code cell source

 
plt.figure()
plt.plot(t, x, label='x(t)')
plt.plot(t, y, label='x(t - t_0)')
plt.xlabel('t [s]')
plt.ylabel('x [/]')
plt.legend(loc=(1.01, 0));
../_images/8d7bb7d4dae3a3a1b3c61c4d8dca1db113a03f4f9e15fac92dd40407760599a6.png 
X = np.fft.rfft(x)
Y = np.fft.rfft(y)
freq = np.fft.rfftfreq(len(t), dt)

Hide code cell source

 
fig, ax = plt.subplots(2, 1)
ax[0].plot(freq, np.abs(X/len(t)*2), label='X')
ax[0].plot(freq, np.abs(Y/len(t)*2), label='Y')
ax[0].set_ylabel('$|\\mathcal{F}(x)|$ [/]')
ax[0].set_xlim(0, 20)
ax[0].legend(loc=(1.01, 0));

ax[1].plot(freq, np.angle(X/len(t)*2), label='X')
ax[1].plot(freq, np.angle(Y/len(t)*2), label='Y')
ax[1].set_xlabel('f [Hz]')
ax[1].set_ylabel('$\\angle \\mathcal{F}(x)$ [rad]')
ax[1].set_xlim(0, 20)
ax[1].legend(loc=(1.01, 0));
../_images/f72dbade45f984f890d112e3ef041d49dc752154a4680842df6323b4b2d716fd.png 
X_shift = np.exp(-1j*2*np.pi*freq*t_0) * X

Hide code cell source

 
fig, ax = plt.subplots(2, 1)
ax[0].plot(freq, np.abs(X/len(t)*2), label='X')
ax[0].plot(freq, np.abs(X_shift/len(t)*2), label='shifted X')
ax[0].set_ylabel('$|\\mathcal{F}(x)|$ [/]')
ax[0].set_xlim(0, 20)
ax[0].legend(loc=(1.01, 0));

ax[1].plot(freq, np.angle(X/len(t)*2), label='X')
ax[1].plot(freq, np.angle(X_shift/len(t)*2), label='shifted X')
ax[1].set_xlabel('f [Hz]')
ax[1].set_ylabel('$\\angle \\mathcal{F}(x)$ [rad]')
ax[1].set_xlim(0, 20)
ax[1].legend(loc=(1.01, 0));
../_images/e58310cd41c66991c1315a1097e63296a353fe37afd1345a83534855ee1b9020.png

Uspešnost časovnega premika preverimo v časovni domeni:

x_shift = np.fft.irfft(X_shift)

Hide code cell source

 
plt.figure()
plt.plot(t, x_shift, label='$\\mathrm{IFFT}(X_{\\mathrm{shift}})$')
plt.plot(t, y, label='x(t - t_0)')
plt.xlabel('t [s]')
plt.ylabel('x [/]')
plt.legend(loc=(1.01, 0))

<matplotlib.legend.Legend at 0x7f0ff93d4cd0>
../_images/9830736a17e26c9cc39670b6453bfe914b7e52193d22311a6345269e4f0d67c0.png

Amplitudna modulacija#

Amplitudna modulacija (frekvenčni zamik)

\[ \mathcal{F}\{x(t)\,e^{\textrm{i}\,2\pi\,f_0\,t}\} = X(f-f_0). \]

oziroma:

\[ \mathcal{F}\{x(t)\,\cos(2\pi\,f_0\,t)\} = \frac{1}{2}\big(X(f-f_0)+X(f+f_0)\big). \]
A = 1
p = 2
o = 0
f_0 = 1.

x = sin(t, A, p, o)
mod = np.cos(2*np.pi*f_0*t)
y = x * mod

Hide code cell source

 
plt.figure()
plt.plot(t, x, label='$x(t)$')
plt.plot(t, mod, label='modulacijski signal')
plt.plot(t, y, label='$x_{\\mathrm{moduliran}}(t)$')
plt.xlabel('t [s]')
plt.ylabel('x [/]')
plt.legend(loc=(1.01, 0));
../_images/c79b13b3aab13b027a46865da66e0900e0c2b1c1209da0ec636bd75257203a0f.png 
X = np.fft.rfft(x)
Y = np.fft.rfft(y)
freq = np.fft.rfftfreq(len(t), dt)

Hide code cell source

 
plt.figure()
plt.plot(freq, np.abs(X/len(t)*2), label='X')
plt.plot(freq, np.abs(Y/len(t)*2), label='Y')
plt.xlabel('f [Hz]')
plt.ylabel('$|\\mathcal{F}(x)|$ [/]')
plt.xlim(0, 10)
plt.legend(loc=(1.01, 0));
../_images/24151c63a17526d91b6c60c9cd7343b416631499aacbeeab3b39aa6a65a5b052.png

Odvajanje in integriranje#

Odvajanje in integriranje

\[ \mathcal{F}\{\dot x(t)\} = \textrm{i}\,2\pi\,f\,X(f) \]

in obratno:

\[ \mathcal{F}\big\{\int_{-\infty}^t x(\tau)\,\textrm{d}\tau\big\} = \frac{X(f)}{\textrm{i}\,2\pi\,f}. \]
A = 1
p = 2
o = 1.5

x = sin(t, A, p, o)

Spomnimo se:

\(\frac{\mathrm{d}}{\mathrm{d} \, t}A \, \sin(a \, x) + o = A \, a \, \cos(a \, x)\)

y = A*2*np.pi*p*np.cos(2*np.pi*t*p)

np.allclose(y, np.gradient(x, dt, edge_order=2), rtol=1e-2)

True

Hide code cell source

 
plt.figure()
plt.plot(t, x, label='$x(t)$')
plt.plot(t, y, label='$y = \\dot{x}(t)$')
plt.xlabel('t [s]')
plt.ylabel('x [/]')
plt.legend(loc=(1.01, 0));
../_images/73a72b9a17d7a0d75bbe9bb002aba440f95c87d5e7d4759e11ce86010aa2acac.png 
X = np.fft.rfft(x) / len(t)
Y = np.fft.rfft(y) / len(t)
X[1:] *= 2
Y[1:] *= 2
freq = np.fft.rfftfreq(len(t), dt)

Hide code cell source

 
plt.figure()
plt.plot(freq, np.abs(X), label='X')
plt.plot(freq, np.abs(Y), label='Y')
plt.xlabel('f [Hz]')
plt.ylabel('$|\\mathcal{F}(x)|$ [/]')
plt.xlim(0, 10)
plt.legend(loc=(1.01, 0));
../_images/58b3f580d65bc78180d5a6acb8d1c9c3ac46748c8a46d9ce26847c9b723cf904.png

Odvod v frekvenčni domeni:

\(\mathcal{F}(\dot{x}(t)) = \mathrm{i} \, \omega \, \mathcal{F}(x(t))\)

omega = 2*np.pi*freq
dX = 1j*omega * X

Hide code cell source

 
plt.figure()
plt.plot(freq, np.abs(dX), label='$\\mathrm{i} ~ \\omega X$')
plt.plot(freq, np.abs(Y), label='Y')
plt.xlabel('f [Hz]')
plt.ylabel('$|\\mathcal{F}(x)|$ [/]')
plt.xlim(0, 10)
plt.legend(loc=(1.01, 0));
../_images/2f01cdb3928c81cb4cda2bd1eddba6f854cf0c05f2e5f8c3d56da3a26cd1d280.png

Integral v frekvenčni domeni:

\(\mathcal{F}(x(t)) = 1 / (\mathrm{i} \, \omega) \cdot \mathcal{F}(\dot{x}(t))\)

omega[0] = 1e-6
ing_Y = 1 / (1j*omega) * Y

Hide code cell source

 
plt.figure()
plt.plot(freq, np.abs(X), label='$X$')
plt.plot(freq, np.abs(ing_Y), label='$1/(\\mathrm{i} ~ \\omega) ~ Y$')
plt.xlabel('f [Hz]')
plt.ylabel('$|\\mathcal{F}(x)|$ [/]')
plt.xlim(0, 10)
plt.legend(loc=(1.01, 0));
../_images/bb2999e8ef9d3c93591a4a2666c12611b12cf57d11243f824452e44b6921579f.png

Konvolucija in produkt funkcij#

Konvolucija in produkt funkcij

\[ \mathcal{F} \big\{ x(t)*y(t) \big\} = X(f) \, Y(f) \]

in

\[ \mathcal{F} \big\{ x(t) \, y(t) \big\} = X(f)*Y(f) \]

Note

Znak \(*\) označuje konvolucijo:

\[ x(t)*y(t) = \int_{-\infty}^{+\infty} x(\tau)\,y(t-\tau)\,\textrm{d}\tau \]

Ker je produkt v frekvenčni domeni numerično veliko učinkovitejša operacija od konvolucije v časovni domeni, je to ena najpomembnejših lastnosti Fourierove transformacije!

Vizualizacija konvolucije na diskretnem signalu:

convolve

A = 1
p = 3
o = 1.5

x = square(t, A, p, o)

X = np.fft.rfft(x) / len(t)
X[1:] *= 2
freq = np.fft.rfftfreq(len(t), dt)

Hide code cell source

 
plt.figure()
plt.plot(freq, np.abs(X), label='X')
plt.xlabel('f [Hz]')
plt.ylabel('$|\\mathcal{F}(x)|$ [/]')
plt.xlim(0, 20)
plt.legend(loc=(1.01, 0));
../_images/c5dae1eecb491e01032ef2ca637e1c485b9b5bd7ce52ae7a8ad24990cd77521b.png

Pripravimo pasovni frekvenčni filter, ki prepušča le v območju \((1.5, 4.5)\) Hz:

freq_band = np.array([1.5, 4.5]) 
b, a = signal.butter(3, freq_band, btype='bandpass', fs=fs)

Pripravimo frekvenčno prenosno funkcijo filtra \(H(f)\):

w, H = signal.freqz(b, a, len(freq), whole=False, fs=fs)

Hide code cell source

 
plt.figure()
plt.plot(w, np.abs(H), label='filter')
plt.plot(freq, np.abs(X), label='X')
plt.xlabel('f [Hz]')
plt.ylabel('$|\\mathcal{F}(x)|$ [/]')
plt.xlim(0, 20)
plt.legend(loc=(1.01, 0));
../_images/1d9cdd8fe4cf14ac861b78338347112bd34f2228398faa4749901f8c0dd5e4ac.png

Filtrirajmo signal z množenjem v frekvenčni domeni:

X_filtriran = X * H

Hide code cell source

 
plt.figure()
plt.plot(freq, np.abs(X), label='$X$')
plt.plot(freq, np.abs(X_filtriran), label='$X \\cdot H$')
plt.xlabel('f [Hz]')
plt.ylabel('$|\\mathcal{F}(x)|$ [/]')
plt.xlim(0, 20)
plt.legend(loc=(1.01, 0));
../_images/d2fe49a9476049b2939b4157f061181db6d15564a94a2dcfd184ca663d74b588.png

Poglejmo še impulzno prenosno funkcijo filtra \(h(t)\) (odziv filtra v času):

h = np.fft.irfft(H)

Hide code cell source

 
plt.figure()
plt.plot(t, x, label='$x(t)$')
plt.xlabel('t [s]')
plt.ylabel('x [/]')
plt.legend(loc=2);
ax2 = plt.gca().twinx()
ax2.plot(t, h, 'C1', label='filter')
ax2.set_ylabel('filter [/]')
ax2.legend(loc=1);
../_images/03a5ce1f2851426e0911cedc839d4e874ba499317e964e74bbfb271391ad95e9.png

Filtrirajmo signal s konvolucijo v časovni domeni:

x_filtriran = signal.convolve(x, h, mode='full')[:len(x)]

Hide code cell source

 
plt.figure()
plt.plot(t, x, label='$x(t)$')
plt.plot(t, x_filtriran, label='$x * h$')
plt.xlabel('t [s]')
plt.ylabel('x [/]')
plt.legend(loc=(1.01, 0));
../_images/56c88b7955a953244abc1f8eb2f02802c063ff7d6c01ff48f5b2909be1f3301a.png

Primerjajmo rezultata:

Hide code cell source

 
plt.figure()
plt.plot(freq, np.abs(X_filtriran), label='$X \\cdot H$')
plt.plot(freq, np.abs(np.fft.rfft(x_filtriran)*2/len(t)), label='$\\mathcal{F}(x*h)$')
plt.xlabel('f [Hz]')
plt.ylabel('$|\\mathcal{F}(x)|$ [/]')
plt.title('Frekvenčna domena')
plt.xlim(0, 20)
plt.legend(loc=(1.01, 0));
../_images/16adc3f1041d779b23172f672c646b345a1860ba2fe6c93e95d3a5b1e0846ee8.png

Hide code cell source

 
plt.figure()
plt.plot(t, x_filtriran, label='$x * h$')
plt.plot(t, np.fft.irfft(X_filtriran*len(t)/2), label='$\\mathrm{IFFT}(X \\cdot h)$')
plt.xlabel('t [s]')
plt.ylabel('x [/]')
plt.title('Časovna domena')
plt.legend(loc=(1.01, 0));
../_images/4a069653f5b3790352bf39c5d00f77827af713a57d084308a15f645e5cadeff5.png

Razlika je posledica implementacije funkcije konvolucije (scipy.signal.convolve). Preverite vpliv parametra mode!

Contents