Chapitre 5

chapitre 5
La Transformée de Fourier discrète

Dans les chapitres 3 et 4, nous avons étudié les représentations en domaine de transformation
de signaux discrets. La transformée de Fourier en temps discret a fourni la représentation du
domaine fréquentiel (ω) pour des séquences absolument sommatives. La transformée en z
fournit une représentation généralisée du domaine fréquentiel (z) pour des séquences
arbitraires. Ces transformations ont deux caractéristiques en commun.
Tout d'abord, les transformées sont définies pour les séquences de longueur infinie.
Deuxièmement, et c'est le plus important, ce sont des fonctions de variables continues (ω ou
z). Du point de vue du calcul numérique (ou du point de vue de MATLAB), ces deux
caractéristiques sont gênantes car il faut évaluer les sommes infinie à des fréquences infinie
sans justification. Pour utiliser MATLAB, il faut tronquer des séquences et ensuite évaluer les
expressions en de nombreux points. C'est ce que nous avons fait dans de nombreux exemples
dans les deux chapitres précédents. Les évaluations étaient évidemment des approximations
des calculs exacts. En d'autres termes, la transformée de Fourier en temps discret et la
transformée z ne sont pas des transformations calculables numériquement.
C'est pourquoi nous portons notre attention sur une transformée numériquement calculable.
On l'obtient en échantillonnant la transformée de Fourier en temps discret dans le domaine
fréquentiel (ou la transformée en z sur le cercle unitaire). Nous développons cette
transformation en analysant d'abord des séquences périodiques. D'après l'analyse de Fourier,
nous savons qu'une fonction périodique (ou séquence) peut toujours être représentée par une
combinaison linéaire d'exponentielles complexes harmoniquement liées (qui est une forme
d'échantillonnage). Cela nous donne la représentation des séries de Fourier discrètes (DFS).
Puisque l'échantillonnage se fait dans le domaine des fréquences, nous étudions les effets de
l'échantillonnage dans le domaine temporel et la question de la reconstruction dans le
domaine z. Nous étendons ensuite le DFS aux séquences de durée finite, ce qui conduit à une
nouvelle transformation, appelée transformée de Fourier discrète (DFT).
La DFT évite les deux problèmes mentionnés et est une transformation numériquement
calculable qui convient à la mise en œuvre informatique. Nous étudions en détail ses
propriétés et son utilisation dans l'analyse des systèmes. Le calcul numérique de la DFT pour
les séquences longues prend un temps prohibitif.
Par conséquent, plusieurs algorithmes ont été développés pour calculer la DFT. Ces
algorithmes sont collectivement appelés transformée de Fourier rapide (ou FFT). Nous
étudierons deux de ces algorithmes en détail.
I. les séries de Fourier discretes

x(n) , satisfaisant à la condition
Au chapitre 2, nous avons défini la séquence périodique par ɶ
suivante
ɶx(n) = xɶ(n + kN ), ∀n, k (5.1)
où N est la période fondamentale de la séquence. De l'analyse de Fourier nous savons que les
fonctions périodiques peuvent être synthétisées comme une combinaison linéaire
d'exponentielles complexes dont les fréquences sont des multiples (ou harmoniques) de la
fréquence fondamentale (qui dans notre cas est 2π/N). D'après la périodicité dans le domaine
des fréquences de la transformée de Fourier en temps discret, nous concluons qu'il existe un
certain nombre d'harmoniques; les fréquences sont {(2π N ) k , k = 0,1,…, N −1 .Par }
x(n) peut être exprimée comme suit
conséquent, une séquence périodique ɶ
2π
1 N −1 ɶ j kn
ɶx(n) = ∑
N k =0
X ( k ) e N
, n = 0, ±1,…, (5.2)
Où { Xɶ (k ), k = 0, ±1,…,} sont appelées la série discrète de Fourier coefficients, qui sont

données par
N −1 2π
− j kn
Xɶ (k ) = ∑ xɶ(n)e N , k = 0, ±1,…, (5.3)
n =0
Notons que Xɶ ( k ) est elle-même une séquence périodique (à valeur complexe) dont la
période fondamentale est égale à N, c'est-à-dire,
Xɶ (k + N ) = Xɶ (k ) (5.4)
La paire d'équations (5.3) et (5.2), prises ensemble, est appelée la représentation en série de
∆ 2π
−j
Fourier discrète des séquences périodiques. En utlisant WN = e N
pour désigner le terme
exponentiel complexe, nous exprimons (5.3) et (5.2) comme suit
∆ N −1
Xɶ (k ) = DFS[ ɶx(n) ] = ∑ ɶx(n)WNnk : Analyse ou équation DFS
k =0
(5.5)
∆ 1 N −1
ɶx(n) = IDFS  Xɶ (k ) = ∑ Xɶ (k )WN−nk : Synthèse ou un inverse d'equations DFS
  N
k =0
EXEMPLE 5.1 Trouver la représentation DFS de la séquence périodique
ɶx ( n) = {…,0,1, 2,3,0,1, 2,3,0,1, 2,3,…,}

↑
2π
−j
Solution La période fondamentale de cette séquence est N = 4. D'où W4 = e 4
=−j
Alors
3
Xɶ (k ) = ∑ ɶx(n)W4nk , k = 0, ±1, ±2,…
n=0
Donc
3 3
Xɶ (0) = ∑ ɶx(n)W40 n = ∑ ɶx(n) = ɶx(0) + ɶx(1) + ɶx(2) + ɶx(3) = 6
0 0
De même,
3 3
Xɶ (1) = ∑ ɶx(n)W4n = ∑ ɶx(n) (− j ) = (−2 + 2 j )
n
0 0
3 3
2n
Xɶ (2) = ∑ xɶ(n)W42 n = ∑ xɶ(n) (− j ) = 2
0 0
3 3
3n
Xɶ (3) = ∑ xɶ(n)W43n = ∑ xɶ(n) (− j ) = (−2 − 2 j )
0 0
5.1.1 IMPLEMENTATION MATLAB
Un examen attentif (5.5) révèle que la DFS est une représentation numériquement calculable.
Elle peut être mise en œuvre de plusieurs façons. Pour calculer chaque échantillon de Xɶ ( k ) ,
nous pouvons implémenter la sommation comme une boucle for--end.
Pour calculer tous les coefficients DFS on aurait besoin d'un autre une boucle for--end.
Il en résultera une implémentation de deux boucles for--end imbriquées. C'est clairement

inéfficace dans MATLAB. Une implémentation plus efficace dans MATLAB serait d'utiliser
une multiplication matrice-vecteur pour chacune des relations dans (5.5). Nous avons utilisé
cette approche plus tôt dans la mise en œuvre d'une approximation numérique de la
transformée de Fourier en temps discret. Soit Xɶ ɶ désignant les vecteurs colonnes
et X
x(n) et Xɶ (k ) , respectivement. Alors
correspondant aux périodes primaires des séquences ɶ
(5.5) est donné par
Xɶ = WN ɶx
1 ∗ɶ (5.6)
xɶ = WN X
N
Où la matrice WN est donnée par
n→
1 1 ⋯ 1 
 
∆
1 W1 ⋯ WN( N −1) 
 N
WN =  WNkn 
0≤k , n≤ N −1  = k  (5.6)
↓ ⋮ ⋮ ⋱ ⋮ 
 2 
1 WN( N −1) N −1
⋯ WN( ) 

La matrice WN est une matrice carrée appelée matrice DFS. La fonction MATLAB dfs
suivante implémente cette procédure.
function [Xk] = dfs(xn,N)

% Computes Discrete Fourier Series Coefficients
% ---------------------------------------------% [Xk] = dfs(xn,N)
%Xk= DFS coeff. array over 0 <= k <= N-1
%xn= One period of periodic signal over 0 <= n <= N-1
% N= Fundamental period of xn
%
n= [0:1:N-1]; % row vector for n
k= [0:1:N-1]; % row vecor for k
WN = exp(-j*2*pi/N); % Wn factor
nk = n’*k; % creates a N by N matrix of nk values
WNnk = WN .^ nk; % DFS matrix
Xk = xn * WNnk; % row vector for DFS coefficients
Le DFS de l'exemple 5.1 peut être calculé à l'aide de MATLAB comme
>> xn = [0,1,2,3]; N = 4; Xk = dfs(xn,N)

Xk =
6.0000 -2.0000 + 2.0000i -2.0000 - 0.0000i -2.0000 - 2.0000i
La fonction idfs suivante implémente l'équation de synthèse.
function [xn] = idfs(Xk,N)

% Computes Inverse Discrete Fourier Series
% ----------------------------------------% [xn] = idfs(Xk,N)
%xn= One period of periodic signal over 0 <= n <= N-1
%Xk= DFS coeff. array over 0 <= k <= N-1
% N= Fundamental period of Xk
%
WNnk = WN .^ (-nk); % IDFS matrix
xn = (Xk * WNnk)/N; % row vector for IDFS values
Attention: Ces fonctions sont des approches efficaces de mise en œuvre (5.5) dans MATLAB.
Elles ne sont pas calculées éfficacement, en particulier pour le grand N. Nous traiterons de ce
problème plus loin dans ce chapitre.
EXEMPLE 5.2 La séquence apériodique des "ondes carrées" est donnée par
 1, mN ≤ n ≤ mN + L −1
xɶ(n) =  ; m = 0, ±1, ±2,…
0, mN + L ≤ n ≤ (m + 1) N −1
où N est la période fondamentale et L/N est le rapport cyclique.
a. Déterminer une expression pour Xɶ ( k ) en termes de L et N .
b. Tracer l’amplitude Xɶ ( k ) pour L =5, N = 20; L =5, N = 40; L =5, N = 60; et L =7, N =
60.
c. Commenter the résultats.
Solution Un tracé de cette séquence pour L = 5 et N = 20 est illustré à la figure 5.1.
FIGURE 5.1 Periodic square wave sequence

a. En appliquant l'équation d'analyse (5.3),
n
N −1 −j
2π L−1 −j
2π L−1 − j 2π k 
= ∑ e N 
kn kn
Xɶ (k ) = ∑ ɶx(n)e N
= ∑ xɶ(n)e N
k =0 n=0 n =0 

 L, k = 0, ± N , ±2 N ,…

= 1− e − j 2 π Lk N
 , par tout ailleurs
 1 − e− j 2 πk N
La dernière étape découle de la somme de la formule des termes géométriques (2.7) du

chapitre 2. La dernière expression peut être simplifiée pour
1− e− j 2 π Lk N e− jπ Lk N e jπ Lk N − e− jπ Lk N
= − jπ k N
1− e− j 2 πk N e e jπk N − e− jπk N
− jπ L−1 k N sin (π kL N )
=e ( )
sin (πk N )
or l’amplitude de Xɶ (k ) est donnée par
 L, k = 0, ± N , ±2 N ,…

Xɶ (k ) =  sin (πkL N )
 , par tout ailleurs
 sin (πk N )
b. Le script MATLAB pour L = 5 et N = 20:
>>L=5;N=20;k= [-N/2:N/2]; % Sq wave parameters

>> xn = [ones(1,L), zeros(1,N-L)]; % Sq wave x(n)
>> Xk = dfs(xn,N); % DFS
>> magXk = abs([Xk(N/2+1:N) Xk(1:N/2+1)]); % DFS magnitude
>> subplot(2,2,1); stem(k,magXk); axis([-N/2,N/2,-0.5,5.5])
>> xlabel(’k’); ylabel(’Xtilde(k)’)
>> title(’DFS of SQ. wave: L=5, N=20’)
Les graphiques pour ce cas et tous les autres cas sont illustrés à la figure 5.2. Notez que
puisque Xɶ ( k ) est périodique, les tracés sont affichés de - N/2 à N/2.
c. Plusieurs observations intéressantes peuvent être faites à partir des graphiques de la figure
5.2. Les enveloppes des coefficients DFS des ondes carrées ressemblent à des fonctions
"sinc".
L'amplitude à k = 0 est égale à L, tandis que les zéros des fonctions sont à des multiples de
N/L, qui est l'inverse du rapport cyclique. Nous étudierons ces fonctions plus loin dans ce
chapitre.
5.1.2 Relation avec la transformée en Z
Soit x ( n) une séquence de durée finie de durée N telle que
nonzero, 0 ≤ n ≤ N −1
x (n) =  (5.8)
 0, ailleurs
FIGURE 5.2 Les tracés DFS d'une onde carrée périodique pour différents L et N
Alors nous pouvons calculer sa transformée en z :

N −1
X ( z ) = ∑ x ( n) z −n (5.9)
n= 0
Maintenant, nous construisons une séquence périodique xɶ( n) en répétant périodiquement

x ( n) avec la période N, c'est-à-dire
 xɶ(n), 0 ≤ n ≤ N −1
x (n) =  (5.10)
La DFS de xɶ( n) est donnée par
−n
N −1 −j
2π
kn N −1  j 2π k 
Xɶ (k ) = ∑ xɶ(n)e N
= ∑ x ( n)  e N  (5.11)
 
n =0 n =0  
En le comparant avec (5.9), nous avons
Xɶ (k ) = X ( z ) z=e j 2Nπ k (5.12)

ce qui signifie que le DFS Xɶ (k ) représente N échantillons uniformément espacés de la
transformée en z, X ( z ) autour du cercle unitaire.
5.1.3 RELATION AVEC LE DTFT
Puisque x ( n) dans (5.8) est de durée finie de la longueur N, il est aussi absolument
sommable. Son DTFT existe donc et est donné par
N −1 N −1
X (e ) = ∑ x ( n )e
jω − jω n
= ∑ ɶx(n)e− jωn (5.13)
n =0 n=0
En comparant (5.13) avec (5.11), nous avons
Xɶ (k ) = X (e jω ) 2π (5.14)
ω= k
N
Soit
∆ 2π ∆ 2π
ω1 = et ωk = k = k ω1
N N
Alors les DFS X ( k ) = X (e jωk ) = X (e jω1 ) ,ce qui signifie que le DFS est obtenu en
2π
échantillonnant uniformément le DTFT à intervalles réguliers ω1 = . De (5.12) et (5.14),
N
nous observons que la représentation DFS nous donne un mécanisme d'échantillonnage dans
le domaine fréquentiel qui, en principe, est similaire à l'échantillonnage dans le domaine
2π
temporel. L'intervalle ω1 = est l'intervalle d'échantillonnage dans le domaine fréquentiel.
N
On l'appelle aussi résolution en fréquence parce qu'elle nous indique à quelle distance se
trouvent les échantillons (ou mesures) de fréquence.
EXEMPLE 5.3 {
Soit x(n) = 0,1, 2,3 .
↑
}
a. Calculez sa transformée de Fourier en temps discret X (e jω ) .
2π
b. Echantillon X (e jω ) à k ω1 = k , k =0, 1, 2, 3 et montrer qu'il est égal à Xɶ (k ) dans
4
l’exemple 5.1.
Solution La séquence x ( n) n'est pas périodique mais de durée finie.
a. La transformée de Fourier en temps discret est donnée par

