Escreva um script em Matlab para obter os graficos dos sinais a partir das séries Exponenciais de Fourier. Teste seus resultados.
% arquivo: seriesexp.m
% série exponencial
% ------------------
clear; close all; home, clc;
t = linspace(-8,8,500);
% parâmetros
T0 = 4; % <- mudeo o período do sinal
w0 = 2*pi/TO;
% série exponencial
X0 = 1/2; % <- mude o coeficiente X0
Xk=@(k) (1/(k*pi))*sin(k*pi/2); % <- mude o coeficiente Xk
x = XO*ones(1,length(t));
N=200; % <- mude o número de termos
for k=-N:1:-1
x = x + Xk(k)*exp(j*k*w0.*t);
end
for k=1:1:N
x = x + Xk(k)*exp(j*k*w0.*t);
end
plot(t,x);grid on;
Passo 1
O que o enunciado pede e quais são os dados (erros/typos no código dado).
Pedido: escrever um script em Matlab que gere o gráfico do sinal reconstruído a partir da série exponencial de Fourier e testar os resultados.
Código enviado (trechos) contém algumas variáveis e erros de digitação que precisam ser corrigidos. Entre os pontos importantes a reparar:
A variável do período foi escrita como T0 = 4; mas depois usada como TO em w0 = 2*pi/TO; — isso está errado.
O coeficiente DC foi escrito X0 = 1/2; mas depois usado como XO em x = XO*ones(...) — typo.
A definição de Xk é \displaystyle X_k = \frac{\sin(k\pi/2)}{k\pi}. Para k=0 essa fórmula tem divisão por zero; é preciso tratar k=0 separadamente (o limite vale 1/2).
O código soma separadamente para k=-N:-1 e k=1:N — isso funciona, mas pode ser simplificado e é importante garantir que a parte real do sinal seja exibida (usar conjugalidade dos coeficientes quando o sinal for real).
Uso de j é aceitável, mas para clareza é recomendado usar 1i.
Passo 2
Breve aula — o que é a série exponencial de Fourier e quais fórmulas vamos usar (explicação didática).
A série exponencial de Fourier de um sinal periódico x(t) de período T_0 é a soma
x(t)=\sum_{k=-\infty}^{\infty} X_k\,e^{j k \omega_0 t},
onde \omega_0=\dfrac{2\pi}{T_0} é a frequência angular fundamental.
Os coeficientes X_k são dados por
X_k=\frac{1}{T_0}\int_{t_0}^{t_0+T_0} x(t)\,e^{-j k \omega_0 t}\,dt,
onde t_0 é qualquer ponto inicial em um período.
No caso do código que tu enviou, os coeficientes propostos são
Explicando devagar: quando k\to0 a expressão \sin(k\pi/2)/(k\pi) tem forma indeterminada 0/0; aplicando limite (ou regra de Taylor) obtemos 1/2, por isso devemos definir X_0=1/2.
Observação prática: se os coeficientes satisfazem X_{-k}=\overline{X_k} (conjugado complexo), a soma dá um sinal real — isto é útil para construir o sinal computacionalmente somando apenas k>0 e adicionando o conjugado.
Passo 3
Como vamos implementar isso no Matlab — pontos a ter em mente (explicação passo a passo das escolhas do script).
Vetor tempo: escolher t suficientemente denso para uma boa figura. Por exemplo, t = linspace(-8,8,2000);.
Periodo e frequência: definir T_0 e \omega_0 corretamente: T0 = 4; w0 = 2*pi/T0;.
Definir função de coeficientes que trate k=0. Em Matlab é conveniente criar um anonymous function que aceita vetor de índices e devolve os valores correspondentes; para evitar divisão por zero usar um teste k==0.
Número de harmônicos N: controlar o quanto aproximamos a soma infinita. Escolher N menor no teste inicial (por ex. 20) e aumentar para ver convergência (por ex. 200).
Montagem da série: duas opções
somar para k=-N:-1 e k=0 e k=1:N (mais direto e explícito);
somar só para k=1:N usando a simetria e adicionando coef*exp(1i*k*w0*t) + conj(coef)*exp(-1i*k*w0*t) para garantir resultado real (mais eficiente e explícita a real-idade).
Plot: mostrar real(x) no gráfico, grade, rótulos e título com o valor de N. Opcional: plotar magnitude dos coeficientes com stem.
Passo 4
Detalhamento do código linha a linha (o que cada linha faz; estilo de “faça isto na prova”).
Vou explicar as linhas essenciais e por que elas são assim — para que na hora da prova tu saiba o que escrever.
clear; close all; clc; — limpa workspace e figuras; sempre comece assim para evitar lixo de execuções anteriores.
t = linspace(-8,8,2000); — cria vetor tempo de -8 a 8 com 2000 pontos (quanto mais pontos, mais suave o traçado).
Para cada kk, se kk==0 retorna X0; caso contrário retorna \sin(kk\pi/2)/(kk\pi).
arrayfun aplica a função escalar a cada elemento do vetor k.
N = 200; — número de harmônicos na soma (ajusta conforme tempo de execução / necessidade de precisão).
x = X0*ones(size(t)); — inicializa a soma com a componente DC.
Loop para somar harmônicos (usar simetria para garantir real):
for k = 1:N
C = Xk(k); — coeficiente X_k.
x = x + C*exp(1i*k*w0.*t) + conj\text{(C)}*exp(-1i*k*w0.*t); — soma o termo positivo e o seu conjugado; assim a soma total permanece real (somente pequenas aprox. numéricas devidas a precisão complexa).
plot(t, real(x),'LineWidth',1.2); grid on; xlabel('t'); ylabel('x(t)'); title(['Reconstrução série exponencial: N=' num2str(N)]); — plota a parte real de x(t) e deixa o gráfico apresentável.
Opcional: plotar stem dos coeficientes para verificar distribuição em k:
Dica de prova: sempre trate o caso k=0 explicitamente; indica que entendes limites e evita erro de divisão por zero.
Passo 5
Testes sugeridos e interpretação dos resultados (como avaliar se está correto).
Rodar o script com N=5, 20, 100, 200 e comparar os gráficos: a aproximação melhora e surgem menos distorções conforme N cresce.
Observar a presença de oscilações tipo Gibbs se o sinal original tiver descontinuidades (isso é normal e mostra que a série converge ponto a ponto exceto exatamente nas descontinuidades).
Verificar o gráfico de stem(k,|X_k|) para ver quantos harmônicos têm magnitude significativa; isso ajuda a escolher N eficiente.
Se o sinal é conhecido (por ex. um pulso), comparar com a expressão analítica no tempo (se disponível) para confirmar.
Passo 6
Erros corrigidos do código original (resumo rápido, para gravar na prova)
Corrigido TO → T0 e XO → X0.
Tratado k=0 explicitamente para evitar divisão por zero.
Usei soma com conjugados para garantir sinal real e reduzir trabalho de somar índices negativos.
Usei 1i para a unidade imaginária (mais claro que j em códigos onde j pode ser sobrescrito).
Resposta
% arquivo: seriesexp_fixed.m% Série exponencial de Fourier - reconstrução e testes
clear; close all; clc;
% vetor tempo
t = linspace(-8,8,2000);
% parâmetros
T0 = 4; % período
w0 = 2*pi/T0; % frequência angular fundamental% coeficientes (tratando k = 0)
X0 = 1/2;
Xk = @(k) arrayfun(@(kk) (kk==0).*X0 + (kk~=0).*sin(kk*pi/2)./(kk*pi), k);
% número de harmônicos (ajuste para ver convergência)
N = 200;
% inicializa com componente DC
x = X0 * ones(size(t));
% soma dos harmônicos usando simetria conjugada para garantir sinal realfor k = 1:N
C = Xk(k);
x = x + C.*exp(1i*k*w0.*t) + conj\text{(C)}.*exp(-1i*k*w0.*t);
end% plot do sinal reconstruídofigure;
plot(t, real(x), 'b', 'LineWidth', 1.2);
grid on;
xlabel('t');
ylabel('x(t)');
title(['Reconstrução da série exponencial: N = ' num2str(N)]);
% plot dos coeficientes (opcional)
kvec = -N:N;
Xvec = Xk(kvec);
figure;
stem(kvec, real(Xvec), 'filled');
hold on;
stem(kvec, imag(Xvec), 'r');
grid on;
xlabel('k');
ylabel('X_k');
title('Coeficientes X_k (parte real e imaginária)');
legend('Re\{X_k\}', 'Im\{X_k\}');