Indice |
Premessa
Questo articolo è una piccola raccolta di esercizi (da annotare anche come promemoria) per il calcolo della convoluzione continua e discreta. Il quaderno degli esercizi finirà, molto probabilmente, in cantina o dimenticato chissà dove per fare spazio a nuovi quaderni per appunti e chissà cos'altro. Allora ho cominciato a scrivere qui, in modo da arricchire il blog con qualcosina di utile senza pretese particolari.
Mi sono concentrato di più su esercizi nel dominio continuo, anche se ho aggiunto un paio di esercizi nel dominio discreto.
Nota: nel calcolo delle convoluzioni continue, ho usato come notazione la variabile T. Vorrei precisare in anticipo che è appunto solo una notazione di dominio che ho spesso trovato in vari esercizi ed a cui mi sono abituato. Questa variabile può essere successivamente omessa nell'espressione del risultato finale.
Per ultimo, è di abitudine usare spesso il calcolatore con simulatori quali GNU/Octave e Matlab per comprovare i risultati: questi pero possono portare a confondere solo le idee se non è ben chiaro cosa e come si sta calcolando. Vedremo più avanti un piccolo esempio.
Esercizi con la convoluzione continua
Esercizio #1
Applichiamo la trasformazione della variabile indipendente:
Dalla rappresentazione anteriore si deduce che:

Prima traslazione:

Traslazione successiva:


Ultima traslazione:


Quindi si ha:
Esercizio #2
Rappresentazione dei segnali:
Si applica la trasformazione della variable indipendente:
Si nota che:

Prima traslazione:

Traslazione successiva:

Ultima traslazione:

Quindi:
Rappresentazione dei segnali:
Calcolo inverso
Si applica la trasformazione della variable indipendente:
Di nuovo:

Prima traslazione:

Notare che il calcolo in si ripete nell'intervallo
.
Continuando la traslazione:

Ottenendo cosi il isultato equivalente a
Esercizio #3
Rappresentazione dei segnali:
Trasformazione della variabile indipendente, in questo caso che he più comoda da disegnare:
Ancora, si nota che

Traslando il segnale fino a
si ha:

è anche possibile farlo passo a passo incremntando il limite di integrazione inferiore di uno, ma alla fine si tarda di più.
Traslazione successiva:
Da la moltiplicazione dei due segnali è costante, si ha quindi:

L'ultima traslazione è analoga alla prima:
Ed in questo caso abbiamo:


Quindi il risultato finale è:
Esercizio #4
Applichiamo la trasformazione della variabile indipendente:
Quindi:

Prima traslazione: abbiamo che:


Traslazione successiva per :
Abbiamo comunque che:

Riassumendo:
Esercizi di convoluzione discreta
Esercizio #5
Dovendo risolvere
![y[n] = \sum_{k = -\infty}^\infty x[k]h[n - k]\qquad](/mediawiki/images/math/7/2/1/72128e06b846e42a21aac2c7de5a3097.png)
chiamando il primo indice di
e
il primo indice di
risolviamo per il primo indice di
:


Quindi:
A questo punto si può rappresentare il risultato:
Per rappresentare il risultato con Octave, ho usato questo piccolo script:
nx = -1:2; x = (nx == -1) + 2*(nx == 0) -(nx == 1) + (nx == 2); nh = -2:2; h = (nh == -2) -(nh == -1 | nh == 1) + (nh == 0) +2*(nh == 2); y = conv(x,h); ny = -3:4; subplot(3,1,1); stem(nx,x,'r'); hold on;grid on; xlabel('x[n]'); subplot(3,1,2); stem(nh,h,'b'); hold on;grid on; xlabel('h[n]'); subplot(3,1,3); stem(ny,y,'g'); grid on; xlabel('x[n]*h[n]');
Generando questa rappresentazione:
Esercizio #6