∞
X (e ) =
jω
∑ x(n)e− jωn = e− jω + 2e− j 2 ω + 3e− j 3ω
n=−∞
2π
b. Échantillonnage à k ω1 = k , k =0, 1, 2, 3, nous obtenons
4
X (e j 0 ) = 1 + 2 + 3 = 6 = Xɶ (0)
X (e j 2 π 4 ) = e− j 2 π 4 + 2e− j 4 π 4 + 3e− j 6 π 4 = −2 + 2 j = Xɶ (1)
X (e j 4 π 4 ) = e− j 4 π 4 + 2e− j8π 4 + 3e− j12 π 4 = 2 = Xɶ (2)
X (e j 6 π 4 ) = e− j 6 π 4 + 2e− j12 π 4 + 3e− j18π 4 = −2 − 2 j = Xɶ (3)
comme attendue.
II. ÉCHANTILLONNAGE ET RECONSTRUCTION DANS LE

DOMAINE Z
Soit x ( n) une séquence arbitraire absolument sommable, qui peut être d'une durée infinie. Sa
transformée en z est donnée par
∞
X ( z) = ∑
n=−∞
x ( m) z −m
et nous supposons que le ROC de X ( z ) inclut le cercle unité. Nous échantillonnons X ( z )

sur le cercle unitaire à des points équidistants séparés en angle par ω1 = 2π N et l'appelons
une séquence DFS,
∆
Xɶ (k ) = X ( z ) z=e j 2Nπ k , k = 0, ±1, ±2,…
∞ −j
2π
km ∞ (5.15)
= ∑
m=−∞
x ( m)e N
= ∑ x(m)W
n=−∞
km
N
qui est périodique avec la période N . Enfin, nous calculons la IDFS de Xɶ (k ) ,
ɶx( n) = IDFS  Xɶ (k )

 
qui est également périodique de période N. De toute évidence, il doit y avoir une relation
entre l'arbitraire x ( n) et le périodique xɶ(n) . C'est une question importante. Pour calculer
numériquement la transformée inverse DTFT ou la transformée inverse en Z, nous devons
traiter un nombre finite d'échantillons de X ( z ) autour du cercle unitaire. Nous devons donc
connaître l’effet d'un tel échantillonnage sur la séquence du domaine temporel. Cette relation
est facile à obtenir.
N −1
1
xɶ(n) =
N
∑ Xɶ (k )W
k =0
− kn
N [de 5.2]
1 N −1  ∞ 
= ∑  ∑ x(m)WNkm WN−kn [de 5.15]
N k =0 m=−∞ 
or
N −1
∞
1 − k (n−m)
∞ ∞
ɶx(n) = ∑
m=−∞
x ( m)
N
∑W
k =0
N = ∑
m=−∞
x(m) ∑ δ (n − m − rN )
r =−∞
 1, n−m= rN
=
0, ailleurs
∞ ∞
= ∑ ∑
r =−∞ m=−∞
x (m)δ (n − m − rN )
Or
∞
ɶx(n)= ∑ x (n − rN ) = ⋯ + x(n + N ) + x(n) + x(n − N ) + ⋯ (5.16)
r =−∞
ce qui signifie que lorsque nous échantillonnons X ( z ) sur le cercle unitaire, nous obtenons
une séquence périodique dans le domaine temporel. Cette séquence est une combinaison
linéaire de l'original x ( n) et de ses répliques infinies, chacune décalée de multiples de ±N .
Ceci est illustré dans l'exemple 5.5. De (5.16), nous observons que si x(n) = 0 pour n < 0 et
n ≥ N , il n'y aura aucun chevauchement ou aliasing dans le domaine temporel. Par
conséquent, nous devrions être en mesure de reconnaître et de récupérer x ( n) à partir de
xɶ(n) , c'est-à-dire,
x(n) = ɶx(n) pour 0 ≤ n ≤ (N − 1)
or
 xɶ(n), 0 ≤ n ≤ ( N − 1)
x(n) = ɶx(n)ℜ N (n) = 
où ℜ N ( n) est appelée une fenêtre rectangulaire de longueur N . Nous avons donc le

