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 x 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.
\operatorname{sen}(\mathrm{x})=\sum_{n=0}^{\infty} \frac{(-1)^{n} x^{2 n+1}}{(2 n+1)!}

Passo 1

O enunciado pede para aproximar \sin(x) usando a série de Taylor
\sin(x) = \sum_{n=0}^{\infty} \frac{(-1)^n\,x^{2n+1}}{(2n+1)!}
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 x e do erro absoluto mínimo \varepsilon pelo usuário.
  • Cálculo iterativo dos termos da série até |\text{termo}_n| < \varepsilon.
  • Cálculo do valor “verdadeiro” \sin(x) 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:
  1. Importar math e matplotlib.pyplot.
  2. Ler x e \varepsilon do usuário (convertendo para float).
  3. Calcular true_sin = math.sin(x).
  4. Inicializar approx = 0.0, term = x (o primeiro termo da série, para n=0), n = 0 e errors = [].
  5. Enquanto \lvert\text{term}\rvert \ge \varepsilon:
    a. Somar term a approx.
    b. Calcular o erro relativo e acrescentar a errors.
    c. Atualizar n += 1 e gerar o próximo term usando a relação de recorrência
\text{term}_{n} = \text{term}_{n-1} \times \frac{-x^2}{(2n)(2n+1)}.
  1. 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ê x e \varepsilon, aproxima \sin(x) por série de Taylor até |\text{termo}|<\varepsilon, registra o erro relativo a cada iteração e exibe o gráfico da evolução desse erro.

Exercícios relacionados