(0.5) Elabore um programa em Python que calcule o valor aproximado de \pi utilizando a fórmula a seguir:
\pi=\frac{1}{1}-\frac{1}{3^{3}}+\frac{1}{5^{3}}-\frac{1}{7^{3}}+\cdots

Passo 1

O enunciado pede que eu elabore um programa em Python que calcule um valor aproximado de \pi usando a série
\pi=\frac{1}{1}-\frac{1}{3^{3}}+\frac{1}{5^{3}}-\frac{1}{7^{3}}+\cdots
Informações dadas:
  • A sequência de termos é alternada (sinais +, -, +, -, …).
  • O n-ésimo termo (começando em n=0) é \dfrac{(-1)^n}{(2n+1)^3}.
  • Preciso produzir um programa que aproxime \pi a partir dessa série.

Passo 2

Vamos entender matematicamente o que essa série representa. Definimos a soma infinita
S=\sum_{k=0}^{\infty}\frac{(-1)^k}{(2k+1)^3}.
Existe um resultado conhecido (valor da função beta de Dirichlet em s=3) que diz:
\sum_{k=0}^{\infty}\frac{(-1)^k}{(2k+1)^3}=\frac{\pi^{3}}{32}.
Aceitando esse resultado, podemos relacionar S com \pi por
S=\frac{\pi^{3}}{32}.

Passo 3

Isolando \pi na relação anterior obtemos a fórmula prática que usaremos numericamente:
\pi=\bigl(32\,S\bigr)^{1/3}.
Na prática numericamente não somamos infinitos termos: calculamos a soma parcial
S_N=\sum_{k=0}^{N}\frac{(-1)^k}{(2k+1)^3}
e usamos a aproximação
\pi\approx \bigl(32\,S_N\bigr)^{1/3}.

Passo 4

Como controlar o erro? A série é alternada e seus termos em módulo são decrescentes para k\ge0 e tendem a zero, então vale o critério do resto da série alternada (criterio de Leibniz): o erro ao truncar após N é menor que o próximo termo em módulo. Ou seja, se definirmos o termo de ordem k por
a_k=\frac{1}{(2k+1)^3},
então
\bigl|S-S_N\bigr|\le a_{N+1}=\frac{1}{(2(N+1)+1)^3}.
Como a fórmula final para \pi envolve a raiz cúbica de 32S, uma forma prática e segura de parar a soma é: calcular a estimativa de \pi a cada passo e parar quando a diferença entre duas estimativas consecutivas for menor que uma tolerância desejada \varepsilon. Este critério é simples e direto de implementar.

Passo 5

Estratégia do programa (passo a passo):
  • Inicializar S com 0.
  • Iterar k=0,1,2,\dots:
    • calcular o denominador (2k+1)^3 e o termo (-1)^k/(2k+1)^3;
    • acrescentar o termo a S;
    • calcular a estimativa de \pi por \pi_{\text{est}}=(32\cdot S)^{1/3};
    • comparar \pi_{\text{est}} com a estimativa anterior; se a diferença absoluta for menor que a tolerância pedida, parar e devolver \pi_{\text{est}}.
  • Garantir um número máximo de iterações para evitar loop infinito.

Passo 6

Observações práticas e dicas para a prova:
  • Use variáveis claras: por exemplo, S (soma parcial), k (índice), term (termo atual), pi\_prev (estimativa anterior), pi\_est (estimativa atual).
  • Para evitar custos de potência repetida, calcule (2k+1) e depois eleve ao cubo com **3.
  • Tolerância típica: \varepsilon=10^{-12} ou \varepsilon=10^{-10} dependendo da precisão pedida.
  • Sempre mostre o número de iterações usadas — isso ajuda a avaliar convergência na hora da prova.
  • Se precisar de uma garantia teórica do erro em S, use a_{N+1} (o próximo termo) como estimativa do erro em S; para a conversão em erro em \pi pode-se usar estimativas por derivada da raiz cúbica, mas para a prova prática o critério de diferença entre estimativas consecutivas é suficiente e simples.

Passo 7

Abaixo está o programa em Python que implementa a ideia explicada. O código recebe uma tolerância e retorna a aproximação de \pi e o número de termos usados.

Resposta

# Aproximação de pi usando a série:
# pi = 1/1 - 1/3^3 + 1/5^3 - 1/7^3 + ...
# Observação: S = sum_{k=0}^\infty (-1)^k/(2k+1)^3 = pi^3 / 32
# Logo pi = (32 * S)^(1/3). Vamos usar somas parciais S_N e checar convergência.

import math

def approx_pi(tol=1e-12, max_iter=10_000_000):
    """
    Aproxima pi usando a série alternada dada.
    tol: tolerância para a diferença entre estimativas consecutivas de pi.
    max_iter: número máximo de iterações (proteção contra loops longos).
    Retorna (pi_est, n_terms) onde n_terms é o número de termos somados.
    """
    S = 0.0           # soma parcial S_N
    sign = 1.0        # (-1)^k
    pi_prev = 0.0     # estimativa anterior de pi
    k = 0

    while k < max_iter:
        denom = (2 * k + 1) ** 3
        term = sign / denom
        S += term
        # estimativa atual de pi
        pi_est = (32.0 * S) ** (1.0 / 3.0)
        # critério de parada: diferença entre estimativas consecutivas
        if k > 0 and abs(pi_est - pi_prev) < tol:
            return pi_est, k + 1  # k+1 termos somados
        pi_prev = pi_est
        sign = -sign
        k += 1

    # Se chegou aqui, não convergiu dentro de max_iter
    return pi_est, k

if __name__ == "__main__":
    pi_approx, terms = approx_pi(tol=1e-12, max_iter=5000000)
    print("pi aproximado:", pi_approx)
    print("termos usados:", terms)
    print("erro absoluto em relação a math.pi:", abs(pi_approx - math.pi))

Exercícios relacionados