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
X_k=\frac{\sin(k\pi/2)}{k\pi}\quad\text{para }k\ne0, \qquad X_0=\frac12.
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
    1. somar para k=-N:-1 e k=0 e k=1:N (mais direto e explícito);
    2. 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).
  • T0 = 4; — define o período T_0.
  • w0 = 2*pi/T0; — calcula \omega_0=\dfrac{2\pi}{T_0}. Nota: corrigido TOT0.
  • X0 = 1/2; — coeficiente DC X_0.
  • Xk = @(k) arrayfun(@(kk) (kk==0).*X0 + (kk~=0).*sin(kk*pi/2)./(kk*pi), k);
    • Xk é uma função anônima que aceita vector k.
    • 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:
    • kvec = -N:N; Xvec = Xk(kvec); figure; stem(kvec, real(Xvec),'filled'); hold on; stem(kvec, imag(Xvec),'r'); ...
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 TOT0 e XOX0.
  • 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 real
for 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ído
figure;
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\}');

Exercícios relacionados