Quindi:
Ed ecco una rappresentazione in scala 1:6:
Addendum: effetti di bordo con GNU/Octave e Matlab
È abbastanza noto che i due programmi GNU/OCtave e Matlab svolgono funzioni uguali o simili, anche se Matlab offre qualcosa in più (ma GNU/Octave è molto più veloce per i lavori equivalenti - p.e. lo script precedente può essere eseguito tanto con ambi i programmi).
A partire dall' esempio 2.8 a pag. 101 del libro Signals and Systems 2nd Ed. by A. Oppenheim, A. S. Willsky & S. H. Nawab, qualche mese fà mi ero proposto di rappresentare la convoluzione dei segnali con GNU/Octave o Matlab:
L'esercizio viene svolto anche sullo stesso libro ma per completezza lo riporto anche qui.
Risoluzione analitica
Quindi rappresentiamo i segnali:
E come sempre applichiamo la trasformazione della variabile indipendente :
Prima traslazione:
Per abbiamo che:
![y(t) = \int_{-\infty}^{\infty}x(\tau)h(t - \tau)\,\mathrm d\tau = \int_{-\infty}^{t - 3}\mathrm e^{2\tau}\,\mathrm d\tau = \left[{e^{2\tau}\over 2}\right]_{-\infty}^{t - 3}](/mediawiki/images/math/d/4/b/d4ba0114031c6a3a5f3b2448cedd91a0.png)

Traslazione successiva:
Una volta che


per cui:
![y(t) = \int_{-\infty}^{\infty}x(\tau)h(t - \tau)\,\mathrm d\tau = \int_{-\infty}^{0}\mathrm e^{2\tau}\,\mathrm d\tau = \left[{\mathrm e^{2\tau}\over 2}\right]_{-\infty}^{0} = {1 \over 2}\qquad t > 3T \qquad(\mathrm A.2)](/mediawiki/images/math/8/2/2/8225009b5be9d74db55cbf2fa7b74d23.png)
Quindi:
Risoluzione mediante l'uso di un simulatore: comprovazione del risultato
Se adesso di primo istinto mettiamo questi numeri in Matlab, o con Octave, con il codice:
t = -10:0.001:10; x = exp(2*t).*heaviside(-t); h = heaviside(t - 3); y = conv(x,h,'full'); ty = -20:0.001:20; plot(ty,y);
(per Octave è necessario il pacchetto specfunc per poter usare la funzione heaviside(n))
Il primo risultato è qualcosa di questo genere:
Che pasticcio! Saltano subito all'occhio due problemi:
- La funzione
non è normalizzata.
- La funzione
si azzera e non è di ampiezza costante per
.
Il pasticcio di questo codice è stato risolto nel forum in un thread aperto da me stesso.
Il problema della normalizzazione è risolvibile facilmente cambiando la assegnazione per :
y = 0.001*conv(x,h,'full');
Mentre il problema del segnale a gradino è invece leggermente più rognoso. In particolare, nel thread linkato sono stati molto utili gli interventi di DirtyDeeds e dimaios, i quali mi hanno ricordato degli effetti di bordo.
Illuminante fu l'intervento di DirtyDeeds al messaggio 25:
[RISPOSTA DI DD]
Tu vuoi rappresentare il risultato della convoluzione in un certo intervallo di tempo, diciamo . Per poter calcolare la convoluzione in quell'intervallo di tempo hai bisogno di conoscere le due funzioni
e
in altri due intervalli di tempo, possibilmente infiniti. Poiché in Matlab non puoi memorizzare vettori infiniti, devi decidere dove fermarti: se memorizzi una porzione troppo stretta di
e
, il risultato della convoluzione non sarà corretto nell'intervallo
e osserverai effetti di "bordo".
[/RISPOSTA DI DD]
La soluzione quindi è definire la funzione per un intervallo di tempo sufficientemente maggiore rispetto a
, e far si che la lunghezza del vettore del risultato della convoluzione sia equivalente sempre a quella di
. Ecco un esempio di codice con cui si ottiene un risultato corretto:
fs = 100; t = -3:1/fs:6; th = -12:1/fs:12; x = exp(2*t).*heaviside(-1*t); h = heaviside(th - 3) - heaviside(th - 12); y = 1/(fs) * conv2(x, h, 'same'); plot(t,x,'r');hold on; plot(th,h,'b');hold on;xlim([-3,6]); plot(t,y,'g');grid on; ylim([-0.5,1.5]);
Conclusione
Si conclude cosi questa piccola raccolta di esercizi.
All'inizio non avevo intenzione di scrivere un articolo, poi tra un caffé e l'altro, ho raccolto gli esercizi svolti in questi giorni, 2 o tre me li sono inventati sul momento mentre scrivevo, mi sono ricordato di un esercizio svolto nel forum, del thread sugli effetti di bordo ... e cosi ne è uscito questo piccolo articolo.
Nel suo piccolo, come sempre, si spera possa essere utile a qualcuno.
Simo