Sistemas de Processamento Digital

Engenharia de Sistemas e Informática

Ficha 4
2005/2006 4.º Ano/ 2.º Semestre

DFS – Série Discreta de Fourier

DFT – Transformada Discreta de Fourier
Convolução Circular
Série Discreta de Fourier (DFS)
N −1 2π
−j
Equação de Análise: X ( k ) = DFS ⎡⎣ x ( n ) ⎤⎦ = ∑ x ( n )W
n =0
nk
N com WN = e N

N −1
1
Equação de Síntese: x ( n ) = IDFS ⎡⎣ X ( k ) ⎤⎦ =
N
∑ X ( k )W
k =0
− nk
N

Exercício 1
Implemente em MatLab as duas funções DFS e IDFS na forma mais eficiente através da utilização de uma
multiplicação matriz-vector.

function [Xk] = dfs(xn)

% Computes Discrete Fourier Series Coefficients
% ---------------------------------------------
% [Xk] = dfs(xn)
% Xk = DFS coeff. array over 0 <= k <= N-1
% xn = One period of periodic signal over 0 <= n <= N-1
%
N = length(xn);
n = 0:N-1; % row vector for n
k = 0: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

function [xn] = idfs(Xk)

% Computes Inverse Discrete Fourier Series
% ----------------------------------------
% [xn] = idfs(Xk)
% xn = One period of periodic signal over 0 <= n <= N-1
% Xk = DFS coeff. array over 0 <= k <= N-1
%
N = length(Xk);
n = 0:N-1; % row vector for n
k = 0: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); % IDFS matrix
xn = (Xk * WNnk)/N; % row vector for IDFS values

Sistemas de Processamento Digital Manuel Baptista & Ernesto Afonso 1

Exercício 2

Determine a DFS da seguinte sequência periódica: x( n ) = {..., 0 ,1, 2 ,3, 0 ,1, 2 ,3, 0 ,1, 2 ,3,...}
↑
a) Por cálculo analítico

Considerando N = 4 obtém-se

Então:

b) Por cálculo computacional (usando a função implementada anteriormente).

Exercício 3
Uma sequência periódica duma onda quadrada é dada por:

⎧1, mN ≤ n ≤ mN + L − 1
x ( n) = ⎨ com m = 0, ± , ±2,...
⎩0 , mN + L ≤ n ≤ (m + 1) N − 1
onde N é o período fundamental e L/N é o duty cycle.
Para L=5 e N=20 temos a seguinte sequência:
Três periodos de x(n)
1.5

1
x(n)

0.5

-0.5
-20 -10 0 10 20 30
n
L = 5; N = 20;
x = [ones(1,L), zeros(1,N-L)];
xn = [x x x];
n = -N:1:2*N-1;
stem(n,xn); xlabel('n'); ylabel('x(n)')
title('Três periodos de x(n)')
axis([-N,2*N-1,-0.5,1.5])

Sistemas de Processamento Digital Manuel Baptista & Ernesto Afonso 2

 a) Determine a expressão para X ( k ) em termos de L e N.

com

b) Trace o módulo X ( k ) para L=5 e N=20, L=5 e N=40, L=5 e N=60, L=7 e N=60. Comente os
resultados.
% Exercício 3.b)
L = [5 5 5 7];
N = [20 40 60 60];
for r=1:4
xn = [ones(1,L(r)), zeros(1,N(r)-L(r))];
Xk = dfs(xn);
magXk = abs([Xk(N(r)/2+1:N(r)) Xk(1:N(r)/2+1)]);
k = [-N(r)/2:N(r)/2];
subplot(4,1,r); stem(k,magXk);
axis([-N(r)/2,N(r)/2,-0.5,L(r)+.5])
xlabel('k'); ylabel('X(k)');
title(sprintf('DFS para L=%i e N=%i',L(r),N(r)))
end

Relação da DFS com a DTFT (Discrete Time Fourier Transform)

N −1
Considerando que a DTFT é dada por: X ( e jω ) = ∑ x ( n ) e− jω n .
n=0

Comparando a DFS temos X ( k ) = X ( e jω ) se ω = 2π

N k . O intervalo de amostragem é w = 2π
N .

Exercício 4

Seja a sequência x( n ) = {..., 0 ,1, 2 ,3, 0 ,1, 2 ,3, 0 ,1, 2 ,3,...} do exercício 1.
↑
a) Determine a sua DTFT X ( e jω )

