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
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 para aproximar
usando a série de Taylor
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:
A cada iteração atualizamos
e calculamos
Passo 3
O algoritmo em alto nível é:
- Ler do usuário: valor de
(em radianos) e tolerância de erro absoluto. - Inicializar
, , , lista para armazenar erros relativos. - Repetir até
:
- Calcular próximo termo
usando a relação recursiva. - Atualizar a soma
. - Calcular e armazenar o erro relativo.
- Incrementar
.
- Imprimir resultado e número de termos usados.
- 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()