A função seno pode ser aproximada por meio de sua expansão em série de Taylor, conforme mostrado na Equação 11.11. 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 erro absoluto mínimo desejado. 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 desejado seja atingido. Além disso, queremos plotar a evolução do erro relativo em cada iteração. Para isso, precisaremos de:
- Leitura de
e do erro absoluto mínimo pelo usuário. - Cálculo iterativo dos termos da série até
. - Cálculo do valor “verdadeiro”
com math.sin(x)
para medir o erro relativo em cada passo. - Armazenar os erros relativos em uma lista e, por fim, usar
matplotlib
para gerar o gráfico.
Passo 2
Descrevemos o algoritmo em alto nível:
- Importar
math
ematplotlib.pyplot
. - Ler
e do usuário (convertendo para float
). - Calcular
true_sin = math.sin(x)
. - Inicializar
approx = 0.0
,term = x
(o primeiro termo da série, para), n = 0
eerrors = []
. - Enquanto
:
a. Somarterm
aapprox
.
b. Calcular o erro relativo e acrescentar aerrors
.
c. Atualizarn += 1
e gerar o próximoterm
usando a relação de recorrência
- Após o loop, exibir o valor aproximado e número de iterações, e gerar o gráfico de
errors
vs. número de iterações.
Passo 3
Veja abaixo a implementação em Python seguindo o algoritmo:
import math
import matplotlib.pyplot as plt
# Leitura dos dados
x = float(input("Digite o valor de x (em radianos): "))
epsilon = float(input("Digite o erro absoluto mínimo desejado: "))
# Valor "verdadeiro" de sin(x) para comparação
\(true_sin\) = math.sin(x)
# Inicialização
approx \(=0.0\)
term = x # primeiro termo para n\(=0\)
n \(=0\)
errors = []
# Iteração até que |term| < epsilon
while abs(term) >= epsilon:
approx \(+=\) term
# cálculo do erro relativo
if \(true_sin\) !\(=0\):
\(rel_error\) = abs(approx - \(true_sin\)) / abs(\(true_sin\))
else:
\(rel_error\) = abs(approx - \(true_sin\))
errors.append(\(rel_error\))
# atualizar para o próximo termo
n \(+=1\)
term *= -x*x / ((2*n) * (2*n\(+1\)))
# Resultados
print(f"Aproximação de sin({x}) = {approx}")
print(f"Valor exato de sin({x}) = {true_sin}")
print(f"Número de termos utilizados = {n}")
# Gráfico da evolução do erro relativo
plt.figure(figsize=(8,5))
plt.plot(range(1, len(errors)\(+1\)), errors, marker='o')
plt.yscale('log')
plt.xlabel("Iteração")
plt.ylabel("Erro relativo (escala log)")
plt.title(f"Evolução do erro relativo na aproximação de sin({x})")
plt.grid(True, which="both", ls="--")
plt.show()
Resposta
O programa acima lê
e
, aproxima
por série de Taylor até
, registra o erro relativo a cada iteração e exibe o gráfico da evolução desse erro.