b) Amostre X e ( ) em kw =
jω 2π
N k , k = 0 ,1, 2 ,3 e verifique se é igual a X ( k ) do exercício 1.

→ conforme esperado!

Sistemas de Processamento Digital Manuel Baptista & Ernesto Afonso 3

Transformada Discreta de Fourier (DFT)
N −1 2π
−j
Transformada directa: X ( k ) = DFT ⎡⎣ x ( n ) ⎤⎦ = ∑ x ( n ) W nk
N com 0 ≤ k ≤ N − 1 e WN = e N

n =0

N −1
1
Transformada inversa: x ( n ) = IDFT ⎡⎣ X ( k ) ⎤⎦ =
N
∑ X ( k )W
k =0
− nk
N com 0 ≤ n ≤ N − 1

Se x ( n ) = x ( ( n ) ) N = x ( n mod N ) então a DFS e a DFT são idênticas.

Crie em MatLab as duas funções DFT e IDFT através da alteração dos nomes da DFS e IDFS.
function [Xk] = dft(xn) e function [xn] = idft(Xk)
Crie em MatLab a função mod da seguinte forma:
function m = mod(n, N)
m = rem(n, N);
m = n + N;
m = rem(n, N);

Exercício 5

x ( n ) = 10 ( 0.8 ) , 0 ≤ n ≤ 10 e a propriedade de simetria circular (folding):

n
Considere a sequência

⎧⎪ x ( 0 ) , n=0
x ( ( −n ) ) N = ⎨ .
⎪⎩ x ( N − n ) , 1 ≤ n ≤ N − 1

a) Determine e trace e x ( ( − n ) )11 . Compare os dois sinais.

% Exercício 5.a)
n = 0:10; x = 10*(0.8) .^ n;
y = x(mod(-n,11)+1);
subplot(2,1,1); stem(n,x); title('Sequencia Original ')
xlabel('n'); ylabel('x(n)'); axis([-0.5,10.5,-1,11])
subplot(2,1,2); stem(n,y); title('Sequencia simetrica Circular')
xlabel('n'); ylabel('x(-n mod 11)'); axis([-0.5,10.5,-1,11])
Sequencia Original

10
x(n)

0
0 1 2 3 4 5 6 7 8 9 10
n
Sequencia simetrica Circular

10
x(-n mod 11)

0
0 1 2 3 4 5 6 7 8 9 10
n

Sistemas de Processamento Digital Manuel Baptista & Ernesto Afonso 4

 b) Verifique a propriedade de simetria circular e da respectiva transformada:

⎧⎪ X ( 0 ) , k =0
DFT ⎡⎣ x ( ( − n ) ) N ⎤⎦ = X ( ( − k ) ) N = ⎨
⎪⎩ X ( N − k ) , 1 ≤ k ≤ N − 1

Nota: no MatLab, a simetria circular obtém-se fazendo x = x mod ( − n,N ) + 1 . ( )

% Exercício 5.b)
X = dft(x,11); Y = dft(y,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(Y)); axis([-0.5,10.5,-5,50])
title('Real{DFT[x((-n))11]}'); xlabel('k');
subplot(2,2,4); stem(n,imag(Y)); axis([-0.5,10.5,-20,20])
title('Imag{DFT[x((-n))11]}'); xlabel('k');
RealDFT[x(n)] ImagDFT[x(n)]
50 20
40
10
30
20 0

10 -10
0
-20
0 5 10 0 5 10
k k
RealDFT[x((-n))11] ImagDFT[x((-n))11]
50 20
40
10
30

20 0

10 -10
0
-20
0 5 10 0 5 10
k k

Exercício 6
Desenvolva uma função em MatLab que decomponha uma sequência de N pontos nas suas componentes
circulares Par e Ímpar, definidas da seguinte forma:

x par ( n ) 1 ⎡ x ( n ) + x ( ( −n ) ) ⎤ e xímpar ( n ) 1 ⎡ x ( n ) − x ( ( −n ) ) ⎤
2 ⎣ N⎦ 2 ⎣ 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));

Sistemas de Processamento Digital Manuel Baptista & Ernesto Afonso 5

Exercício 7

x ( n ) = 10 ( 0.8 ) , 0 ≤ n ≤ 10 .
n
Considere novamente a sequência

