Escreva um script em Matlab para obter os graficos dos sinais a partir das séries Trigonométricas de Fourier. Teste seus resultados.
% arquivo: series.m
% série trigométrica
% ------------------
clear; close all; home, clc;
t = linspace(-8,8,500);
% parâmetros
TO = 2; % mude aqui o período do sinal
w0 = 2*pi/TO;
a0 = 1/3 % <- Escreva o coeficiente a0;
ak =@(k) (4*(-1)^k)/(k*pi)^2; % <- Escreva o coeficiente ak;
bk =@(k) 0; % <- Escreva o coeficiente bk;
%
x = a0*ones(1,length(t));
N=200; % <- Mude o número de termos da série
for k=1:N
    x = x + ak(k)*cos(k*w0.*t) +bk(k)*sin(k*w0.*t);
end
plot(t,x);grid on;

Passo 1

O que o enunciado pede e o que já foi dado.
  • Pedido: escrever um script em Matlab que gere gráficos do sinal definido pela série trigonométrica de Fourier e testar os resultados.
  • O enunciado me deu um script-base (arquivo series.m) com as seguintes informações (peguei estes nomes e valores do código enviado):
    • vetor de tempo: t = linspace(-8,8,500);
    • período: TO = 2;
    • pulsação fundamental: w0 = 2*pi/TO;
    • coeficiente constante: a0 = 1/3
    • coeficientes: ak =@(k) (4*(-1)^k)/(k*pi)^2; e bk =@(k) 0;
    • soma parcial da série feita com N=200 termos num for k=1:N.
  • Perguntas implícitas que vou resolver: (1) corrigir / completar o script para rodar sem erros; (2) explicar didaticamente como a série está sendo construída e por que esses coeficientes; (3) mostrar como testar/visualizar a convergência (variação com N); (4) sugerir pequenas melhorias e uma versão vetorizada para acelerar.

Passo 2

O que é a série trigonométrica de Fourier e como ela é escrita (aulas básicas, passo a passo).
  • A série trigonométrica de Fourier de um sinal periódico x(t) de período T_0 tem a forma
x(t)=a_0+\sum_{k=1}^{\infty} \left[a_k\cos(k\omega_0 t)+b_k\sin(k\omega_0 t)\right],
onde \omega_0=\dfrac{2\pi}{T_0}.
  • Significado de cada termo:
    • a_0 é a componente média (constante) do sinal.
    • Os termos com a_k são harmônicas pares (cossenos) que representam componentes em fase zero.
    • Os termos com b_k são harmônicas senoidais que representam componentes com defasagem de \pi/2.
  • As fórmulas para calcular os coeficientes (se for preciso calcular a partir da função x(t)) são:
a_0=\frac{1}{T_0}\int_{T_0} x(t)\,dt, \qquad a_k=\frac{2}{T_0}\int_{T_0} x(t)\cos(k\omega_0 t)\,dt, \qquad b_k=\frac{2}{T_0}\int_{T_0} x(t)\sin(k\omega_0 t)\,dt.
  • Observações práticas:
    • Se a função x(t) for par (simétrica em relação ao eixo vertical), então todos os b_k=0.
    • Coeficientes que decaem como 1/k^2 sugerem uma função contínua com derivada descontínua (ex.: triângulo) — isso explica o \dfrac{1}{k^2} no a_k do seu exemplo.
    • Na prática, usamos uma soma finita (soma parcial) com N termos para aproximar x(t). A qualidade melhora com N, mas efeitos como o fenômeno de Gibbs podem aparecer perto de descontinuidades.

Passo 3

Planos de implementação em Matlab (detalhado, sem pular etapas).
  • Estrutura básica:
    1. escolher um vetor de tempo t suficientemente denso para ver os detalhes do sinal e que cubra alguns períodos (ex.: t = linspace(-2*TO,2*TO,2000);).
    2. calcular \omega_0 = 2\pi/TO.
    3. inicializar o sinal com a_0 (vetor constante).
    4. somar para k=1 até N os termos a_k\cos(k\omega_0 t) e b_k\sin(k\omega_0 t).
    5. plotar e testar para vários valores de N para ver a convergência.
  • Dicas de implementação:
    • Sempre use a notação elemento-a-elemento ao operar com vetores em Matlab quando necessário (.*, ./, .^) dentro de expressões que envolvem vetores.
    • Pré-alocar vetores (x = a0*ones(size(t));) é mais eficiente.
    • A forma com for é clara e fácil de entender (boa para estudo). Existe também uma versão vetorizada (mais rápida) usando multiplicação de matrizes: construir uma matriz \cos(k\omega_0 t) de tamanho N\times\text{length}(t) e multiplicar pelos coeficientes, somando em uma linha. Vou mostrar as duas abordagens no script.
  • Como testar:
    • Plotar aproximações com N diferentes (ex.: N=1,5,20,100) em subplots para ver a evolução.
    • Plotar os coeficientes a_k (stem) para ver seu decaimento e sinal alternante.
    • Ajustar o número de pontos no tempo para evitar aliasing visual.