théorème suivant.
THEOREM 1 Échantillonnage de fréquence
Si x ( n) est limité dans le temps (c'est-à-dire de durée finie) à [0, N - 1], alors N échantillons
de X ( z ) sur le cercle unitaire déterminent X ( z ) pour tous z
EXEMPLE 5.4 { }
soit x1 ( n ) = 6,5, 4,3, 2,1 . Sa DTFT X 1 (e jω ) est échantiollonnée à
↑
2π
ωk = k k = 0, ±1, ±2, ±3,…
4
Pour obtenir une DFS de la sequence Xɶ 2 (k ) . Déterminer la sequence Xɶ 2 (n) , qui est la DFS
inverse de Xɶ 2 (k ) .
Solution Sans calculer le DTFT, le DFS, ou le DFS inverse, nous pouvons évaluer Xɶ 2 (n)
en utilisant la formule d'aliasing (5.16).
∞
ɶx2 (n)= ∑ x1 (n − 4r )
r =−∞
Ainsi x (4) est replié dans x (0) , et x (5) est replié dans x(1) . Par conséquent
{
ɶx2 ( n ) = …,8, 6, 4,3,8, 6, 4,3,8, 6, 4,3,… ,
↑
}
n
EXEMPLE 5.5 Soit x ( n) = (0.7 ) u (n) . Échantillonner sa transformation z sur le cercle
unitaire avec N = 5, 10, 20, 50 et étudier son effet dans le domaine
temporel.
Solution D'après le tableau 4.1, la transformée en z de x ( n) est
1 z
X ( z) = −1
= , z ≻ 0.7
1− 0.7 z z − 0.7
Nous pouvons maintenant utiliser MATLAB pour implémenter l'opération d'échantillonnage
Xɶ (k ) = X ( z ) z=e j 2Nπ k , k = 0, ±1, ±2,…
et le calcul inverse de DFS pour déterminer la séquence de domaine temporel correspondante.

Le script MATLAB pour N = 5 est le suivant.
>> N = 5; k = 0:1:N-1; % sample index

>> wk = 2*pi*k/N; zk = exp(j*wk); % samples of z
>> Xk = (zk)./(zk-0.7); % DFS as samples of X(z)
>> xn = real(idfs(Xk,N)); % IDFS
>> xtilde = xn’* ones(1,8); xtilde = (xtilde(:))’; % Periodic sequence
>> subplot(2,2,1); stem(0:39,xtilde);axis([0,40,-0.1,1.5])
>> xlabel(’n’); ylabel(’xtilde(n)’); title(’N=5’)
Les graphiques de la figure 5.3 montrent clairement l'aliasing dans le domaine temporel, en
particulier pour N=5 et N=10. Pour des valeurs élevées de N, l'extrémité arrière de x(n) est
suffisamment petite pour qu'il en résulte une quantité appréciable d'aliasing dans la pratique.
Une telle information est utile pour tronquer efficacement une séquence de durée infinie avant
de prendre sa transformation.
FIGURE 5.3 Tracés de l’exemple 5.5
5.2.1 LA FORMULE DE RECONSTRUCTION DE LA TRANSFORMEE EN Z
Soit x ( n) de temps limité à [0,N − 1]. Alors du Théorème 1 nous devrions être capables de
ɶ (k ) . Ceci est donné par
récupérer la transformée en z X ( z ) en utilisant ses échantillons X
X ( z ) = Ζ  x (n) = Ζ  xɶ(n)ℜ N (n)

= Ζ[ IDFS{ xɶ(k ) }ℜ N (n)]
Samples of X ( z )
Cette approche aboutit à la formule de reconstruction du domaine z.

N −1 N −1
X ( z ) = ∑ x (n) z −n
=∑ xɶ(n) z −n
0 0
 1
N −1 N −1 
= ∑  ∑ Xɶ (k )WN−kn z −n
0 
 N 0 
1 N −1  N −1 
= ∑ Xɶ (k )∑ WN−kn z −n 
N k =0  0 
1 N −1 ɶ  N −1 −k −1 n 
= ∑ X (k )∑
N k =0
(WN z ) 
 0 
1 N −1 ɶ 1−WN−kN z − N 
= ∑ X (k ) 
N k =0  1−WN−k z −1 
Pusque WN
−kN
= 1 , Nous avons
1− z − N N −1
Xɶ (k )
X ( z) =
N
∑
k =0 1−WN z
−k −1
(5.17)
5.2.2 LA FORMULE D'INTERPOLATION DTFT
La formule de reconstruction (5.17) peut être spécialisée pour la transformée de Fourier en

temps discret en l'évaluant sur le cercle unitaire z = eiω . Alors
1− e− jω N N −1
Xɶ (k )
X (e ) =jω
N
∑
k =0 1 − e
j 2 π k N − jω
e
N −1
1− e− jω N
= ∑ Xɶ (k )
k =0 N {1− e j 2 πk N e− jω }
Considérons
− j ω −2 π k N
1− e− jω N 1− e ( )N
=
N {1 − e j 2 πk N e− jω } N 1− e− j(ω−2 πk N )
{ }
   
−j
N
( ω −2 π k N )  sin  N (ω − 2πk N ) 
2
e   2  
= 
1
− j ( ω −2 π k N )  1  
e 2
 N sin  (ω − 2πk N ) 
  2  
Soit
 ω N 
sin 
∆  2  − jω N2−1
Φ (ω )= e : une fonction d'interpolation (5.18)
 ω 
N sin  
2
Alors
N −1
 2πk 
X (e jω ) = ∑ Xɶ (k )Φω −  (5.19)
k =0
 N 
Ceci est la formule d'interpolation DTFT pour reconstruire X (e jω ) à partir de ses

échantillons Xɶ (k ) . Puisque, nous avons X (e j 2 πk N ) = Xɶ (k ) , ce qui signifie que
l'interpolation est exacte aux points d'échantillonnage. Rappelons la formule d'interpolation
dans le domaine temporel (3.33) pour les signaux analogiques :
∞
xa (t ) = ∑ x (n)sin c  F (t − nT )
n=−∞
s s (5.20)
La formule d'interpolation DTFT (5.19) est similaire.
Cependant, il y a quelques differences. Premièrement, la formule dans le domaine temporel

(5.20) reconstruit un signal analogique non périodique arbitraire, tandis que la formule dans le
domaine fréquentiel (5.19) nous donne une forme d'onde périodique. Deuxièmement, en
sin ( Nx )
(5.19), nous utilisons une fonction d'interpolation au lieu de notre fonction plus
N sin x
sin x
familière (sinc). La fonction Φ(ω ) est une fonction périodique et est donc connue sous
x
le nom de fonction sinc-périodique. Elle est également connue sous le nom de fonction de
Dirichlet. C'est la fonction que nous avons observée dans l'exemple 5.2.
La formule d'interpolation (5.19) subit le même sort que (5.20) en essayant de la mettre en
pratique. Il faut générer plusieurs fonctions d'interpolation (5.18) et effectuer leurs
combinaisons linéaires pour obtenir la transformée de Fourier en temps discret X (e jω ) à
partir de ses échantillons calculés Xɶ (k ) . De plus, dans MATLAB, nous devons évaluer
(5.19) sur une grille plus fine sur 0 ≤ ω ≤ 2π . Il s'agit clairement d'une approche inefficace.
Une autre approche consiste à utiliser la fonction d'interpolation par spline cubique comme
approximation de (5.19). C'est ce que nous avons fait pour mettre en œuvre (5.20) au chapitre
3.
Cependant, il existe une approche alternative et efficace basée sur la DFT, que nous
étudierons dans la section suivante.
III. LA TRANSFORMÉE DE FOURIER DISCRÈTE
La série de Fourier discrète fournit un mécanisme de calcul numérique de la transformée de
Fourier en temps discret. Cela nous a également alerté d'un problème potentiel d'aliasing dans
le domaine temporel. Selon les mathématiques, l'échantillonnage de la transformée de Fourier
en temps discret donne une séquence périodique xɶ(n) . Mais la plupart des signaux en
pratique ne sont pas périodiques. Ils sont susceptibles d'être d'une durée finie. Comment
pouvons-nous développer une représentation de Fourier numériquement calculable pour de
tels signaux ? Théoriquement, nous pouvons résoudre ce problème en définissant un signal
périodique dont la forme primaire est celle du signal de durée finie et en utilisant ensuite le
DFS sur ce signal périodique. Pratiquement, nous definisons une nouvelle transformée
appelée la transformée de Fourier discrète (DFT), qui est la période primaire de la DFS. Ce
DFT est la transformée de Fourier numériquement calculable ultime pour les séquences
arbitraires de durée finie.
Tout d'abord, nous avons défini une séquence de durée finie qui a N échantillons sur
0 ≤ n ≤ N - 1 comme une séquence de N-points. Soit xɶ(n) un signal périodique de période N,
créé à l'aide de la séquence à N points x ( n) ; c'est-à-dire de (5.19)
∞
ɶx(n) = ∑ x (n − rN )
r =−∞
Il s'agit d'une représentation quelque peu lourde. En utilisant l'opération modulo-N sur
l'argument nous pouvons le simplifier en
xɶ(n) = x (n mod N ) (5.21)
Une façon simple d'interpréter cette opération est la suivante : si l'argument n est compris
entre 0 et N-1, alors laissez-le tel quel ; sinon ajoutez ou soustrayez des multiples de N à partir
de n jusqu'à ce que le résultat soit compris entre 0 et N-1. Notez bien que (5.21) n'est valable
que si la longueur de x ( n) est N ou moins. De plus, nous utilisons la notation pratique
suivante pour désigner l'opération modulo-N.
∆
x ((n))N = x(n mod N ) (5.22)
Alors les relations compactes entre x ( n) et xɶ(n) sont
ɶx(n) = x ((n)) N ( Extension périodique)

(5.23)
x(n) = ɶx (n)ℜ N (n) (Opération de la fenêtre)
La fonction rem(n,N) de MATLAB détermine le reste après avoir divisé n par N . Cette
fonction peut être utilisée pour implémenter notre opération modulo-N lorsque n ≥ 0 .
Lorsque n < 0 , nous devons modifier le résultat pour obtenir des valeurs correctes. Ceci est
illustré ci-dessous dans la fonction m=mod(n,N).
function m = mod(n,N)
% Computes m = (n mod N) index
% ----------------------------
%m= mod(n,N)
m= rem(n,N); m = m+N; m = rem(m,N);
Dans cette fonction n peut être n'importe quel tableau entier, et le tableau m contient les
valeurs modulo-N correspondantes.
À partir du théorème d'échantillonnage en fréquence, nous concluons que N échantillons

équidistants de la transformée de Fourier en temps discret X (e jω ) de la séquence à N points
x ( n) peuvent reconstruire de façon unique X (e jω ) . Ces N échantillons autour du cercle
unitaire sont appelés les coefficients de la transformée de Fourier discrète. Soit
Xɶ (k ) = DFSxɶ(n) , qui est une séquence périodique (et donc de durée infinie). Son intervalle
primaire est alors la transformée de Fourier discrète, qui est de durée finie. Ces notions sont
explicitées dans les definitions suivantes. La transformée de Fourier discrète d'une séquence à
N points est donnée par
∆  Xɶ (k ), 0 ≤ k ≤ N-1 ɶ
X (k ) = DFT  x (n) =  = X ( k )ℜ N ( k )
or
N −1
X (k ) = ∑ x(n)WNnk , 0 ≤ k ≤ N -1 (5.24)
n=0
Notez que la DFT X (k ) est également d'une séquence à N points, c'est-à-dire 'il n’est pas
défini en dehors de 0 ≤ k ≤ N − 1 . De (5.23) Xɶ ( k ) = X ((k )) ; c'est-à-dire, en dehors de
N
l'intervalle 0 ≤ k ≤ N − 1 seul la DFS Xɶ (k ) est définie, qui est bien sûr l'extension périodique
de X (k ) . Enfin, X (k ) = Xɶ ( k )ℜ N (k ) signifie que la DFT X (k ) est l'intervalle primaire
de Xɶ (k ) .
La transformée de Fourier discrète inverse d'un DFT de point N X (k ) est donnée par
∆
x(n) = IDFT  X (k ) = xɶ(n)ℜ N (n)
Or
N −1
1
x ( n) =
N
∑ X (k )W
k =0
− nk
N , 0 ≤ k ≤ N -1 (5.25)
Une fois de plus x ( n) n'est pas défini en dehors de 0 ≤ n ≤ N -1 . L'extension de x ( n) en
dehors de cette plage est xɶ(n) .
Il ressort clairement des discussions en haut de cette section que la DFS est pratiquement
équivalent au DFT lorsque 0 ≤ n ≤ N -1 . Par conséquent, la mise en œuvre de la DFT peut se
faire de la même manière. Si x ( n) et X (k ) sont disposés comme vecteurs colonne x et X,
respectivement, alors de (5.24) et (5.25) nous avons
X = WN x
1 ∗ (5.26)
x= W X
N N
où WN est la matrice définie en (5.7) et sera maintenant appelée matrice DFT. Ainsi, les
fonctions MATLAB dfs et idfs antérieures peuvent être renommées comme fonctions dft et
idft pour implémenter les calculs de transformée de Fourier discretes.
function [Xk] = dft(xn,N)
% Computes Discrete Fourier Transform
% -----------------------------------%
[Xk] = dft(xn,N)
%Xk= DFT coeff. array over 0 <= k <= N-1
%xn= N-point finite-duration sequence
% N= Length of DFT
%
WNnk = WN .^ nk; % DFT matrix
Xk = xn * WNnk; % row vector for DFT coefficients
function [xn] = idft(Xk,N)
% Computes Inverse Discrete Transform
% -----------------------------------%
[xn] = idft(Xk,N)
%xn= N-point sequence over 0 <= n <= N-1
%Xk= DFT coeff. array over 0 <= k <= N-1
% N= length of DFT
%
WNnk = WN .^ (-nk); % IDFT matrix
xn = (Xk * WNnk)/N; % row vector for IDFT values
EXEMPLE 5.6 Soit x ( n) une sequence à 4-points.

1, 0 ≤ n ≤ 3
x(n) = 
0, ailleurs
a. Calculez la transformée de Fourier en temps discret X (e jω ) et tracez son amplitude et

sa phase.
b. Calculez la DFT à 4 points de x ( n) .
Solution
a. La transformée de Fourier à temps discret est donnée par

3
X (e ) = ∑ x ( n )e - j ω n = 1 + e - jω + e - j 2 ω + e - j 3 ω
jω
1− e− j 4 ω sin(2ω ) − j 3ω 2
= = e
1− e− jω sin( ω 2)
Par conséquent
sin(2ω )
X (e jω ) =
sin( ω 2)
Et
 3ω sin(2ω )
 − , when ≻0
 2 sin( ω 2)
∠X (e jω ) = 
 3ω sin(2ω )
− ± π, when ≺0
 2 sin( ω 2)
Les graphiques sont illustrés à la figure 5.4.
b. Désignons la DFT à 4 points par X 4 (k ) . Alors
3
X 4 (k ) = ∑ x(n)W4nk ; k =0, 1, 2, 3; W4 = e− j 2π 4 = − j
n=0
Ces calculs sont semblables à ceux de l'exemple 5.1. Nous pouvons également utiliser
MATLAB pour calculer ce DFT.
>> x = [1,1,1,1]; N = 4; X = dft(x,N);

>> magX = abs(X), phaX = angle(X)*180/pi
magX =
4.0000 0.0000 0.0000 0.0000
phaX =
0 -134.9810 -90.0000 -44.9979
Donc
X 4 (k ) = {4, 0, 0, 0}
↑
FIGURE 5.4 The DTFT plots in Example 5.6
Notez que lorsque l’amplitude de l'échantillon est nulle, l'angle correspondant n'est pas nul.
Ceci est dû à un algorithme particulier utilisé par MATLAB pour calculer la partie angulaire.
En général, ces angles doivent être ignorés. Le graphique des valeurs de DFT est illustré à la
figure 5.5. Le tracé de est X (e jω ) également représenté par une ligne en pointillés à des fins
de comparaison. D'après le graphique de la figure 5.5, nous observons que X 4 donne
correctement 4 échantillons de X (e jω ) , mais qu'il n'y a qu'un seul échantillon non nul. Est-ce
surprenant ? En regardant les 4 points de x ( n) , qui contiennent tous les 1's, on doit conclure
que son extension périodique est la suivante
ɶx(n) = 1, ∀n
qui est un signal constant (ou DC). C'est ce que prévoit la DFT X 4 (k ) , qui a un échantillon
non nul à k =0 (ou ω =0) et n'a aucune valeur à d'autres fréquences.
EXEMPLE 5.7 Comment pouvons-nous obtenir d'autres échantillons de la DTFT X (e jω ) ?
Solution Il est clair que nous devrions échantillonner à des fréquences denses (ou plus
fines), c'est-à-dire que nous devrions augmenter N. Supposons que nous
prenions deux fois le nombre de points, ou N = 8 au lieu de 4, ce que nous
pouvons obtenir en traitant x ( n) comme une séquence à 8 points en ajoutant 4
zéros.
x(n) = {1, 1, 1, 1,0,0,0,0}

↑
FIGURE 5.5 Les graphiques DFT de l'exemple 5.6
Il s'agit d'une opération très importante appelée opération de rembourrage zéro. Cette
opération est nécessaire dans la pratique pour obtenir un spectre dense de signaux comme
nous le verrons.
Soit X 8 (k ) un DFT à 8 points, alors
7
X 8 (k ) = ∑ x(n)W8nk ; k =0, 1, 2,…, 7; W8 = e− j 2π 4 = e− j π 4
n =0
Dans ce cas, la résolution en fréquence est ω1 = 2π 8 = π 4 .
MATLAB script:
>> x = [1,1,1,1, zeros(1,4)]; N = 8; X = dft(x,N);

>> magX = abs(X), phaX = angle(X)*180/pi
magX =
4.0000 2.6131 0.0000 1.0824 0.0000 1.0824 0.0000 2.6131
phaX =
0 -67.5000 -134.9810 -22.5000 -90.0000 22.5000 -44.9979 67.5000
Par conséquent
0 0 0 0
X 8 (k ) = {4, 2.6131e− j 67.5 , 0, 1.0824e− j 22. 5 , 0, 1.0824e− j 22. 5 , 0, 2.6131e− j 67. 5 }
↑
FIGURE 5.6 Les diagrammes DFT de l'exemple 5.7: N =8
qui est illustré à la figure 5.6. En continuant, si nous traitons x ( n) comme une séquence de 16
points en capitonnant 12 zéros, de telle sorte que
x(n) = {1, 1, 1, 1,0,0,0,0,0,0,0,0,0,0,0,0}

↑
− jπ 8
alors la résolution en fréquence est ω1 = 2π 16 = π 8 et W16 = e . On obtient donc un
spectre plus dense avec des échantillons spectraux séparés par π/ 8. L'esquisse de W16 ( k ) est
illustré à la figure 5.7.
Il devrait donc être clair que si nous obtenons beaucoup plus d'échantillons spectraux en
choisissant une valeur N élevée, les échantillons DFT résultants seront très proches les uns
des autres et nous obtiendrons des valeurs de placettes semblables à celles de la figure 5.4.
Cependant, les parcelles de tiges affichées seront denses. Dans cette situation, une meilleure
approche pour afficher les échantillons consiste soit à les montrer à l'aide de points, soit à
joindre les valeurs de l'échantillon à l'aide de la commande plot (c'est-à-dire en utilisant le
FOH étudié au chapitre 3). La figure 5.8 montre l'amplitude et la phase du DFT à 128 points
x128 (k ) obtenu en capitonnant 120 zéros. Le diagramme d’amplitude de DFT chevauche le
diagramme d’amplitude de DTFT montré en pointillés tandis que le diagramme de phase
montre un écart aux discontinuités dû aux valeurs finie de N, qui devrait être attendu.
Commentaires : Sur la base des deux derniers exemples, il y a plusieurs commentaires que
nous pouvons faire.
FIGURE 5.7 Les diagrammes DFT de l'exemple 5.7: N =16
1. Zero-padding est une opération dans laquelle plus de zéros sont ajoutés à la séquence
originale. La DFT longue qui en résulte fournit des échantillons étroitement espacés de la
transformée de Fourier en temps discret de la séquence originale.
Dans MATLAB, le zero-padding est implémenté à l'aide de la fonction zéros.
2. Dans l'exemple 5.6, tout ce dont nous avions besoin pour tracer avec précision la
transformée de Fourier en temps discret X (e jω ) de x ( n) était X 4 (k ) , La DFT4-point.
Ceci par ce que x ( n) n'avait que 4 échantillons différents de zéro, donc nous aurions pu
utiliser la formule d'interpolation (5.19) sur X 4 (k ) pour obtenir X (e jω ) . Cependant, dans
la pratique, il est plus facile d'obtenir X 8 (k ) et X 16 (k ) , et ainsi de suite, pour remplir les
valeurs de X (e jω ) plutôt que d'utiliser la formule d'interpolation. Cette approche peut être
rendue encore plus efficace en utilisant des algorithmes de transformée de Fourier rapide
pour calculer le DFT.
3. Le zero-padding nous donne un spectre de haute densité et fournit une meilleure version
affichée pour le tracé. Mais cela ne nous donne pas un spectre à haute résolution parce
qu'aucune nouvelle information n'est ajoutée au signal; seuls des zéros supplémentaires
sont ajoutés dans les données.
4. Pour obtenir un spectre à haute résolution, il faut obtenir plus de données de l'expérience ou
des observations (voir exemple 5.8 ci-dessous). Il existe également d'autres méthodes
avancées qui utilisent des informations secondaires supplémentaires ou des techniques non
linéaires.
FIGURE 5.8 Les courbes DFT de l'exemple 5.7 pour N = 128 sont représentées par des
courbes linéaires.
EXEMPLE 5.8 Pour illustrer la différence entre le spectre à haute densité et le spectre à
haute résolution, considérons la séquence suivante
x(n) = cos(0.48πn) + cos(0.52πn)
Nous voulons déterminer son spectre en fonction du nombre fini d'échantillons.

a. Déterminer et tracer la transformée de Fourier en temps discret de x ( n) , 0 ≤ n ≤ 10.
b. Déterminer et tracer la transformée de Fourier en temps discret de x ( n) , 0 ≤ n ≤ 100.
Solution
Nous pourrions déterminer analytiquement la transformée de Fourier en temps

discret dans chaque cas, mais MATLAB est un bon instrument pour étudier ces
problèmes.
a. Nous pouvons d'abord déterminer la DFT de 10 points de x ( n) pour obtenir une

estimation de sa transformée de Fourier en temps discret.
MATLAB Script:
>> n = [0:1:99]; x = cos(0.48*pi*n)+cos(0.52*pi*n);

>> n1 = [0:1:9] ;y1 = x(1:1:10);
>> subplot(2,1,1) ;stem(n1,y1); title(’signal x(n), 0 <= n <= 9’);xlabel(’n’)
>> Y1 = dft(y1,10); magY1 = abs(Y1(1:1:6));
>> k1 = 0:1:5 ;w1 = 2*pi/10*k1;
>> subplot(2,1,2);stem(w1/pi,magY1);title(’Samples of DTFT Magnitude’);
>> xlabel(’frequency in pi units’)
FIGURE 5.9 Signal et son spectre dans l'exemple 5.8a: N =10

Les graphiques de la figure 5.9 montrent qu'il n'y a pas assez d'échantillons pour tirer des
conclusions. Par conséquent, nous tamponnerons 90 zéros pour obtenir un spectre dense.
Comme expliqué dans l'exemple 5.7, ce spectre est représenté par la commande plot.
MATLAB Script:
>> n2 = [0:1:99]; y2 = [x(1:1:10) zeros(1,90)];

>> subplot(2,1,1) ;stem(n2,y2) ;title(’signal x(n), 0 <= n <=9+90 zeros’);
>> xlabel(’n’)
>> Y2 =dft(y2,100); magY2 = abs(Y2(1:1:51));
>> k2 = 0:1:50; w2 = 2*pi/100*k2;
>> subplot(2,1,2); plot(w3/pi,magY3); title(’DTFT Magnitude’);
Le graphique de la figure 5.10 montre maintenant que la séquence a une fréquence dominante
à ω =0.5π . Ce fait n'est pas corroboré par la séquence originale, qui a deux fréquences. Le
zero-padding a fourni une version plus lisse du spectre de la figure 5.9.
FIGURE 5.10 Signal et son spectre dans l'exemple 5.8a: N = 100
b. Pour obtenir de meilleures informations spectrales, nous allons prélever les 100
premiers échantillons de x ( n) et déterminer sa transformée de Fourier en temps
discret.
MATLAB Script:
>> subplot(2,1,1); stem(n,x);

>> title(’signal x(n), 0 <= n <= 99’); xlabel(’n’)
>> X = dft(x,100); magX = abs(X(1:1:51));
>> k = 0:1:50; w = 2*pi/100*k;
>> subplot(2,1,2); plot(w/pi,magX); title(’DTFT Magnitude’);
Le diagramme de transformée de Fourier en temps discret de la figure 5.11 montre

clairement deux fréquences, qui sont très proches l'une de l'autre. Il s'agit du spectre à
haute résolution de. x ( n) . Notez que le fait d'ajouter plus de zéros à la séquence de
100 points donnera un rendu plus lisse du spectre à la figure 5.11, mais ne révélera
aucune nouvelle information. Nous encourageons les lecteurs à le vérifier.
FIGURE 5.11 Signal et son spectre dans l'exemple 5.8b: N = 100
IV. PROPRIÉTÉS DE LA TRANSFORMÉE DE FOURIER DISCRÈTE

Les propriétés du DFT sont dérivées de celles du DFS parce que, mathématiquement, DFS est
la représentation valable. Nous discutons de plusieurs propriétés utiles, qui sont données sans
preuve. Ces propriétés s'appliquent également au DFS avec les modifications nécessaires. Soit
X (k ) un DFT N -point de la séquence x ( n) . Sauf indication contraire, les DFTs de N- point
seront utilisés dans ces propriétés.
1. Linearité: La DFT est une transformation linéaire
DFT  ax1 (n) + bx2 (n) = a DFT  x1 (n) + b DFT  x2 (n)

Note : Si x1 ( n) et x2 (n) ont des durées differentes,-c'est-à-dire ils sont respectivement
de séquences N1 -point et N 2 -point-, alors choisissez N3 = max ( N1 , N 2 ) et procédez en
prenant des DFTs de N3 -point.
2. Pliage circulaire: Si une séquence à N points est repliée, le résultat x(−n) ne serait pas
une séquence à N points, et il ne serait pas possible de calculer sa DFT. Nous utilisons
donc l'opération modulo-N sur l'argument (−n) et définissons le pliage par
 x (0), n=0
x ((−n))N =  (5.26)
 x ( N − n), 1 ≤ n ≤ N-1

C'est ce qu'on appelle un pliage circulaire. Pour le visualiser, imaginez que la séquence
x ( n) est enroulée autour d'un cercle dans le sens inverse des aiguilles d'une montre de
sorte que les indices n = 0 et n = N se chevauchent. On peut alors le voir x ((−n))N
comme un enroulement dans le sens des aiguilles d'une montre de x ( n) autour du cercle,
d'où le nom de pliage circulaire. Dans MATLAB, le pliage circulaire peut être obtenu par
x = x ( mod ( − n, N ) + 1) . Notez que les arguments dans MATLAB commencent par 1. la
DFT d'un pliage circulaire est donné par
 X (0), k=0
DFT  x ((−n))N  = X ((−k ))N =  (5.26)
 X ( N − k ), 1 ≤ k ≤ N-1

n
EXEMPLE 5.9 Soit x ( n) = 10 (0.8) , 0 ≤ n ≤ 10
a. Déterminer et tracer x ((−n))11 .

b. Vérifier la propriété de pliage circulaire.
Solution Le script MATLAB:

>> n = 0:100; x = 10*(0.8) .^ n; y = x(mod(-n,11)+1);
>> subplot(2,1,1); stem(n,x); title(’Original sequence’)
>> xlabel(’n’); ylabel(’x(n)’);
>> subplot(2,1,2); stem(n,y); title(’Circularly folded sequence’)
>> xlabel(’n’); ylabel(’x(-n mod 10)’);
Les graphiques de la figure 5.12 montrent le effect de pliage circulaire.
b. Le script MATLAB:
>> X = dft(x,11); Y = dft(y,11);

>> subplot(2,2,1); stem(n,real(X));
>> title(’Real{DFT[x(n)]}’); xlabel(’k’);
>> subplot(2,2,2); stem(n,imag(X));
>> title(’Imag{DFT[x(n)]}’); xlabel(’k’);
>> subplot(2,2,3); stem(n,real(Y));
>> title(’Real{DFT[x((-n))11]}’); xlabel(’k’);
>> subplot(2,2,4); stem(n,imag(Y));
>> title(’Imag{DFT[x((-n))11]}’); xlabel(’k’);
Les graphiques de la figure 5.13 permettent de vérifier la propriété.
FIGURE 5.12 Pliage circulaire dans l'exemple 5.9a
FIGURE 5.13 Pliage circulaire dans l'exemple 5.9b

3. Conjugaison : Comme pour la propriété ci-dessus, nous devons introduire le pliage
circulaire dans le domaine des fréquences.
DFT  x∗ (n) = X ∗ ((−k ))N (5.30)
x (n)
4. Propriétés de symétrie pour les séquences réelles : Soit une séquence de N points à
valeur réelle. Alors x(n) = x (n) . En utilisant (5.30)

∗
X (k ) = X ∗ ((−k ))N (5.31)
Cette symétrie est appelée symétrie conjuguée circulaire. Cela implique en outre que
Re  X (k ) = Re  X ((−k ))N  =⇒ Séquence circulaire pair
Im  X ( k ) = − Im  X (( N − k ))N  =⇒ Séquence circulaire impaire (5.32)
X (k ) = X ((−k ))N =⇒ Séquence circulaire pair
∠X (k ) = −∠X ((−k ))N =⇒ Séquence circulaire impaire
Commentaires:
1. Observer les grandeurs et les angles des différents DFT dans les exemples 5.6 et 5.7. Ils
satisfont aux symétries circulaires ci-dessus. Ces symétries sont différentes des symétries
paires et impaires habituelles. Pour visualiser ceci, imaginez que les échantillons DFT sont
disposés autour d'un cercle de sorte que les indices k = 0 et k = N se chevauchent ; alors les
échantillons seront symétriques par rapport à k = 0, ce qui justifie le nom, symétrie circulaire.
2. La symétrie correspondante pour les coefficients de la DFS est appelée symétrie conjuguée
périodique.
3. Puisque ces DFTs ont une symétrie, il faut calculer X ( k ) seulement pour
N
k = 0,1,…, ; N pair
2
Or pour
N −1
k = 0,1,…, ; N impair
2
Il en résulte une économie d'environ 50 % en termes de calcul et de stockage.
4. De (5.30)
X (0) = X ∗ ((−0))N = X ∗ (0)

ce qui signifie que le coefficient DFT à k = 0 doit être un nombre réel. Mais k = 0 signifie que
la fréquence ωk = k ω1 = 0 , qui est la fréquence continue. Par conséquent, le coefficient DC
pour une valeur réelle x ( n) doit être un nombre réel. De plus, si Nest pair, alors N/ 2 est aussi
un entier.
Alor de (5.32)
X ( N 2) = X ∗ ((− N 2))N = X ∗ ( N 2)
ce qui signifie que même la composante k = N/ 2 est également évaluée en valeur réelle.
Cette composante est appelée la composante de Nyquist puisque k = N/ 2 signifie que la

fréquence ω N 2 = ( N 2)(2π N ) = π , qui est la fréquence numérique de Nyquist.
Les signaux à valeur réelle peuvent également être décomposés respectivement en leurs
composantes paires xe (n) et impaires x0 (n) comme nous l'avons vu au chapitre 2.
Cependant, ces composantes ne sont pas des séquences à N points et nous ne pouvons donc
pas prendre leurs DFT à N points. C'est pourquoi nous avons mis sur le site define un nouvel
ensemble de composants utilisant le pliage circulaire dont il a été question plus haut. Ces
composantes sont appelées composantes paires circulaires et composantes impaires circulaires
définies par
 x (0) , n=0
∆ 1 

xec (n)=  x (n) + x ((−n))N  =  1
2    x (n) + x ( N − n) ,
   1 ≤ n ≤ N-1
2 (5.33)
 0, n=0
∆ 1
  
xoc (n)=  x (n) − x ((−n))N  =  1
2    x (n) − x ( N − n) ,
 1 ≤ n ≤ N-1
 2  
Alors
DFT  xec (n) = Re  X (k ) = Re  X (−k )N 

(5.34)
DFT  xoc (n) = Im  X (k ) = Im  X (−k )N 
Implication : Si x ( n) est réelle et circulaire pair, alors sa DFT est aussi réelle et circulaire
pair. Par conséquent, seuls les premiers coefficients 0 ≤ n ≤ N/ 2 sont nécessaires pour une
représentation complète. En utilisant (5.33), il est facile de développer une fonction pour
décomposer une séquence de N-points en ses composantes circulaire paire et circulaire
impaire. La fonction circevod suivante utilise la fonction mod donnée précédemment pour
implémenter le fonctionnement modulo-N.
function [xec, xoc] = circevod(x)

% signal decomposition into circular-even and circular-odd parts
% --------------------------------------------------------------
% [xec, xoc] = circevod(x)
%
if any(imag(x) ~= 0)
error(’x is not a real sequence’)
end
N= length(x); n = 0:(N-1);
xec = 0.5*(x + x(mod(-n,N)+1)); xoc = 0.5*(x - x(mod(-n,N)+1));
n
EXEMPLE 5.10 Soit x( n) = 10 (0.8) , 0 ≤ n ≤ 10 comme dans l'exemple 5.9.
aDécomposer et representer le tracé de xec ( n) et xoc ( n) de x ( n) .
b. Vérifier la propriété en (5.34).
Solution a. script MATLAB:
>> n = 0:10; x = 10*(0.8) .^ n;

>> [xec,xoc] = circevod(x);
>> subplot(2,1,1); stem(n,xec); title(’Circular-even component’)
>> xlabel(’n’); ylabel(’xec(n)’); axis([-0.5,10.5,-1,11])
>> subplot(2,1,2); stem(n,xoc); title(’Circular-odd component’)
>> xlabel(’n’); ylabel(’xoc(n)’); axis([-0.5,10.5,-4,4])
Les graphiques de la figure 5.14 illustrent les composantes à symétrie circulaire de l'équation
suivante x ( n) .
FIGURE 5.14 Composantes paires circulaires et impaires circulaires de la séquence dans

l'exemple 5.10a
FIGURE 5.15 Graphiques des propriétés de symétrie DFT dans l'exemple 5.10b
b. script MATLAB:
>> X = dft(x,11); Xec = dft(xec,11); Xoc = dft(xoc,11);

>> subplot(2,2,1); stem(n,real(X)); axis([-0.5,10.5,-5,50])
>> title(’Real{DFT[x(n)]}’); xlabel(’k’);
>> subplot(2,2,2); stem(n,imag(X)); axis([-0.5,10.5,-20,20])
>> title(’Imag{DFT[x(n)]}’); xlabel(’k’);
>> subplot(2,2,3); stem(n,real(Xec)); axis([-0.5,10.5,-5,50])
>> title(’DFT[xec(n)]’); xlabel(’k’);
>> subplot(2,2,4); stem(n,imag(Xoc)); axis([-0.5,10.5,-20,20])
>> title(’DFT[xoc(n)]’); xlabel(’k’);
A partir des graphiques de la figure 5.15, nous observons que la DFT de xec ( n) est le même
que la partie réelle de X (k ) et que la DFT de xoc ( n) est le même que la partie imaginaire de
X (k ) .
Une propriété similaire pour les séquences à valeurs complexes est explorée dans le problème
P5.18.
5. Décalage circulaire d'une séquence : Si une séquence de N points est décalée dans l'une
ou l'autre direction, le résultat n'est plus compris entre 0 ≤ n ≤ N − 1 .
Par conséquent, nous convertissons premièrement x ( n) dans son extension périodique xɶ(n) ,
puis nous le déplaçons de m échantillons pour obtenir
ɶx (n − m) = x ((n − m))N (5.35)

Ceci est appellé un décalage périodique de xɶ(n) . Le décalage périodique est ensuite converti
en une séquence à N points. La séquence résultante
xɶ(n − m)ℜ N (n) = x ((n − m))N ℜ N (n) (5.36)
est appelé le décalage circulaire de x ( n) . Encore une fois pour visualiser ceci, imaginez que
la séquence x ( n) est enroulée autour d'un cercle. Tournez maintenant le cercle par k
échantillons et déballez la séquence de 0 ≤ n ≤ N − 1 . Sa DFT est donné par
DFT  x ((n − m))N ℜ N (n) = WNkm X (k ) (5.37)
n
EXEMPLE 5.11 Soit x( n) = 10 (0.8) , 0 ≤ n ≤ 10 une sequence çà 11-points.
a. .Esquisser x ((n + 4))11 ℜ11 ( n) , c'est-à-dire un décalage circulaire de 4 échantillons

vers la gauche.
b. b. Esquisser x ((n − 3))15 ℜ15 (n) , c'est-à-dire un décalage circulaire de 3 échantillons
vers la droite, où x ( n) est supposée être une séquence de 15 points.
Solution
Nous utiliserons une approche graphique étape par étape pour illustrer l'opération de
déplacement circulaire. Cette approche montre l'extension périodique
ɶx (n) = x ((n))N de x ( n) , suivie d'un décalage linéaire de xɶ(n) pour obtenir
ɶx (n − m) = x ((n − m))N , et enfin la troncation xɶ(n − m) pour obtenir le
décalage circulaire.
a. La figure 5.16 montre quatre séquences. La partie supérieure gauche montre x ( n)

, la partie inférieure gauche montre xɶ(n) , la partie supérieure droite montre
xɶ(n + 4) et enfin la partie inférieure droite montre x ((n + 4))11 ℜ11 (n) . Notez
bien que lorsque les échantillons sortent de la fenêtre[0, N- 1] dans une direction,
ils réapparaissent dans la direction opposée. C'est le sens du décalage circulaire,
et il est différent du décalage linéaire.
b. Dans ce cas, la séquence x ( n) est traitée comme une séquence de 15 points par
remplissage de 4 zéros. Maintenant, le décalage circulaire sera different que
lorsque N = 11. C'est ce que montre la figure 5.17. En fait, le déplacement
circulaire x ((n − 3))15 ressemble à un déplacement linéaire x(n − 3) .
Pour implémenter un décalage circulaire, nous n'avons pas besoin de passer par le décalage
périodique comme indiqué dans l'exemple 5.11. Il peut être mis en œuvre directement de deux
façons. Dans la première approche, l'opération modulo-N peut être utilisée sur l'argument
( n − m) dans le domaine temporel. Ceci est illustré ci-dessous dans la fonction cirshftt.
FIGURE 5.16 Interprétation graphique du décalage circulaire, N =11
FIGURE 5.17 Interprétation graphique du décalage circulaire, N =15

function y = cirshftt(x,m,N)
% Circular shift of m samples wrt size N in sequence x: (time domain)
% -------------------------------------------------------------------
% [y] = cirshftt(x,m,N)
%y= output sequence containing the circular shift
%x= input sequence of length <= N
%m= sample shift
%N= size of circular buffer
% Method: y(n) = x((n-m) mod N)
% Check for length of x
if length(x) > N
error(’N must be >= the length of x’)
end
x=[x zeros(1,N-length(x))];
n= [0:1:N-1]; n = mod(n-m,N); y = x(n+1);
Dans la deuxième approche, la propriété (5.37) peut être utilisée dans le domaine fréquentiel.
Cette question est abordée dans le problème P5.20.
n
EXEMPLE 5.12 Pour une séquence x( n) = 10 (0.8) de 11 points, 0 ≤n≤ 10, déterminer et
tracer x ((n − 6))15 .
Solution
Script MATLAB:
>> n = 0:10; x = 10*(0.8) .^ n; y = cirshftt(x,6,15);

>> n = 0:14; x = [x, zeros(1,4)];
>> subplot(2,1,1); stem(n,x); title(’Original sequence’)
>> xlabel(’n’); ylabel(’x(n)’);
>> subplot(2,1,2); stem(n,y);
>> title(’Circularly shifted sequence, N=15’)
>> xlabel(’n’); ylabel(’x((n-6) mod 15)’);
Les résultats sont présentés à la figure 5.18.
6. Décalage circulaire dans le domaine fréquentiel : Cette propriété est un double de la

propriété précédente donnée par
DFT WN− ln x (n) = X ((k − l ))N ℜ N (k ) (5.38)
7. Convolution circulaire : Une convolution linéaire entre deux séquences de N points

donnera une séquence plus longue. Une fois de plus, nous devons limiter notre intervalle à 0 ≤
n ≤ N - 1. Par conséquent, au lieu d'un déplacement linéaire, nous devrions considérer le
déplacement circulaire.
FIGURE 5.18 Séquence décalée circulairement dans l'exemple 5.12
Une opération de convolution qui contient un décalage circulaire s'appelle la convolution

circulaire et est donnée par
N −1
x1 ( n) N x2 (n) = ∑ x1 (m) x2 ((n − m))N , 0 ≤ n ≤ N – 1 (5.39)
m= 0
Notez que la convolution circulaire est aussi une séquence de N points. Sa structure est
similaire à celle d'une convolution linéaire. Les differences sont dans les limites de sommation
et dans le décalage circulaire du point N. Il dépend donc de N et s'appelle aussi une
convolution circulaire en N points. Par conséquent, l'utilisation de la notation N est
appropriée. La propriété DFT de la convolution circulaire est la suivante
DFT  x1 (n) N x2 (n) = X 1 (k )⋅ X 2 (k ) (5.40)
 
Une autre interprétation de cette propriété est que lorsque nous multiplions deux DFT à N
points dans le domaine fréquentiel, nous obtenons la convolution circulaire (et non la
convolution linéaire habituelle) dans le domaine temporel
EXEMPLE 5.13 Soient x1 ( n) = {1, 2, 2} , et x2 (n) = {1, 2,3, 4} . Calculer la convolution
circulaire en 4 points x1 ( n) 4 x2 ( n) .
Solution
Notez que x1 (n) est une séquence de 3 points, donc nous devrons tamponner un zéro pour en
faire une séquence de 4 points avant d'effectuer la convolution circulaire. Nous calculerons
cette convolution aussi bien dans le domaine temporel que dans le domaine fréquentiel.
Dans le domaine temporel, nous utiliserons le mécanisme de la convolution circulaire, tandis

que dans le domaine des fréquences, nous utiliserons les DFT.
• approache dans le domaine temporel: La convolution circulaire à 4 points est donnée par
3
x1 ( n) 4 x2 ( n) = ∑ x1 (m) x2 ((n − m))4
m= 0
Il faut donc créer une séquence circulairement pliée et décalée x2 (( n − m))N pour chaque
valeur de n, la multiplier échantillon par échantillon avec x1 (m) , ajouter les échantillons pour
obtenir la valeur de convolution circulaire pour ce n, puis répéter la procédure pour 0≤n≤3.
Considérons
x1 (m) = {1, 2, 2, 0} , et x2 (m) = {1, 2, 3, 4}
pour n =0
3 3
∑ x1 (m) ⋅ x2 ((0 − m))5 = ∑ {1, 2, 2, 0}⋅ {1, 4, 3, 2}

m=0 m=0
3
= ∑ {1, 8, 6, 0} = 15
m=0
Pour n =1
3 3
∑ x (m) ⋅ x ((1− m)) = ∑ {1, 2, 2, 0}⋅ {2, 1, 4, 3}

m=0
1 2 5
m=0
3
= ∑ {2, 2, 8, 0} = 12
m=0
Pour n =2
3 3
∑ x (m) ⋅ x ((2 − m)) = ∑ {1, 2, 2, 0}⋅ {3, 2, 1, 4}

m=0
1 2 5
m=0
3
= ∑ {3, 4, 2, 0} = 9
m=0
Pour n =3
3 3
∑ x1 (m) ⋅ x2 ((3 − m))5 = ∑ {1, 2, 2, 0}⋅ {4, 3, 2, 1}

m=0 m=0
3
= ∑ {4, 6, 4, 0} = 14
m=0
Par conséquent
x1 (n) 4 x2 (n) = {15, 12, 9, 14}
•Approche dans le domaine des fréquences : Dans cette approche, nous calculons des DFTs à
4 points de x1 (n) et x2 (n) , les multiplions échantillon par échantillon, puis prenons le DFT
inverse du résultat pour obtenir la convolution circulaire.
DFT de x1 (n)
x1 (n) = {1, 2, 2, 0} ⇒ X 1 (k ) = {5, −1− j 2, 1, −1 + j 2}
DFT de x2 (n)
x2 (n) = {1, 2, 3, 4} ⇒ X 2 (k ) = {10, − 2 + j 2, − 2, − 2 − j 2}
Maintenant
X 1 (k )⋅ X 2 (k ) = {50, 6 + j 2, − 2, 6 − j 2}
Enfin après IDFT,
x1 (n) 4 x2 (n) = {15, 12, 9, 14}
qui est le même qu'avant.
Semblable à la mise en place d'un décalage circulaire, nous pouvons mettre en œuvre la
convolution circulaire de plusieurs façons différentes. L'approche la plus simple serait de
mettre en œuvre (5.39) littéralement en utilisant la fonction cirshftt et en exigeant deux
boucles imbriquées for--end. Évidemment, ce n'est pas efficace.
Une autre approche consiste à générer une séquence x ((n − m))N pour chaque n dans
[ 0, N − 1] sous forme de lignes d'une matrice, puis à la mettre en œuvre (5.39) sous forme
d'une multiplication matrice-vecteur semblable à notre fonction dft. Il en faudrait une boucle
for--end. La fonction circonvt suivante incorpore ces étapes.
function y = circonvt(x1,x2,N)
% N-point circular convolution between x1 and x2: (time-domain)
% -------------------------------------------------------------
% [y] = circonvt(x1,x2,N)
% y= output sequence containing the circular convolution
%x1= input sequence of length N1 <= N
%x2= input sequence of length N2 <= N
% N= size of circular buffer
% Method: y(n) = sum (x1(m)*x2((n-m) mod N))
% Check for length of x1
if length(x1) > N
error(’N must be >= the length of x1’)
end
% Check for length of x2
if length(x2) > N
error(’N must be >= the length of x2’)
end
x1=[x1 zeros(1,N-length(x1))];
x2=[x2 zeros(1,N-length(x2))];
m= [0:1:N-1]; x2 = x2(mod(-m,N)+1); H = zeros(N,N);
for n = 1:1:N
H(n,:) = cirshftt(x2,n-1,N);
end
y= x1*conj(H’);
Les problèmes P5.24 et P5.25 explorent une approche pour éliminer la boucle for—end dans
la fonction circonvt. La troisième approche consisterait à mettre en œuvre le fonctionnement
dans le domaine des fréquences (5.40) en utilisant la fonction dft.
Cette question est abordée dans le problème P5.26.
EXEMPLE 5.14 Utilisons MATLAB pour effectuer la convolution circulaire de l'exemple

5.13.
Solution
Les sequences sont x1 ( n) = {1, 2, 2} et x2 ( n) = {1, 2, 3, 4} .
script MATLAB:
>> x1 = [1,2,2]; x2 = [1,2,3,4]; y = circonvt(x1, x2, 4)

y=
15 12 9 14
Par conséquent
x1 (n) 4 x2 (n) = {15, 12, 9, 14}
Comme avant.
EXEMPLE 5.15 : Dans cet exemple, nous allons étudier l'effet de N sur la convolution
circulaire. Evidemment, N≥4 ; sinon il y aura un repliement de domaine temporel pour x2 (n) .
Nous utiliserons les deux mêmes séquences de l'exemple 5.13.
a. Calculer x1 ( n) 5 x2 ( n) .
b. Calculer x1 ( n) 6 x2 ( n) .
c. Commenter les résultats.
Solution
Les séquences sont x1 ( n) = {1, 2, 2} et x2 ( n) = {1, 2, 3, 4} . Même si les séquences sont

les mêmes que dans l'exemple 5.14, on peut s'attendre à des résultats différents pour les
valeurs de N . Ce n'est pas le cas de la convolution linéaire, qui est unique, étant donné deux
séquences.
a. Script MATLAB pour une convolution circulaire 5-points:

>> x1 = [1,2,2]; x2 = [1,2,3,4]; y = circonvt(x1, x2, 5)
y=
9 4 9 14 14
Par conséquent
x1 ( n) 5 x2 ( n) = {9, 4, 9, 14, 14}
b. Script MATLAB pour une convolution circulaire 6-points:
>> x1 = [1,2,2]; x2 = [1,2,3,4]; y = circonvt(x1, x2, 6)

y=
1 4 9 14 14 8
Par conséquent
x1 ( n) 6 x2 ( n) = {1, 4, 9, 14, 14, 8}
c. Une observation attentive des convolutions circulaires à 4, 5 et 6 points de cet exemple et

de l'exemple précédent montre certaines caractéristiques uniques. De toute évidence, une
convolution circulaire à N points est une séquence à N points. Cependant, certains
échantillons de ces convolutions ont les mêmes valeurs, alors que d'autres valeurs
peuvent être obtenues sous forme de somme d'échantillons d'autres convolutions. Par
exemple, le premier échantillon de la convolution à 5 points est la somme du premier et
du dernier échantillon de la convolution à 6 points. La convolution linéaire entre x1 (n) et
x2 (n) est donnée par
x1 ( n) ∗ x2 ( n) = {1, 4, 9, 14, 14, 8}
ce qui équivaut à la convolution circulaire en 6 points. Ces questions et d'autres sont

examinées dans la section suivante.
8. Multiplication: C'est le dual de la propriété à convolution circulaire. Il est donné par

1
DFT [ x1 (n) ⋅ x2 (n) ] = X 1 (k ) N X 2 (k ) (5.41)
N
dans laquelle la convolution circulaire est effectuée dans le domaine fréquentiel.
Les fonctions MATLAB développées pour la convolution circulaire peuvent également être
utilisées ici puisque X 1 (k ) et X 2 (k ) sont également des séquences à N points.
9. Relation de Parseval: Cette relation calcule l'énergie dans le domaine fréquentiel.

N −1
2 1 N −1 2
E x = ∑ x (n) = ∑ X (k ) (5.42)
n= 0 N k =0
2
X (k )
La quantité est appelé le spectre d'énergie des séquences de durée finie. De même,
N
2
Xɶ (k )
pour les séquences périodiques, la quantité est appelé le spectre de puissance.
N
V. CONVOLUTION LINÉAIRE EN UTILISANT LA DFT
L'une des opérations les plus importantes dans les systèmes linéaires est la convolution
linéaire. En fait, les filtres FIR sont généralement implémentés dans la pratique en utilisant
cette convolution linéaire. D'autre part, le DFT est une approche pratique pour la mise en
œuvre du fonctionnement des systèmes linéaires dans le domaine des fréquences. Comme
nous le verrons plus loin, c'est aussi une opération efficace en termes de calculs.
Cependant, il y a un problème. Les opérations DFT aboutissent à une convolution circulaire

(ce que nous ne désirons pas), pas à une convolution linéaire que nous voulons. Nous verrons
maintenant comment utiliser la DFT pour effectuer une convolution linéaire (ou de manière
équivalente, comment faire une convolution circulaire identique à la convolution linéaire).
Nous avons fait allusion à ce problème dans l'exemple 5.15.
Soit x1 (n) une sequence à N1-point et soit x2 (n) une sequence à N2-point. Définir la
convolution linéaire de x1 (n) et x2 (n) par x3 (n) , c’est à dire,
x3 (n) = x1 (n) ∗ x2 (n)

N1−1
∞ (5.43)
= ∑
k =−∞
x1 (k ) x2 (n − k ) = ∑ x1 (k ) x2 (n − k )
0
Alors x3 (n) est une sequence à ( N1 + N 2 −1) -points. Si nous choisissons
N = max ( N1 , N 2 ) et calculons une convolution circulaire à N-point x1 (n) N x2 ( n) , Alors

nous obtenons une séquence de N points, qui est évidemment différente de celle de x3 (n) .
Cette observation nous donne aussi un indice. Pourquoi ne pas choisir N = N1 + N 2 −1 et

réaliser une convolution circulaire ( N1 + N 2 −1) -points? Alors au moins ces deux
convolutions auront un nombre égal d'échantillons.
Soit donc N = N1 + N 2 −1 et traitons x1 (n) et x2 (n) comme des séquences à N points.

Definir la convolution circulaire N-point par x4 (n) .
x4 ( n) = x1 (n) N x2 ( n)
 N −1 
=  ∑ x1 (m) x2 ((n − m))N  ℜ N (n)
 m=0 
 N −1 ∞ 
=  ∑ x1 (m) ∑ x2 (n − m − rN ) ℜ N (n)
 m=0 r =−∞

 
 ∞ N −1 
 
=  ∑ ∑ x1 ( m)x2 (n − m − rN ) ℜ N (n)
 r=−∞ m=0 
 x3 (n−rN )

 
 ∞ 
=  ∑ x3 (n − rN ) ℜ N (n)
 r=−∞ 
(5.44)
Cette analyse montre qu'en général, la convolution circulaire est une version repliée de la
convolution linéaire. Nous avons observé ce fait dans l'exemple 5.15.
Maintenant puisque x3 (n) est une séquence N = ( N1 + N 2 −1) -point, nous avons
x4 (n) = x3 (n) , 0 ≤ n ≤ (N − 1)
ce qui signifie qu'il n'y a pas de repliement dans le domaine temporel.
Conclusion: Si nous faisons les deux séquences x1 (n) et x2 (n) les séquences de
N = ( N1 + N 2 −1) points en remplissant un nombre approprié de zéros, alors la convolution
circulaire est identique à la convolution linéaire.
EXEMPLE 5.16 Soient x1 (n) et x2 (n) les deux séquences de 4 points suivantes.
x1 ( n) = {1, 2, 2, 1} , x2 ( n) = {1, −1, −1, 1}
a. Déterminer leur convolution linéaire x3 (n) .
b. Calculez la convolution circulaire x4 (n) de sorte qu'elle soit égale à x3 (n) .
Solution : Nous utiliserons MATLAB pour résoudre ce problème.
a. Script MATLAB:
>> x1 = [1,2,2,1]; x2 = [1,-1,-1,1]; x3 = conv(x1,x2)

x3 = 1 1 -1 -2 -1 1 1
La convolution linéaire x3 (n) est donc une séquence de 7 points donnée par
x3 ( n) = {1, 1, −1, −2 −1, 1, 1}
b. Nous devrons utiliser N ≥ 7. En choisissant N = 7, nous avons

>> x4 = circonvt(x1,x2,7)
x4 = 1 1 -1 -2 -1 1 1
Par conséquent
x4 ( n) = {1, 1, −1, −2 −1, 1, 1} = x3 ( n)
5.5.1 ANALYSE DES ERREURS
Pour utiliser la DFT pour la convolution linéaire, nous devons choisir N correctement.
Cependant, dans la pratique, il n'est pas toujours possible de le faire, surtout lorsque N est très
grand et qu'il y a une limite à la mémoire. Ensuite, une erreur sera introduite lorsque N est
choisi inférieur à la valeur requise pour effectuer la convolution circulaire. Nous voulons
calculer cette erreur, ce qui est utile dans la pratique. Évidemment N ≥ max ( N1 , N 2 ) . Par
conséquent, soit
max ( N1 , N 2 ) ≤ N < ( N1 + N 2 −1)
Puis, d'après notre analyse précédente (5.44)
 ∞ 
x4 (n) =  ∑ x3 (n − rN ) ℜ N (n)
 r =−∞ 
Soit une erreur e(n) donnée par
∆
e(n) = x4 (n) − x3 (n)
 
=  ∑ x3 (n − rN ) ℜ N (n)
 r≠0 
Puisque N ≥ max ( N1 , N 2 ) , seuls deux termes correspondant à r = ± 1 restent dans la somme

ci-dessus. D'où
e( n) =  x3 (n − N ) + x3 (n + N ) ℜ N (n)
Généralement, x1 (n) et x2 (n) sont des séquences causales. Alors x3 (n) est aussi causal, ce
qui signifie que
x3 (n − N ) = 0 ; 0 ≤ n ≤ N−1
donc
e( n) = x3 (n + N ) ; 0 ≤ n ≤ N−1
Il s'agit d'une relation simple

mais importante. Cela implique que lorsque
max ( N1 , N 2 ) ≤ N < ( N1 + N 2 −1) la valeur de l'erreur à n est la même que la valeur de
convolution linéaire calculée pour N échantillons. Maintenant, la convolution linéaire sera de
zéro après les ( N1 + N 2 −1) échantillons. Cela signifie que les premiers échantillons de la
convolution circulaire sont erronés, tandis que les autres sont les valeurs correctes de la
convolution linéaire.
EXEMPLE 5.17 Considérons les séquences x1 (n) et x2 (n) de l'exemple précédent. Évaluer
les convolutions circulaires pour N = 6, 5 et 4. Vérifier les relations d'erreur dans chaque cas.
Solution: De toute évidence, la convolution linéaire x3 (n) est toujours la même.
x3 ( n) = {1, 1, −1, −2 −1, 1, 1}
Lorsque N = 6, on obtient une séquence de 6 points.
x4 ( n) = x1 (n) 6 x2 (n) = {2, 1, −1, −2 −1, 1}
Par conséquent
e(n) = {2, 1, −1, −2 −1, 1} − {1, 1, −1, −2 −1, 1, 1}

= {1, 0,0,0,0,0} , 0≤n≤5
= x3 (n + 6)
comme prévu. Lorsque N = 5, on obtient une séquence de 5 points,
x4 (n) = x1 ( n) 5 x2 ( n) = {2, 2, −1, −2, −1}
et
e(n) = {2, 2, −1, −2, −1} − {1, 1, −1, −2 −1}

= {1, 1,0,0,0} , 0≤n≤4
= x3 (n + 5)
Enfin, lorsque N = 4, on obtient une séquence de 4 points,

x4 (n) = x1 ( n) 4 x2 (n) = {0, 2,0, −2}
et
e(n) = {0, 2,0, −2} − {1, 1, −1, −2}

= {−1, 1,1,0} , 0≤n≤3
= x3 (n + 4)
Le dernier cas de N = 4 fournit également l'observation utile suivante.

Observation : Lorsque N = max ( N1 , N 2 ) est choisi une convolution circulaire, les premiers
échantillons (M-1) sont erronés (c.-à-d. différents de la convolution linéaire), où
M = min ( N1 , N 2 ) . Ce résultat est utile pour la mise en œuvre de longues convolutions sous
forme de traitement de blocs.
5.5.2 BLOCS CONVOLUTIONS
Lorsque nous voulons filtrer une séquence d'entrée qui est reçue en continu, par exemple un
signal vocal provenant d'un microphone, nous pouvons considérer cette séquence, pour des
raisons pratiques, comme une séquence de longueur infinie. Si nous voulons implémenter
cette opération de filtrage comme un filtre FIR dans lequel la convolution linéaire est calculée
en utilisant le DFT, alors nous rencontrons quelques problèmes pratiques. Nous devrons
calculer un DFT important, ce qui est généralement peu pratique. De plus, les échantillons de
sortie ne sont pas disponibles tant que tous les échantillons d'entrée n'ont pas été traités. Cela
entraîne des retards inacceptables. Par conséquent, nous devons segmenter la séquence
d'entrée de longueur infinie en sections plus petites (ou blocs), traiter chaque section à l'aide
du DFT, et finalement assembler la séquence de sortie à partir des sorties de chaque section.
Cette procédure est appelée opération de convolution de bloc (ou traitement de bloc).
Supposons que la séquence x(n) est divisée en N séquences de points et que la réponse
impulsionnelle du filtre est une séquence de M-points, où M<N. Ensuite, à partir de
l'observation de l'exemple 5.17, nous remarquons que la convolution circulaire à N points
entre le bloc d'entrée et la réponse impulsionnelle donnera une séquence de sortie de bloc
dans laquelle les premiers échantillons (M-1) ne sont pas les bonnes valeurs de sortie. Si nous
divisons x(n) simplement en sections qui ne se chevauchent pas, alors la séquence de sortie
résultante aura des intervalles d'échantillons incorrects. Pour corriger ce problème, nous
pouvons diviser x(n) en sections, chacune se chevauchant avec la précédente par exactement
(M -1) échantillons, sauvegarder les derniers (N- M +1) échantillons de sortie, et finalement
concaténer ces sorties en une séquence. Pour corriger les premiers (M - 1) échantillons du
premier bloc de sortie, on met à zéro les premiers (M - 1) échantillons du premier bloc
d'entrée. Cette procédure s'appelle une méthode d'enregistrement par chevauchement des
convolutions de blocs. De toute évidence, quand x(n) , cette méthode est plus efficient. Nous
l'illustrons par un exemple simple.
EXEMPLE 5.18 Soit x( n) = (n + 1) , 0 ≤ n ≤ 9 et h(n) = {1, 0, −1} . Implémenter la

↑
méthode d'enregistrement par recouvrement en utilisant N=6 pour calculer

y ( n) = x( n) ∗ h( n) .
Solution
Puisque M = 3, nous devrons chevaucher chaque section avec la précédente par deux
échantillons. Maintenant x(n) est une séquence de 10 points, et nous aurons besoin
de (M-1) = 2 zéros au début. Puisque N = 6, nous aurons besoin de 3 sections. Que
les sections soient
x1 ( n) = {0, 0, 1, 2, 3, 4}
x2 ( n) = {3, 4, 5, 6, 7, 8}
x3 ( n) = {7, 8, 9, 10, 0, 0}
Notez que nous devons ajouter x3 (n) deux zéros puisque x(n) n'a plus de valeurs à
n=9. Nous allons maintenant calculer la convolution circulaire en 6 points de chaque
section avec h(n) .
y1 = x1 (n) 6 h(n) = {- 3, -4, 1, 2, 2, 2}
y2 = x2 (n) 6 h(n) = {- 4, -4, 2, 2, 2, 2}
y3 = x3 (n) 6 h(n) = { 7, 8, 2, 2, - 9, - 10}
En notant que les deux premiers échantillons de chaque section doivent être éliminés, nous
assemblons le résultat y(n) comme suit
y (n)= { 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, -9, - 10}

↑
La convolution linéaire est donnée par

x(n) ∗ h(n)= { 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 9, - 10}
↑
qui est d'accord avec la méthode d'enregistrement par chevauchement.
En utilisant cet exemple comme guide, nous pouvons développer une fonction MATLAB
pour implémenter la méthode d'enregistrement de chevauchement pour une très longue
séquence d'entrée x(n) .
L'étape clé de cette fonction est d'obtenir une indexation correcte de la segmentation. Pour
x(n) donné avec n ≥ 0, il faut mettre à zéro les premiers (M-1) échantillons pour commencer
le traitement des blocs. Soit cette séquence augmentée
∆
xˆ (n) ={0, 0, …, 0, x ( n)}, n ≥0
( M -1) zeros
Et soit L = N − M +1, alorrs le k ieme blockc xk (n) , 0 ≤ n ≤ N−1, est donné par
xk (n) = xˆ (m) ; kL ≤ m ≤ kL + N − 1, k ≥ 0, 0 ≤ n ≤ N−1

Le nombre total de blocs est donné par
 N + M - 2
K= x  +1
 L 
où N x est la longueur x(n) et i est l'opération de troncature. Maintenant, chaque bloc peut
être circulairement convolutionné avec h(n) en utilisant la fonction circonvt développée
précédemment pour obtenir
yk (n) = xk ( n) N h( n)
Enfin, en éliminant les premiers (M-1) échantillons de chacun yk (n) et en concaténant les
échantillons restants, on obtient la convolution linéaire y(n) .
Cette procédure est incorporée dans la fonction ovrlpsav suivante.

%%\leftskip12pt
function [y] = ovrlpsav(x,h,N)
% Overlap-Save method of block convolution
% ----------------------------------------
% [y] = ovrlpsav(x,h,N)
% y= output sequence
% x= input sequence
% h= impulse response
% N= block length
%
Lenx = length(x); M = length(h); M1 = M-1; L = N-M1;
h=[h zeros(1,N-M)];
%
x= [zeros(1,M1), x, zeros(1,N-1)]; % preappend (M-1) zeros
K= floor((Lenx+M1-1)/(L)); % # of blocks
Y= zeros(K+1,N);
% convolution with succesive blocks
for k=0:K
xk = x(k*L+1:k*L+N);
Y(k+1,:) = circonvt(xk,h,N);
end
Y= Y(:,M:N)’; % discard the first (M-1) samples
y= (Y(:))’; % assemble output
Note : La fonction ovrlpsav telle que développée ici n'est pas l'approche la plus efficace. Nous
reviendrons sur cette question lorsque nous discuterons de la transformation de Fourier rapide.
EXEMPLE 5.19 Pour vérifier le fonctionnement de la fonction ovrlpsav, considérons les

séquences données dans l'exemple 5.18.
Solution script MATLAB:
>> n = 0:9; x = n+1; h = [1,0,-1]; N = 6; y = ovrlpsav(x,h,N)

y=
1 2 2 2 2 2 2 2 2 2 -9 -10
C'est la convolution linéaire correcte comme prévu.
Il existe une autre méthode appelée méthode d'addition de chevauchement des convolutions
de blocs. Dans cette méthode, la séquence d'entrée x(n) est divisée en blocs non
chevauchants et convolutionnée avec la réponse impulsionnelle. Les blocs de sortie résultants
sont superposés aux sections suivantes et ajoutés pour former la production globale. Cette
question est abordée dans le problème P5.32.
VI. LA TRANSFORMATION DE FOURIER RAPIDE

Le DFT (5.24) introduit plus haut est la seule transformation discrète dans le domaine
temporel et dans le domaine fréquentiel, et elle est définie pour des séquences de durée finie.
Bien qu'il s'agisse d'une transformation calculable, l'implémentation simple de (5.24) est très
inefficace, surtout lorsque la longueur de séquence N est grande. En 1965, Cooley et Tukey[1]
ont montré une procédure pour réduire considérablement le nombre de calculs impliqués dans
le DFT. Cela a conduit à l'explosion des applications du DFT, y compris dans le domaine du
traitement numérique du signal. De plus, elle a également conduit au développement d'autres
algorithmes efficient. Tous ces algorithmes de efficient sont collectivement connus sous le
nom d'algorithmes de transformée de Fourier rapide (FFT).
Considérons une séquence de N points x(n) . Sa DFT N-points est donné par (5.24) et
reproduit ici
N −1
X (k ) = ∑ x(n)WNnk , 0≤k≤N−1
n=0
où WN = e− j 2π N . Pour obtenir un échantillon de X (k ) , il faut N multiplications complexes

et (N-1) additions complexes. Pour obtenir un ensemble complet de coefficients DFT, nous
avons donc besoin de N 2 multiplications complexes et N ( N −1)≃ N 2 d'additions
complexes. Il faut aussi stocker N 2 coefficients complexes {WNnk } (ou générer en interne à
un coût supplémentaire). De toute évidence, le nombre de calculs DFT pour une séquence à
N-points dépend quadratiquement de N, qui sera noté par la notation suivante
CN = o ( N 2 )
Pour les grands N, o ( N 2 ) est inacceptable dans la pratique. En général, le temps de

traitement d'une addition est beaucoup plus court que celui d'une multiplication.
C'est pourquoi nous nous concentrerons désormais sur le nombre de multiplications

complexes, qui lui-même nécessite 4 multiplications réelles et 2 additions réelles.
But d'un calcul efficace Dans un algorithme conçu efficacement, le nombre de calculs doit
être constant par échantillon de données, et donc le nombre total de calculs doit être linéaire
par rapport à N .
La dépendance quadratique de N peut être réduite en réalisant que la plupart des calculs (qui
sont faits encore et encore) peuvent être éliminés en utilisant la propriété de périodicité
WNnk = WN (
k n+ N )
= WN(
k + N )n
et la propriété de symétrie
WNnk + N 2 = −WNnk
de facteur {WNnk }
Un algorithme qui ne prend en compte que la périodicité de WNnk est l'algorithme de Goertzel.
Cet algorithme nécessite encore C N = o ( N 2 ) multiplications, mais il présente certains
avantages. Cet algorithme est décrit au chapitre 12. Nous commençons d'abord par un
exemple pour illustrer les avantages des propriétés de symétrie et de périodicité dans la
réduction du nombre de calculs. Nous décrivons et analysons ensuite deux algorithmes FFT
spécifiques qui nécessitent C N = o ( N log N ) opérations. Ce sont les algorithmes de
décimation dans le temps (DIT-FFT) et de décimation dans la fréquence (DIF-FFT).
EXEMPLE 5.20 Discutons des calculs d'un DFT à 4 points et développons un algorithme
efficace pour son calcul.
3
X (k ) = ∑ x(n)W4nk , 0 ≤ k ≤ 3; W4 = e− j 2π 4 = − j
n=0
Solution Ces calculs peuvent être effectués sous la forme d'une matrice
 X (0) W40 W40 W40 W40   x(0)

    
 X (1)  W40 W41 W42 W43   x(1) 
 =
 X (2) W 0 W42 W44 W46   x(2)
   4
 X (3)  W 0 W43 W46 W49   x(3) 
   4
qui nécessite 16 multiplications complexes.
Approche efficace utilisant la périodicité,
W40 = W44 = 1 ; W41 = W49 = − j
W42 = W46 = −1 ; W43 = j
et en substituant dans la forme matricielle ci-dessus, nous obtenons

 X (0) 1 1 1 1   x(0)
    
 X (1)  1 − j −1 j   x(1) 
 =  
 X (2) 1 −1 1 −1  x(2)
    
 X (3)  1 j −1 − j   x(3) 
    
En utilisant la symétrie, on obtient
X (0) = x(0) + x(1) + x(2) + x(3) = [ x(0) + x(2)] + [ x(1) + x(3)]

g1 g2
X (1) = x(0) − jx(1) − x(2) + jx(3) = [ x(0) − x(2)] − j [ x(1) − x(3) ]

h1 h2
X (2) = x(0) − x(1) + x(2) − x(3) = [ x(0) + x(2)] − [ x(1) + x(3) ]

g1 g2
X (3) = x(0) + jx(1) − x(2) − jx(3) = [ x(0) − x(2)] + j [ x(1) − x(3)]

h1 h2
Hence an efficient algorithm is
step1 step2
g1 = x(0) + x(2) X (0) = g1 + g 2
g 2 = x(1) + x(3) X (1) = h1− jh 2 (5.47)
h1 = x(0) − x(2) X (2) = g1− g 2
h 2 = x(1) − x(3) X (3) = h1 + jh2
qui ne nécessite que 2 multiplications complexes, ce qui est un nombre considérablement plus
petit, même pour cet exemple simple. Une structure graphique du signal flow pour cet
algorithme est donnée à la figure 5.19.
Une interpretation Cet algorithme efficace (5.47) peut être interprété différemment. Tout
d'abord, une séquence de 4 points x( n) est divisée en deux séquences de 2 points, qui sont
organisées en vecteurs de colonnes comme montré ici.
  x(0)  x(1)    x(0) x(1) 

 ,  =  
  x(2)  x(3)   x(2) x(3)
     
FIGURE 5.19 Signal flowgraph dans l'exemple 5.20
Deuxièmement, un DFT plus petit de 2 points de chaque colonne est pris.
 x(0) x(1)  1 1   x(0) x(1) 

W2  =  
 x(2) x(3) 1 −1  x(2) x(3)
 x(0) + x(2) x(1) + x(3)  g1 g 2
= = 
 x(0) − x(2) x(3) − x(1)   h1 h2 
Ensuite, chaque élément de la matrice résultante est multiplié par {W4pq } , où p est l'index de
ligne et q est l'index de colonne ; c'est-à-dire, le produit-point suivant est exécuté :
1 1   g1 g 2  g1 g 2 
 ∗ = 
1 − j   h1 h2   h1 − jh 2
Enfin, deux autres DFT à 2 points plus petits sont pris sur des vecteurs en ligne.
 g1 g 2   g1 g 2  1 1   g1 + g 2 g1 − g 2 
  W2 =   = 
 h1 − jh 2  h1 − jh 2 1 − j   h1− jh 2 h1 + jh 2
 X (0) X (2)
=  

 X (1) X ( 3 )
Bien que cette interprétation semble avoir plus de multiplications que l'algorithme efficace,
elle suggère une approche systématique de calcul d'un DFT plus grand basé sur de plus petits
DFT.
5.6.1 APPROCHE DIVISÉE ET COMBINÉE
Pour réduire la dépendance quadratique du calcul DFT par rapport à N, il faut choisir un
nombre composite N = LM puisque
L2 + M 2 ≪ N 2 Pour N grand
Divisez maintenant la séquence en M séquences plus petites de longueur L, calculez M DFTs
plus petits de point L, puis combinez-les dans un DFT plus grand en utilisant L DFTs plus
petits de point M. C'est là l'essence même de l'approche " diviser pour mieux combiner ". Soit
N = LM, alors les indices n et k in (5.46) peuvent être écrits comme suit
n = l + Lm, 0 ≤ ℓ ≤ L −1, 0 ≤ m ≤ M −1
(5.48)
k = q + Mp, 0 ≤ p ≤ L −1, 0 ≤ q ≤ M −1
et écrire des séquences x( n) et X ( k ) comme tableaux x( ℓ, m) et X ( p, q) , respectivement.

Alors (5.46) peut être écrit comme suit
L−1 M −1
X ( p, q) = ∑∑ x (ℓ, m) WN(ℓ+Lm)(q+Mp)
ℓ=0 m=0
L−1   M −1 

= ∑ WNℓq  ∑ x ( ℓ, m) WNLmq WNM ℓp (5.49)
ℓ =0 
  m=0 

 
L−1 
 
  M −1  ℓp
Lmq 
= ∑ WN  ∑ x (ℓ, m)WN  WL
ℓq

ℓ =0 
 m=0 
 
 M -point DFT 
L -point DFT
Par conséquent (5.49) peut être mis en œuvre comme une procédure en trois étapes :
1. Tout d'abord, nous calculons le tableau DFT du point M

M −1
F (ℓ, q)∆∑ x (ℓ, m) WMmq ; 0≤q≤M–1 (5.50)
m=0
pour chacune des lignes ℓ = 0,…, L −1 .
2. Deuxièmement, nous modifions F (ℓ, q ) pour obtenir un autre tableau.
0 ≤ ℓ ≤ L-1
G (ℓ, q) = WNℓq F (ℓ, q), (5.51)
0 ≤ q ≤ M-1
Le facteur WNℓq s'appelle un facteur double.
3. Finally, we compute the L-point DFTs

L−1
X ( p, q) = ∑ G (ℓ, q)WLℓp , 0 ≤ p ≤ L-1 (5.52)
ℓ =0
pour chacune des colonnes q=0,...,M−1.

Le nombre total de multiplications complexes pour cette approche peut maintenant être donné
par
CN = LM 2 + N + ML2 < o ( N 2 ) (5.53)
Nous illustrons cette approche dans l'exemple suivant.
EXEMPLE 5.21 Élaborer l'algorithme FFT de division et de combinaison pour N = 15.
Solution : Soit L=3 et M=5. Ensuite, à partir de (5.48), nous avons
n = ℓ + 3M , 0 ≤ ℓ ≤ 2, 0≤m≤4
(5.54)
k = q +5 p, 0 ≤ p ≤ 2, 0 ≤ q ≤ 4
Ainsi (5.49) deviant

2
X ( p, q) = ∑ {W15ℓq  x(ℓ, m)W5mq  }W3ℓp (5.55)
ℓ =0
Pour implémenter (5.55), nous arrangeons la séquence donnée x(n) sous la forme d'un tableau
{ x(ℓ, m) } en utilisant un ordre par colonne comme suit
x(0) x(3) x(6) x(9) x(12)

x(1) x(4) x(7) x(10) x(13) (5.56)
x(2) x(5) x(8) x(11) x(14)
La première étape consiste à calculer des DFT de 5 points F (ℓ, q ) pour chacune des trois
rangées et à les disposer de nouveau dans la même formation de tableau.
F (0,0) F (0,1) F (0, 2) F (0,3) F (0, 4)

F (1,0) F (1,1) F (1, 2) F (1,3) F (1, 4) (5.57)
F (2,0) F (2,1) F (2, 2) F (2,3) F (2, 4)
qui nécessite un total de 3 × 5² = 75 opérations complexes. La deuxième étape consiste à

modifier F (ℓ, q ) pour obtenir le tableau G (ℓ, q ) en utilisant les facteurs de rotation W15ℓq
G (0,0) G (0,1) G (0, 2) G (0,3) G (0, 4)
G (1,0) G (1,1) G (1, 2) G (1,3) G (1, 4) (5.58)
G (2,0) G (2,1) G (2, 2) G (2,3) G (2, 4)
qui nécessite 15 opérations complexes. La dernière étape consiste à effectuer des DFT en 3
points X ( p, q ) pour chacune des colonnes de five afin d'obtenir
X (0,0) X (0,1) X (0, 2) X (0,3) X (0, 4)

X (1,0) X (1,1) X (1, 2) X (1,3) X (1, 4) (5.59)
X (2,0) X (2,1) X (2, 2) X (2,3) X (2, 4)
en utilisant un total de 5×3² =45 opérations complexes. Selon (5.54), le tableau en (5.59) est
un réarrangement de X (k ) comme
X (0) X (1) X (2) X (3) X (4)

X (5) X (6) X (7) X (8) X (9) (5.60)
X (10) X (11) X (12) X (13) X (14)
Enfin, après avoir "déroulé" ce tableau en ligne, on obtient le DFT 15-points X (k ) . Le

nombre total d'opérations complexes requises pour cette approche combinatoire est de 135,
alors que l'approche directe pour le DFT en 15 points nécessite 225 opérations complexes.
L'approche " diviser pour mieux combiner " est donc clairement efficace
La procédure de division et de combinaison peut être répétée si M ou L sont des nombres

composites. De toute évidence, l'algorithme le plus efficace de efficient est obtenu lorsque N
est un nombre très composite, c'est-à-dire, N = R v . De tels algorithmes sont appelés
algorithmes radix-R FFT. Quand N = R1v1 R2v2 , alors de telles décompositions sont appelées
algorithmes FFT à radix mixtes. L'algorithme le plus populaire et le plus facilement
programmable est l'algorithme radix-2 FFT.
5.6.2 ALGORITHME de RADIX-2 FFT
Soit N = 2v ; puis nous choisissons L=2 et M = N/ 2 et divisons x(n) en deux séquences de

N/2 points selon (5.48) comme suit
g1 (n) = x(2n) N
; 0≤n≤ −1
g 2 (n) = x(2n + 1) 2
La séquence g1 (n) contient des échantillons d'ordre pair de x(n) , tandis g 2 (n) que contient
des échantillons d'ordre impair de x(n) . Soit G1 (k ) et soit G2 (k ) N/2 points DFTs de g1 (n)
et g 2 (n) , respectivement. Puis (5.49) se réduit à
X ( k ) = G1 ( k ) + WNk G2 ( k ), 0 ≤ k ≤ N-1 (5.61)

Cette formule s'appelle une formule de fusion, qui combine deux DFT à N/2 points en un
DFT à N points. Le nombre total de multiplications complexes se réduit à
N2
CN =
2
+N =o N
2
(
2 )
Cette procédure peut être répétée encore et encore. A chaque étape, les séquences sont
décimées et les plus petits DFT combinés. Cette décimation se termine après les étapes de ν
quand nous avons N séquences à un point, qui sont aussi des DFT à un point. La procédure
qui en résulte est appelée algorithme de décimation dans le temps (DIT-FFT), pour lequel le
nombre total de multiplications complexes est de
C N = Nv = N log 2 N
De toute évidence, si N est grand, alors C N est approximativement linéaire en N, ce qui était
le but de notre algorithme efficace. En utilisant des symétries supplémentaires, C N peut être
N
reduit à log 2 N . Le signal flowgraph pour cet algorithme est illustré à la figure 5.20 pour
2
N=8.
FIGURE 5.20 Structure FFT de décimation dans le temps pour N =8

Dans une approche alternative, nous choisissons M = 2, L = N/2 et suivons les étapes (5.49).
Notez que les DFT initiaux sont des DFT à 2 points, qui ne contiennent pas de multiplications
complexes. Du (5.50)
F (0, m) = x(0, m) + x(1, m)W20

= x(n) + x (n + N 2), 0≤n≤ N / 2
F (1, m) = x(0, m) + x (1, m)W21
= x(n) − x(n + N 2), 0≤n≤ N / 2
Et de (5.51)
G (0, m) = F (0, m)WN0

= x(n) + x(n + N 2), 0≤n≤ N / 2
(5.62)
G (1, m) = F (1, m)WNm
= [ x(n) − x(n + N 2)] WNn , 0≤n≤ N / 2
Soient G (0, m ) = d1 (n) et G (1, m ) = d 2 ( n) pour 0 ≤ n ≤ N/ 2−1 (puisqu'elles peuvent être

considérées comme des séquences temps-domaine) ; puis à partir de (5.52) nous avons
X (0, q ) = X (2q ) = D1 (q )
(5.63)
X (1, q) = X (2q + 1) = D2 (q )
Cela implique que les valeurs DFT X (k ) sont calculées de façon décimée. Par conséquent,
cette approche est appelée un algorithme de décimation en fréquence FFT (DIF-FFT). Son
signal flowgraph est une structure transposée de la structure DIT-FFT, et sa complexité de
N
calcul est également égale à log 2 N .
2
MATLAB fournit une fonction appelée fft pour calculer la DFT d'un vecteur x. Elle est
appelée par X=fft(x,N), qui calcule la DFT à N points.
Si la longueur de x est inférieure à N, alors x est rempli de zéros. Si l'argument N est omis,
alors la longueur du DFT est la longueur de x. Si x est une matrice, alors fft(x,N) calcule le
DFT à N points de chaque colonne de x.
Cette fonction fft est écrite en langage machine et n'utilise pas les commandes MATLAB
(c'est-à-dire qu'elle n'est pas disponible sous la forme a. m_file). Il s'exécute donc très
rapidement. Il s'agit d'un algorithme à rayons mixtes. Si N est une puissance de deux, un
algorithme FFT radix-2 à grande vitesse est utilisé. Si N n'est pas une puissance de deux, alors
N est décomposé en facteurs premiers et un algorithme FFT à rayon mixte plus lent est utilisé.
Enfin, si N est un nombre premier, alors la fonction fft est réduite à l'algorithme DFT brut.
Le DFT inverse est calculé à l'aide de la fonction ifft, qui a les mêmes caractéristiques que fft.
EXEMPLE 5.22 Dans cet exemple, nous allons étudier le temps d'exécution de la fonction
fft pour 1≤N ≤ 2048. Cela révélera la stratégie de la division et de la combinaison pour
diverses valeurs de N. Une mise en garde s'impose. Les résultats obtenus dans cet exemple ne
sont valables que pour les versions 5 et antérieures de MATLAB. A partir de la version 6,
MATLAB utilise un nouveau noyau de calcul numérique appelé LAPACK. Il est optimisé
pour les références de mémoire et l'utilisation du cache et non pour les opérations
individuelles du point floating.
Par conséquent, les résultats de la version 6 et des versions ultérieures sont difficiles à
interpréter. Les temps d'exécution indiqués ici sont également ceux d'un ordinateur spécifique
et peuvent varier d'un ordinateur à l'autre.
Solution
Pour déterminer le temps d'exécution, MATLAB propose deux fonctions. La

fonction horloge fournit la lecture instantanée de l'horloge, tandis que la fonction
etime(t1,t2) calcule le temps écoulé entre deux marques de temps t1 et t2 Pour
déterminer le temps d'exécution, nous allons générer des vecteurs aléatoires de
longueur 1 à 2048, calculer leurs FFTs, et enregistrer le temps de calcul dans un
tableau. Enfin, nous allons tracer ce temps d'exécution par rapport à N .
Script MATLAB:
>> Nmax = 2048; fft_time=zeros(1,Nmax);
>> for n=1:1:Nmax
>> x=rand(1,n);
>> t=clock;fft(x);fft_time(n)=etime(clock,t);
>> end
>> n=[1:1:Nmax]; plot(n,fft_time,’.’)
>> xlabel(’N’);ylabel(’Time in Sec.’) title(’FFT execution times’)
Le graphique des temps d'exécution est illustré à la figure 5.21. Cette intrigue est très
instructive. Les points de l'intrigue ne montrent pas une fonction claire, mais
semblent se regrouper en différentes tendances. Le groupe le plus élevé représente
une dépendance de o(N 2) sur N, ce qui signifie que ces valeurs doivent être des
nombres premiers entre 1 et 2048 pour lesquels l'algorithme FFT est par défaut
l'algorithme DFT.
De même, il existe des groupes correspondant aux dépendances o ( N 2 2) , o ( N 2 3)
, o ( N 2 4) , pour lesquelles le nombre N a moins de décompositions.
Le dernier groupe montre la dépendance (presque linéaire) o ( N log N ) , qui est pour
les
FIGURE 5.21 Temps d'exécution FFT pour 1<= N< = 2048
N = 2v , 0 ≤ ν ≤ 11. Pour ces valeurs de N, on utilise l'algorithme radix-2 FFT.

Pour toutes les autres valeurs, un algorithme FFT à rayons mixtes est utilisé. Cela montre que
la stratégie de division et de combinaison est très efficace lorsque N est très composite. Par
exemple, le temps d'exécution est de 0,16 s pour N = 2048, 2,48 s pour N = 2047 et 46. 96 s
pour N = 2039.
Les fonctions MATLAB développées précédemment dans ce chapitre devraient maintenant

être modified en substituant la fonction fft à la fonction dft. Dans l'exemple précédent, il faut
prendre soin d'utiliser un N. Une bonne pratique est de choisir N = 2v à moins qu'une
situation specifique ne l'exige autrement.
5.6.4 CONVOLUTIONS RAPIDES
La fonction conv de MATLAB est implémentée à l'aide de la fonction filtre (qui est écrite en
C) et est très efficace pour des valeurs inférieures à N (< 50).
Pour des valeurs plus élevées de N, il est possible d'accélérer la convolution en utilisant
l'algorithme FFT. Cette approche utilise la convolution circulaire pour mettre en œuvre la
convolution linéaire et la FFT pour mettre en œuvre la convolution circulaire. L'algorithme
qui en résulte est appelé algorithme de convolution rapide. De plus, si nous choisissons N =2ν
et implémentons la FFT radix-2, alors l'algorithme s'appelle une convolution à grande vitesse.
Soit une séquence x1 (n) de N1 -points et une séquence x2 (n) de N 2 -points ; alors pour la
convolution à grande vitesse, N est choisi pour être
 log 2 (N1 +N2 -1)
N = 2 (5.64)
Où  x
  est le plus petit entier supérieur à x (aussi appelé fonction plafond). La convolution
linéaire x1 (n) ∗ x2 (n) peut maintenant être implémentée par deux FFT à N-points, un IFFT à
N-points et un produit scalaire à N points.
x1 (n) ∗ x2 (n) = IFFT [FFT [x1 (n)] · FFT [x2 (n)]] (5.65)
Pour des valeurs élevées de N, (5,65) est plus rapide que la convolution dans le domaine
temporel, comme nous le voyons dans l'exemple suivant.
EXEMPLE 5.23
Pour démontrer l'efficacité de la convolution à grande vitesse, comparons les temps

d'exécution de deux approches. Soit x1 (n) un nombre aléatoire de L-point uniformément
réparti entre[0, 1], et soit x2 (n) une séquence aléatoire gaussienne de L-point avec moyenne 0
et variance 1. Nous déterminerons les temps d'exécution moyens pour 1≤ L≤ 150, dans lequel
la moyenne est calculée sur les 100 réalisations de séquences aléatoires. (Veuillez consulter la
mise en garde donnée dans l'exemple 5.22.)
Solution script MATLAB:

conv_time = zeros(1,150); fft_time = zeros(1,150);
%
for L = 1:150
tc = 0; tf=0;
N= 2*L-1; nu = ceil(log10(NI)/log10(2)); N = 2^nu;
for I=1:100
h= randn(1,L); x = rand(1,L);
t0 = clock; y1 = conv(h,x); t1=etime(clock,t0); tc = tc+t1;
t0 = clock; y2 = ifft(fft(h,N).*fft(x,N)); t2=etime(clock,t0);
tf = tf+t2;
end
%
conv_time(L)=tc/100; fft_time(L)=tf/100;
end
%
n= 1:150; subplot(1,1,1);
plot(n(25:150),conv_time(25:150),n(25:150),fft_time(25:150))
La figure 5.22 montre la convolution linéaire et les temps de convolution à grande vitesse
pour 25≤L≤150. Il est à noter que ces périodes sont influencées par la
FIGURE 5.22 Comparaison des temps de convolution linéaires et à grande vitesse
plate-forme informatique utilisée pour exécuter le script MATLAB. Le tracé de la figure 5.22
a été obtenu sur un ordinateur 486 de 33 MHz. Il montre que pour des valeurs faibles de L, la
convolution linéaire est plus rapide. Le point de croisement semble être L = 50, au-delà
duquel le temps de convolution linéaire augmente de façon exponentielle, tandis que le temps
de convolution à grande vitesse augmente de façon assez linéaire. Notez que puisque N = 2v ,
le temps de convolution à grande vitesse est constant sur une plage de L .
5.6.5 CONVOLUTIONS DE BLOCS À GRANDE VITESSE
Plus tôt, nous avons discuté d'un algorithme de convolution par blocs appelé la méthode de
chevauchement et de sauvegarde (et la méthode de chevauchement et d'addition qui
l'accompagne), qui est utilisée pour convolutionner une très grande séquence avec une
séquence relativement petite. La fonction MATLAB ovrlpsav développée dans cette section
utilise le DFT pour implémenter la convolution linéaire. Nous pouvons maintenant remplacer
le DFT par l'algorithme FFT radix-2 pour obtenir un algorithme de chevauchement et de
sauvegarde à grande vitesse. Pour réduire davantage les calculs, la TFR de la séquence la plus
courte (fixed) ne peut être calculée qu'une seule fois. La fonction hsolpsav suivante montre cet
algorithme.
function [y] = hsolpsav(x,h,N)

% High-speed Overlap-Save method of block convolutions using FFT
% --------------------------------------------------------------
% [y] = hsolpsav(x,h,N)
%y= output sequence
%x= input sequence
%h= impulse response
%N= block length (must be a power of two)
%
N= 2^(ceil(log10(N)/log10(2));
Lenx = length(x); M = length(h);
M1 = M-1; L = N-M1; h = fft(h,N);
%
x= [zeros(1,M1), x, zeros(1,N-1)];
K= floor((Lenx+M1-1)/(L)); % # of blocks
Y= zeros(K+1,N);
for k=0:K
xk = fft(x(k*L+1:k*L+N));
Y(k+1,:) = real(ifft(xk.*h));
end
Y= Y(:,M:N)’; y = (Y(:))’;
Un modification similaire peut être fait à l'algorithme de chevauchement et d'ajout.

MATLAB fournit également la fonction fftfilt pour implémenter l'algorithme de
chevauchement et d'ajout.

Chapitre 5

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Chapitre 5

Transféré par

Droits d'auteur :

Formats disponibles

chapitre 5

La Transformée de Fourier discrète

I. les séries de Fourier discretes

Où { Xɶ (k ), k = 0, ±1,…,} sont appelées la série discrète de Fourier coeﬃcients, qui sont

EXEMPLE 5.1 Trouver la représentation DFS de la séquence périodique

ɶx ( n) = {…,0,1, 2,3,0,1, 2,3,0,1, 2,3,…,}

5.1.1 IMPLEMENTATION MATLAB

Il en résultera une implémentation de deux boucles for--end imbriquées. C'est clairement

function [Xk] = dfs(xn,N)

Le DFS de l'exemple 5.1 peut être calculé à l'aide de MATLAB comme

>> xn = [0,1,2,3]; N = 4; Xk = dfs(xn,N)

La fonction idfs suivante implémente l'équation de synthèse.

function [xn] = idfs(Xk,N)

où N est la période fondamentale et L/N est le rapport cyclique.

a. Déterminer une expression pour Xɶ ( k ) en termes de L et N .

FIGURE 5.1 Periodic square wave sequence

La dernière étape découle de la somme de la formule des termes géométriques (2.7) du

or l’amplitude de Xɶ (k ) est donnée par

b. Le script MATLAB pour L = 5 et N = 20:

>>L=5;N=20;k= [-N/2:N/2]; % Sq wave parameters

5.1.2 Relation avec la transformée en Z

Soit x ( n) une séquence de durée finie de durée N telle que

Alors nous pouvons calculer sa transformée en z :

Maintenant, nous construisons une séquence périodique xɶ( n) en répétant périodiquement

La DFS de xɶ( n) est donnée par

En le comparant avec (5.9), nous avons

Xɶ (k ) = X ( z ) z=e j 2Nπ k (5.12)

5.1.3 RELATION AVEC LE DTFT

En comparant (5.13) avec (5.11), nous avons

Solution La séquence x ( n) n'est pas périodique mais de durée finie.

a. La transformée de Fourier en temps discret est donnée par

II. ÉCHANTILLONNAGE ET RECONSTRUCTION DANS LE

et nous supposons que le ROC de X ( z ) inclut le cercle unité. Nous échantillonnons X ( z )

qui est périodique avec la période N . Enfin, nous calculons la IDFS de Xɶ (k ) ,

ɶx( n) = IDFS  Xɶ (k )

x(n) = ɶx(n) pour 0 ≤ n ≤ (N − 1)

où ℜ N ( n) est appelée une fenêtre rectangulaire de longueur N . Nous avons donc le

THEOREM 1 Échantillonnage de fréquence

Solution D'après le tableau 4.1, la transformée en z de x ( n) est

et le calcul inverse de DFS pour déterminer la séquence de domaine temporel correspondante.

>> N = 5; k = 0:1:N-1; % sample index

FIGURE 5.3 Tracés de l’exemple 5.5

5.2.1 LA FORMULE DE RECONSTRUCTION DE LA TRANSFORMEE EN Z

X ( z ) = Ζ  x (n) = Ζ  xɶ(n)ℜ N (n)

Cette approche aboutit à la formule de reconstruction du domaine z.

5.2.2 LA FORMULE D'INTERPOLATION DTFT

La formule de reconstruction (5.17) peut être spécialisée pour la transformée de Fourier en

Ceci est la formule d'interpolation DTFT pour reconstruire X (e jω ) à partir de ses

La formule d'interpolation DTFT (5.19) est similaire.

Cependant, il y a quelques diﬀerences. Premièrement, la formule dans le domaine temporel

5.2.3 IMPLEMENTATION MATLAB

xɶ(n) = x (n mod N ) (5.21)

Alors les relations compactes entre x ( n) et xɶ(n) sont

ɶx(n) = x ((n)) N ( Extension périodique)

À partir du théorème d'échantillonnage en fréquence, nous concluons que N échantillons

5.3.1 IMPLEMENTATION MATLAB

EXEMPLE 5.6 Soit x ( n) une sequence à 4-points.

a. Calculez la transformée de Fourier en temps discret X (e jω ) et tracez son amplitude et

a. La transformée de Fourier à temps discret est donnée par

Les graphiques sont illustrés à la figure 5.4.

b. Désignons la DFT à 4 points par X 4 (k ) . Alors

>> x = [1,1,1,1]; N = 4; X = dft(x,N);

FIGURE 5.4 The DTFT plots in Example 5.6

EXEMPLE 5.7 Comment pouvons-nous obtenir d'autres échantillons de la DTFT X (e jω ) ?

>> n = [0:1:99]; x = cos(0.48pin)+cos(0.52pin);