a) Decomponha e trace as componentes par e ímpar de x ( n ) .

Circular-even component
10

xec(n)

0
0 1 2 3 4 5 6 7 8 9 10
n
Circular-odd component
4

2
xoc(n)

-2

-4
0 1 2 3 4 5 6 7 8 9 10
n

b) Verifique as seguintes propriedades da simetria circular:

X par ( k ) = Re ⎡⎣ X ( k ) ⎤⎦ = Re ⎡⎣ X ( ( −k ) ) N ⎤⎦ e X ímpar ( k ) = Im ⎡⎣ X ( k ) ⎤⎦ = Im ⎡⎣ X ( ( − k ) ) N ⎤⎦
% Exercício 7.b)
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');
RealDFT[x(n)] ImagDFT[x(n)]
50 20
40
10
30
20 0

10 -10
0
-20
0 5 10 0 5 10
k k
DFT[xec(n)] DFT[xoc(n)]
50 20
40
10
30

20 0

10 -10
0
-20
0 5 10 0 5 10
k k

Sistemas de Processamento Digital Manuel Baptista & Ernesto Afonso 6

Exercício 8

x ( n ) = 10 ( 0.8 ) , 0 ≤ n ≤ 10 .
n
Considere novamente a sequência

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)

if length(x) > N % Check for length of x

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);
a) Represente x ( ( n + 4 ) )11 que representa um deslocamento circular em direcção à esquerda.
x(n) Original Extensão periodica

10 10

5 5

0 0
-5 0 5 10 15 -5 0 5 10 15
n n
Deslocamento Periodico Deslocamento circular
10 10

5 5

0 0
-5 0 5 10 15 -5 0 5 10 15
n n
b) Represente x ( ( n − 3) )15 que representa um deslocamento circular em direcção à direita, onde se
assume que a sequência tem um comprimento de 15 pontos (por adição de zeros).

Sequência original Sequência com deslocamento circular, N=15

10 10

8 8
x((n-3) mod 15)

6 6
x(n)

4 4

2 2

0 0

0 5 10 15 0 5 10 15
n n

Sistemas de Processamento Digital Manuel Baptista & Ernesto Afonso 7

 c) Represente x ( ( n − 6 ) )15 que representa um deslocamento circular em direcção à direita.
Sequência original Sequência com deslocamento circular, N=15

10 10

8 8

x((n-6) mod 15)

6 6
x(n)
4 4

2 2

0 0
0 5 10 15 0 5 10 15
n n

Convolução Circular
N −1
Definição: N x ( n) = ∑ x ( m) x (( n − m)) , 0 ≤ n ≤ N −1
x1 ( n ) ○ 2 1 2 N
m=0

Propriedades da convolução circular:

Convolução no tempo: DFT ⎡⎣ x1 ( n ) ○

N x ( n ) ⎤ = X ( k ) .X ( k )
2 ⎦ 1 2

Multiplicação no tempo: DFT ⎡⎣ x1 ( n ) .x2 ( n ) ⎤⎦ = 1

N X1 ( k ) ○
N X (k )
2

Relação com a convolução linear: x1 ( n ) ○

N x2 ( n ) = x1 ( n ) ∗ x2 ( n ) se a x ( n ) e x ( n ) forem
1 2
acrescentados zeros de forma a terem N=N1+N2-1 pontos.

Exercício 9

Considere as sequências x1 ( n ) = {1, 2 , 2} e x1 ( n ) = {1, 2 , 3, 4} .

a) Calcule a convolução circular de 4 pontos x1 ( n ) ○

4 x ( n) .
2

Abordagem no tempo:

Para n = 0:

Para n = 1:

Para n = 2:

Para n = 3:

Abordagem na frequência:
DFT de x1(n):
DFT de x2(n):
Multiplicação:
Após a IDFT: → conforme era esperado!

Sistemas de Processamento Digital Manuel Baptista & Ernesto Afonso 8

 b) Utilize o MatLab para calcular a convolução circular.
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))

if length(x1) > N % Check for length of x1

error('N must be >= the length of x1')
end
if length(x2) > N % Check for length of x2
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: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*H';

Aplicando a função circonvt:

>> x1 = [1,2,2]; x2 = [1,2,3,4];
>> y = circonvt(x1,x2,4)
y =
15 12 9 14
c) Estude o efeito de N na convolução circular (N ≥ 4):

