A função cosseno pode ser aproximada por meio de sua expansão em série de Taylor, conforme expressa na Equação 11.12. Desenvolva um programa em Python para calcular essa aproximação até que um erro absoluto mínimo seja atingido. O programa deve solicitar ao usuário o valor de x e o valor desejado para o erro absoluto mínimo. Ao final, gere um gráfico que mostre a evolução do erro relativo ao longo das iterações.
\cos (x)=\sum_{n=0}^{\infty} \frac{(-1)^{n} x^{2 n}}{(2 n)!}

Passo 1

O enunciado pede para aproximar \cos(x) usando a série de Taylor
\cos(x) = \sum_{n=0}^{\infty} \frac{(-1)^n\,x^{2n}}{(2n)!}
até que o erro absoluto entre o valor exato (usando math.cos) e a aproximação fique abaixo de um limite fornecido pelo usuário. Além disso, devemos rastrear e plotar a evolução do erro relativo a cada iteração.

Passo 2

Vamos usar a forma recursiva do termo geral da série para evitar recomputar fatoriais a cada passo. Definimos:
T_0 = 1,\quad T_{n+1} = T_n \times \biggl(-1\biggr)\times\frac{x^2}{(2n+1)(2n+2)}.
A cada iteração atualizamos
S_{n+1} = S_n + T_{n+1}
e calculamos
\text{erro absoluto} = \bigl|\cos(x) - S_{n+1}\bigr|, \quad \text{erro relativo} = \begin{cases} \dfrac{\bigl|\cos(x) - S_{n+1}\bigr|}{\bigl|\cos(x)\bigr|},&\text{se }\cos(x)\neq0,\\\\ 0,&\text{caso contrário.} \end{cases}á

Passo 3

O algoritmo em alto nível é:
  1. Ler do usuário: valor de x (em radianos) e tolerância de erro absoluto.
  2. Inicializar S=1, T=1, n=0, lista para armazenar erros relativos.
  3. Repetir até \lvert \cos(x)-S\rvert < \text{tol}:
  • Calcular próximo termo T usando a relação recursiva.
  • Atualizar a soma S\gets S + T.
  • Calcular e armazenar o erro relativo.
  • Incrementar n.
  1. Imprimir resultado e número de termos usados.
  2. Gerar gráfico de iteração vs. erro relativo usando matplotlib.

Passo 4

Segue o programa em Python que implementa esse algoritmo e ao final exibe o gráfico da evolução do erro relativo.

Resposta

import math
import matplotlib.pyplot as plt

def \(aproximar_cos\)(x, tol):
 # valor exato para comparação
 \(cos_exato\) = math.cos(x)
 # inicialização
 S \(=1.0\) # soma parcial
 T \(=1.0\) # termo atual \(T_0\)
 n \(=0 erros_rel\) = [] # lista de erros relativos
 
 # cálculo iterativo até erro absoluto < tol
 \(erro_abs\) = abs(\(cos_exato\) - S)
 while \(erro_abs\) >= tol:
 # atualizar termo usando a forma recursiva
 T *= -1 * x*x / ((2*n\(+1\))*(2*n\(+2\)))
 # atualizar soma parcial
 S \(+=\) T
 n \(+=1\)
 
 # recalcular erro absoluto e relativo
 \(erro_abs\) = abs(\(cos_exato\) - S)
 if \(cos_exato\) !\(=0\):
 \(erro_rel\) = \(erro_abs\) / abs(\(cos_exato\))
 else:
 \(erro_rel =0.0 erros_rel\).append(\(erro_rel\))
 
 return S, n\(+1\), \(erros_rel\) # n\(+1\) termos foram somados

def main():
 # entrada do usuário
 x = float(input("Digite x (em radianos): "))
 tol = float(input("Digite a tolerância de erro absoluto desejada: "))
 
 aproxim, termos, \(erros_rel\) = \(aproximar_cos\)(x, tol)
 print(f"
Aproximação de cos({x}) = {aproxim}")
 print(f"Valor exato de cos({x}) = {math.cos(x)}")
 print(f"Número de termos usados: {termos}")
 
 # plot da evolução do erro relativo
 plt.figure(figsize=(8,5))
 plt.plot(range(1, len(\(erros_rel\))\(+1\)), \(erros_rel\), marker='o', linestyle='-')
 plt.yscale('log')
 plt.xlabel("Iteração (n)")
 plt.ylabel("Erro relativo")
 plt.title(f"Evolução do erro relativo na aproximação de cos({x})")
 plt.grid(True, which="both", ls="--")
 plt.show()

if __name__ \(==\) "__main__":
 main()

Exercícios relacionados