A funçāio cosseno hiperbólico pode ser calculada por meio de sua expansīo em série infinita, conforme representado na Equação 11.14. Desenvolva um programa que solicite ao usuário o número de iteraçōes desejado. Para cada iteraçāo, calcule o erro relativo em relação ao valor real de \operatorname{cosh} (x). Ao final, gere um gráfico que mostre a evoluçāo do erro relativo ao longo das iteraçōes.
\operatorname{cosh} (x)=\sum_{n=0}^{\infty} \frac{x^{2 n}}{(2 n)!}

Passo 1

O enunciado pede para aproximarmos a função hiperbólica \operatorname{cosh}(x) pela sua série de potências
\operatorname{cosh}(x)=\sum_{n=0}^{\infty}\frac{x^{2n}}{(2n)!}
e, a cada iteração, calcular o erro relativo em relação ao valor exato \operatorname{cosh}(x). Por fim, devemos plotar a evolução desse erro ao longo das iterações.

Passo 2

Vamos solicitar ao usuário dois valores: o ponto x em que queremos avaliar \operatorname{cosh}(x) e o número de iterações N (quantos termos da série vamos somar). Também importaremos as bibliotecas necessárias: math para o valor exato e matplotlib.pyplot para o gráfico.

Passo 3

Calculamos o valor exato com math.cosh(x) e, em seguida, construímos a soma parcial da série termo a termo. Para evitar o custo de calcular fatorial repetidamente, usamos a relação de recorrência
\text{termo}_n = \text{termo}_{n-1}\times\frac{x^2}{(2n)(2n-1)}
com \text{termo}_0=1.

Passo 4

A cada iteração n (de 0 a N-1), atualizamos a soma parcial, calculamos o erro relativo
\text{erro}_n = \frac{\bigl|\text{soma\_parcial}_n - \operatorname{cosh}(x)\bigr|}{\bigl|\operatorname{cosh}(x)\bigr|}
e armazenamos esse erro numa lista.

Passo 5

Com a lista de erros pronta, usamos matplotlib para traçar um gráfico de iteração versus erro relativo. É interessante usar escala logarítmica no eixo y para visualizar melhor a convergência rápida.

Resposta

import math
import matplotlib.pyplot as plt

# Entrada de dados
x = float(input("Digite o valor de x: "))
N = int(input("Digite o número de iterações desejado: "))

# Valor exato de cosh(x)
valor_exato = math.cosh(x)

# Preparação para soma da série e lista de erros
soma_parcial = 0.0
termo = 1.0       # termo de n=0 é x^0/(0!) = 1
erros = []

# Loop para N termos
for n in range(N):
    # Adiciona o termo atual à soma parcial
    soma_parcial += termo
    
    # Calcula erro relativo e armazena
    erro_relativo = abs(soma_parcial - valor_exato) / abs(valor_exato)
    erros.append(erro_relativo)
    
    # Atualiza o termo para o próximo n usando recorrência
    # termo_{n+1} = termo_n * x^2 / ((2n+2)*(2n+1))
    termo *= x**2 / ((2*n + 2)*(2*n + 1))

# Plot do erro relativo
plt.figure(figsize=(8, 5))
plt.plot(range(1, N+1), erros, marker='o')
plt.yscale('log')  # melhor visualização da convergência
plt.title("Evolução do Erro Relativo na Aproximação de cosh(x)")
plt.xlabel("Número de termos na série")
plt.ylabel("Erro relativo")
plt.grid(True, which="both", ls="--")
plt.show()

Exercícios relacionados