i) x1 ( n ) ○
5 x ( n)
2

>> y = circonvt(x1,x2,5)
y =
9 4 9 14 14
ii) x1 ( n ) ○
6 x2 ( n )

>> y = circonvt(x1,x2,6)
y =
1 4 9 14 14 8
Comentário: Comparando com a convolução linear,
>> y = conv(x1,x2)
y =
1 4 9 14 14 8
observa-se que, ao aumentar o valor de N na convolução circular, se obtêm os pontos
suplementares da convolução linear, tendo ambas resultado idêntico quando N = N1 + N2 – 1.

Sistemas de Processamento Digital Manuel Baptista & Ernesto Afonso 9

Exercício 10

Considere as sequências x1 ( n ) = {1, 2 , 2 , 1} e x1 ( n ) = {1, − 1, − 1, 1} .

a) Determine a convolução linear x1 ( n ) ∗ x2 ( n ) .

>> x1 = [1,2,2,1]; x2 = [1,-1,-1,1];
>> y = conv(x1,x2)
y =
1 1 -1 -2 -1 1 1
b) Determine a convolução circular de modo a que seja igual ao resultado anterior.
Calcula-se a convolução circular fazendo N = 4 + 4 -1 = 7:
>> y = circonvt(x1,x2,7)
y =
1 1 -1 -2 -1 1 1
obtendo-se o mesmo resultado da alínea a).

Exercício 11

Considere as mesmas sequências x1 ( n ) e x2 ( n ) do exercício 10.

a) Calcule a convolução circular para N = 6, 5, 4 e 3.

Para N = 6:

Para N = 5:

Para N = 4:
b) Verifique as relações de erro, para cada N, relativamente à convolução linear.

Sendo a convolução linear x3 ( n ) = {1,1,-1,-2 , −1,1,1} , o erro é dado pela diferença entre a
convolução circular e a linear, considerando os primeiros N pontos.

Para N = 6:

Para N = 5:
Para N = 4:

Convolução por Blocos

Procedimento a executar para calcular a convolução com blocos de N pontos dos sinais x ( n ) com P pontos
e h ( n ) com M pontos (com P > M):

- Criar a sequência x̂(n) a partir de x ( n ) , acrescentando M-1 zeros no início e N-1 zeros no final:

x̂(n) {0 , 0 , 0 ,..., 0 ,x(n), 0 , 0 , 0 ,..., 0} ;

M −1 N −1

- Considerando L = N-M+1, então o bloco número k, xk ( n ) com 0 ≤ n ≤ N − 1 , é dado por

xk ( n ) = ˆx ( m ) , kL ≤ m ≤ kL + N − 1 e k ≥ 0 . Cada bloco é constituído por N pontos de x̂ ( n )
dos quais M-1 pontos são sobrepostos com o bloco anterior.

⎡ P + M − 2⎤
- O número total de blocos é dado por K =⎢ ⎥⎦ + 1 , onde [.] significa truncar.
⎣ L

Sistemas de Processamento Digital Manuel Baptista & Ernesto Afonso 10

 - A cada bloco é aplicada a convolução circular yk ( n ) = xk ( n ) ○
N h ( n) .

- Finalmente, eliminam-se os M-1 primeiros valores de cada yk ( n ) e juntam-se para formar y ( n )

Exercício 12

Considere as mesmas sequências x ( n ) = n + 1, 0 ≤ n ≤ 9 e h ( n ) = {1, 0 , −1} .

a) Calcule y( n ) = x ( n ) ∗ h( n ) pelo método de “overlap-save”, considerando P = 6.

Como M = 3 é necessário sobrepor cada bloco com o anterior em duas amostras. Se x ( n ) for uma
sequência de 10 pontos, serão necessários (M-1) = 2 zeros no início. Como N = 6, serão necessárias
as 3 seguintes secções:

Calculando a convolução circular de h ( n ) com cada um dos blocos:

O vector y ( n ) obtém-se eliminando as primeiras 2 amostras de cada bloco yk ( n ) , juntando-os

depois numa única sequência .

A convolução linear calculada directamente é .

b) Implemente no MatLab o método de “overlap-save”.

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

Sistemas de Processamento Digital Manuel Baptista & Ernesto Afonso 11