A função cosseno pode ser aproximada por meio de sua expansĭio 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.

Passo 1

O enunciado pede que a gente aproxime \cos(x) usando sua série de Taylor (expansão de Maclaurin):
\cos(x) = \sum_{k=0}^{\infty} (-1)^k \frac{x^{2k}}{(2k)!}\,.
A ideia é ir somando termo a termo até que o erro absoluto entre a nossa aproximação e o valor “verdadeiro” (obtido por math.cos) fique abaixo do limite estabelecido pelo usuário. Vamos também armazenar o erro relativo em cada iteração e, no final, gerar um gráfico dessa evolução.

Passo 2

Planejamento do algoritmo:
  1. Importar os módulos math e matplotlib.pyplot.
  2. Ler do usuário o ângulo x em graus e o erro absoluto mínimo \varepsilon. Converter x para radianos.
  3. Calcular o valor de referência cos_true = math.cos(x_rad).
  4. Inicializar:
  • term = 1.0 (o primeiro termo da série, para k=0),
  • approx = term (soma parcial),
  • k = 1,
  • lista rel_errors = [] para armazenar o erro relativo em cada iteração.
  1. Enquanto \lvert\text{approx} - \cos_{\text{true}}\rvert \ge \varepsilon:
    a. Atualizar o termo com a fórmula recursiva
\text{term} \leftarrow -\,\text{term} \times \frac{x_{\text{rad}}^2}{(2k-1)\,(2k)}
b. Somar esse termo a approx.
c. Calcular erro relativo
E_{\text{rel}} = \frac{\lvert \cos_{\text{true}} - \text{approx}\rvert}{\lvert \cos_{\text{true}}\rvert}
e adicionar em rel_errors.
d. Incrementar k.
6. Ao final, exibir o número de termos usados e plotar rel_errors em função de iterações.

Passo 3

Segue o programa Python completo:
import math
import matplotlib.pyplot as plt

# 1. Leitura de dados
\(x_deg\) = float(input("Digite o valor de x em graus: "))
eps = float(input("Digite o erro absoluto mínimo desejado: "))

# 2. Conversão para radianos e valor de referência
\(x_rad\) = math.radians(\(x_deg\))
\(cos_true\) = math.cos(\(x_rad\))

# 3. Inicialização
term \(=1.0\) # primeiro termo da série (k \(=0\))
approx = term # soma parcial
k \(=1 rel_errors\) = []

# 4. Iteração até erro absoluto < eps
while abs(approx - \(cos_true\)) >= eps:
 # fórmula recursiva para o próximo termo
 term *= - \(x_rad\)**2 / ((2*k - 1) * (2*k))
 approx \(+=\) term
 # erro relativo
 \(E_rel\) = abs(\(cos_true\) - approx) / abs(\(cos_true\)) if \(cos_true\) !\(=0\) else abs(\(cos_true\) - approx)
 \(rel_errors\).append(\(E_rel\))
 k \(+=1\)

# 5. Resultados
print(f"
Valor exato de cos({\(x_deg\)}°) = {\(cos_true\)}")
print(f"Aproximação pela série = {approx}")
print(f"Número de termos usados = {k}")

# 6. Gráfico da evolução do erro relativo
plt.figure(figsize=(8, 5))
plt.plot(range(1, len(\(rel_errors\))\(+1\)), \(rel_errors\), marker='o')
plt.yscale('log')
plt.title("Evolução do Erro Relativo na Aproximação de cos(x)")
plt.xlabel("Iteração (termo k)")
plt.ylabel("Erro Relativo")
plt.grid(True, which="both", ls="--")
plt.show()

Passo 4

Como saída, o programa:
  • Exibe o valor exato de \cos(x), a aproximação obtida e quantos termos foram necessários para atingir o erro desejado.
  • Mostra um gráfico em escala logarítmica do erro relativo em cada iteração, permitindo visualizar como a série converge para \cos(x).

Resposta

Programa Python conforme descrito acima.

Exercícios relacionados