A série BBP (Bailey-Borwein-Plouffe) é uma fórmula para calcular \pi diretamente em base hexadecimal (base 16), apresentada na Equaçāo 11.15. Desenvolva um programa que utilize essa série para calcular uma aproximação de \pi, utilizando um número de iteraçōes fornecido pelo usuário. Em cada iteraçāo, calcule o erro relativo e, ao final, gere um gráfico que mostre a evoluçāo desse erro ao longo das iterações.
\pi_{a}=\sum_{n=0}^{\infty} 16^{-n}\left(\frac{4}{8 n+1}-\frac{2}{8 n+4}-\frac{1}{8 n+5}-\frac{1}{8 n+6}\right)(11.15)

Passo 1

O enunciado pede um programa que use a série BBP para aproximar \pi em base hexadecimal, somando até um número de iterações N dado pelo usuário, e que em cada iteração calcule o erro relativo em relação ao valor real de \pi. Para isso, vamos precisar de:
  1. Um laço que percorra n de 0 até N-1.
  2. A expressão do termo geral da série BBP.
  3. Armazenar a soma parcial para obter a aproximação \pi_{a}.
  4. Calcular o erro relativo usando a constante \pi da biblioteca math.
  5. Registrar esses erros numa lista e usar matplotlib para gerar o gráfico da evolução do erro.

Passo 2

A série BBP é dada por
\pi_{a} \;=\;\sum_{n=0}^{\infty} 16^{-n}\!\Bigl(\tfrac{4}{8n+1}-\tfrac{2}{8n+4}-\tfrac{1}{8n+5}-\tfrac{1}{8n+6}\Bigr).
Em cada iteração n truncamos a soma em N termos, ou seja,
\pi_{a}^{(N)} = \sum_{n=0}^{N-1} 16^{-n}\!\Bigl(\tfrac{4}{8n+1}-\tfrac{2}{8n+4}-\tfrac{1}{8n+5}-\tfrac{1}{8n+6}\Bigr).
O cálculo de cada termo é direto: computamos 16^{-n} e multiplicamos pela combinação de frações.

Passo 3

No laço principal:
  1. Inicializamos pi_a = 0.0 e uma lista erros = [].
  2. Para cada n de 0 a N-1:
    a. Calculamos o termo
    \displaystyle t = 16^{-n}\bigl(\tfrac{4}{8n+1}-\tfrac{2}{8n+4}-\tfrac{1}{8n+5}-\tfrac{1}{8n+6}\bigr).
    b. Atualizamos pi_a += t.
    c. Calculamos o erro relativo
    \displaystyle \text{erro} = \frac{\lvert\pi_a - \pi\rvert}{\pi}
    usando math.pi, e adicionamos esse valor à lista erros.

Passo 4

Após computar todas as iterações, usamos matplotlib para desenhar o gráfico de erros em função do número de iterações. Ajustamos rótulos dos eixos e, para melhor visualização, podemos usar escala logarítmica no eixo vertical.

Resposta

import math
import matplotlib.pyplot as plt

def \(bbp_pi\)(N):
 """Calcula aproximação de pi pela série BBP em N iterações e retorna lista de erros relativos."""
\[pi_a =0.0\]
 erros = []
 for n in range(N):
 coef \(=16\)**(-n)
 termo = coef * (
 4.0/(8*n \(+1\))
 - 2.0/(8*n \(+4\))
 - 1.0/(8*n \(+5\))
 - 1.0/(8*n \(+6\))
 )
 \(pi_a +=\) termo
 erro = abs(\(pi_a\) - math.pi) / math.pi
 erros.append(erro)
 return erros

def main():
 N = int(input("Número de iterações (N): "))
 erros = \(bbp_pi\)(N)
 # Gera o gráfico da evolução do erro
 plt.figure(figsize=(8, 5))
 plt.plot(range(1, N\(+1\)), erros, marker='o', linestyle='-', markersize\(=4\))
 plt.yscale('log')
 plt.xlabel("Iteração")
 plt.ylabel("Erro relativo")
 plt.title("Evolução do erro relativo na série BBP para π")
 plt.grid(True, which="both", ls="--")
 plt.show()

if __name__ \(==\) "__main__":
 main()

Exercícios relacionados