Passo 4

Análise do script que você enviou e correções necessárias (passo a passo).
  • No código original, faltou ponto-e-vírgula em a0 = 1/3 (isso só imprime no console; não é erro crítico, mas é bom colocar ;).
  • A definição de ak e bk precisa usar operadores elemento-a-elemento se for chamada com vetores (vou garantir com .^ e ./ nas expressões).
  • t = linspace(-8,8,500) usa um intervalo fixo; prefiro definir t em função de TO para ver vários períodos: t = linspace(-2*TO,2*TO,2000);.
  • N=200 é aceitável, mas para visualização interativa é bom mostrar vários N menores também.
  • Vou adicionar títulos, labels e um gráfico dos coeficientes.

Passo 5

Explicação didática de como interpretar os coeficientes que foram dados \big(a_0,\\ a_k,\\ b_k\big).
  • No seu caso:
    • a_0=\dfrac{1}{3} é a média do sinal.
    • a_k=\dfrac{4(-1)^k}{(k\pi)^2} tem decaimento em 1/k^2 e alternância de sinal por causa de (-1)^k. Isso é típico de uma onda triangular deslocada/normalizada ou de uma função contínua com cantos (derivadas com saltos).
    • b_k=0 indica simetria par do sinal reconstruído (apenas cossenos).
  • Em termos práticos: como a_k\propto 1/k^2, a soma converge rápido; já sinais com a_k\propto 1/k (ex.: degrau, dente de serra) convergem mais lentamente e apresentam Gibbs mais pronunciado.

Passo 6

Apresentação do script Matlab final (explicado em palavras antes do código).
  • O script final que eu vou fornecer:
    • corrige pequenas questões de sintaxe;
    • cria um vetor de tempo baseado em T_0;
    • implementa a soma parcial por laço for (didática) e também mostra uma opção vetorizada comentada;
    • plota aproximações para vários valores de N e plota os coeficientes a_k.
  • Vou organizar o código com comentários claros para que seja fácil de testar e modificar (mudar T_0, N, densidade de t, etc.).

Resposta

% arquivo: series.m
% série trigonométrica de Fourier - reconstrução a partir de coeficientes
% ------------------
clear; close all; clc;

% Parâmetros básicos (mude aqui)
TO = 2;              % período do sinal (mude se quiser)
w0 = 2*pi/TO;        % pulsação fundamental
a0 = 1/3;            % coeficiente a0
ak = @(k) 4.*(-1).^k ./ ((k*pi).^2);  % coeficiente ak (note o .^ e ./ para vetores)
bk = @(k) 0.*k;     % coeficiente bk (aqui é zero para todo k)

% Tempo para plot (vários períodos, denso o suficiente)
t = linspace(-2*TO, 2*TO, 2000);

% Valores de N que serão mostrados (soma parcial)
Ns = [1, 5, 20, 100];   % escolha alguns Ns para ver a convergência

% Plot das aproximações para diferentes N
figure('Name','Série de Fourier - aproximações para vários N','NumberTitle','off');
for i = 1:length(Ns)
    N = Ns(i);
    x = a0 * ones(size(t));   % inicializa com a0
    
    % soma (implementação direta - clara e didática)
    for k = 1:N
        x = x + ak(k) .* cos(k*w0.*t) + bk(k) .* sin(k*w0.*t);
    end
    
    subplot(2,2,i);
    plot(t, x, 'LineWidth', 1.2);
    grid on;
    title(['Soma parcial com N = ' num2str(N)]);
    xlabel('t');
    ylabel('x(t)');
    xlim([min(t) max(t)]);
end

% Plot dos coeficientes a_k (visualizar decaimento e sinal)
figure('Name','Coeficientes a_k','NumberTitle','off');
Kplot = 1:40;
stem(Kplot, ak(Kplot),'filled');
grid on;
title('Coeficientes a_k');
xlabel('k');
ylabel('a_k');

% (Opcional) Versão vetorizada para um N grande (mais eficiente):
% descomente para usar
%{
Nvec = 200;
K = (1:Nvec)';                 % coluna
% Matriz NxM: (K*w0) * t  => (Nx1)*(1xM) -> NxM
Phi_cos = cos(K*w0 * t);       % Nx(length(t))
ak_vec = ak(K);                % Nx1
% bk_vec = bk(K);              % Nx1 (aqui é zero)
x_vec = a0 + (ak_vec.' * Phi_cos);   % 1xM, resultado vetor tempo
figure('Name','Soma vetorizada N=200','NumberTitle','off');
plot(t, x_vec, 'LineWidth', 1.2); grid on;
title('Reconstrução (vetorizada) com N = 200');
xlabel('t'); ylabel('x(t)');
%}

% Observações rápidas:
% - Se quiser mudar o período, altere TO e reexecute.
% - Para ver Gibbs ou comportamento em descontinuidades, experimente
%   coeficientes que decaiam mais lentamente (ex.: ~1/k).
% - A versão vetorizada (comentada) é muito mais rápida para N grande.

Exercícios relacionados