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
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
usando sua série de Taylor (expansão de Maclaurin):
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:
- Importar os módulos
math
ematplotlib.pyplot
. - Ler do usuário o ângulo
em graus e o erro absoluto mínimo . Converter para radianos. - Calcular o valor de referência
cos_true = math.cos(x_rad)
. - Inicializar:
term = 1.0
(o primeiro termo da série, para), approx = term
(soma parcial),k = 1
,- lista
rel_errors = []
para armazenar o erro relativo em cada iteração.
- Enquanto
:
a. Atualizar o termo com a fórmula recursiva
b. Somar esse termo a
c. Calcular erro relativo
approx
.c. Calcular erro relativo
e adicionar em
d. Incrementar .
6. Ao final, exibir o número de termos usados e plotar
rel_errors
.d. Incrementar
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
, 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
.
Resposta
Programa Python conforme descrito acima.