O valor aproximado de \pi pode ser calculado da seguinte forma:
PASSO 1: Calcula-se o valor da série com n termos:
S=\frac{1}{1^{3}}+\frac{1}{3^{3}}+\frac{1}{5^{3}}+\frac{1}{7^{3}}+\cdots
PASSO 2: Calcula-se o valor aproximado de \pi pela expressão:
\pi=\sqrt[3]{S \times 32}
Desenvolva um programa que peça para o usuário informar a quantidade n de termos da série, calcule e exiba o valor aproximado de \pi com 14 casas decimais.
Obs. 1: Para aumentar a exatidão no cálculo do valor do \pi, utilize o tipo de dados double ao invés do float. A máscara de formatação para o double é olf.
Obs. 2: Para calcular a raiz cúbica, utilize a função cbrt () disponível na biblioteca math.h.
Valor de referência (14 casas decimais): \pi=3.14159265358979

Passo 1

O enunciado pede que eu escreva um programa que leia a quantidade n de termos de uma série, calcule o valor aproximado de \pi seguindo dois passos e exiba o resultado com 14 casas decimais. As informações fornecidas são:
\text{PASSO 1: } S=\frac{1}{1^{3}}+\frac{1}{3^{3}}+\frac{1}{5^{3}}+\frac{1}{7^{3}}+\cdots
\text{PASSO 2: } \pi=\sqrt[3]{S\times 32}
Requisitos do programa (dados no enunciado): usar o tipo de dados \texttt{double}, usar a função \texttt{cbrt()} da biblioteca \texttt{math.h} para a raiz cúbica e imprimir com 14 casas decimais (máscara \texttt{"%.14lf"}). Valor de referência de \pi com 14 casas: \pi=3{,}14159265358979.

Passo 2

Um ponto importante de entendimento (didática): a identidade conhecida que liga uma série de inversos de cubos de números ímpares a \pi é
\sum_{k=0}^{\infty}\frac{(-1)^{k}}{(2k+1)^{3}}=\frac{\pi^{3}}{32}.
Ou seja, a série que converge para \pi^{3}/32 é a série alternada
S=\frac{1}{1^{3}}-\frac{1}{3^{3}}+\frac{1}{5^{3}}-\frac{1}{7^{3}}+\cdots.
Se usarmos essa série alternada com n termos e calcularmos \pi por \pi=\sqrt[3]{32S}, a aproximação converge para \pi. Se usássemos a série com todos os sinais positivos, a relação com \pi não seria a acima e a fórmula \pi=\sqrt[3]{32S} não valeria. Portanto, para que o programa produza uma boa aproximação de \pi conforme o enunciado, devemos somar a versão alternada dos termos ímpares ao cubo.
Breve comentário sobre por que essa identidade existe (sem prova completa): ela pode ser obtida a partir da expansão em série de Taylor (ou de Fourier) da função \arctan(x) e manipulações integrais/termwise que levam a somas de potências ímpares; a identidade é clássica e usada para obter \pi a partir de séries. Aqui vamos aceitar a identidade como base do método e mostrá-la numericamente no programa.

Passo 3

Como implementar o cálculo (passo a passo prático e didático):
  1. Representação da série finita com n termos: vamos somar os termos
S_{n}=\sum_{k=0}^{n-1}\frac{(-1)^{k}}{(2k+1)^{3}}.
Cada termo é calculado assim:
  • calcular o índice ímpar m=2k+1;
  • calcular m^{3} (usando cast para \texttt{double});
  • calcular o inverso 1.0/(m^{3});
  • aplicar o sinal (-1)^{k}: se k for par, somamos; se k for ímpar, subtraímos.
  1. Acumular a soma em uma variável do tipo \texttt{double} para aproveitar a precisão.
  2. Após calcular S_{n}, calcular a aproximação de \pi por
\pi_{\text{aprox}}=\texttt{cbrt}(32.0\times S_{n}).
Observações de implementação:
  • Não usar \texttt{pow(m,3)} desnecessariamente; é mais eficiente fazer \texttt{m*m*m} com \texttt{m} convertido para \texttt{double}.
  • Ler n com \texttt{scanf("%d", \&n)} e verificar se n>0.
  • Imprimir com \texttt{printf("%.14lf\n", pi\_aprox);}.

Passo 4

Estimativa de quantos termos são necessários para atingir 14 casas decimais:
A série alternada tem termos monoticamente decrescentes em magnitude, logo o erro absoluto ao truncar a n-ésima parcela é menor que o valor do próximo termo (Critério do resto da série alternada):
\left|S-S_{n}\right| \le \frac{1}{(2n+1)^{3}}.
Se quisermos erro em S menor que 10^{-14}, precisamos de
\frac{1}{(2n+1)^{3}}<10^{-14}\quad\Rightarrow\quad 2n+1>(10^{14})^{1/3}\approx 4{,}6416\times 10^{4}.
Portanto n da ordem de 2{,}3\times 10^{4} (aprox. n\approx 23208) é suficiente para fazer o erro em S menor que 10^{-14}. A sensibilidade da transformação \pi=\sqrt[3]{32S} é da mesma ordem (fator aproximadamente 1{,}08), então esse n também dá aproximadamente 14 dígitos corretos em \pi. Conclusão prática: escolher n na casa de 2\times 10^{4} garante 14 casas decimais estáveis; para valores menores de n ainda obtém-se aproximações, mas com menos casas corretas.

Passo 5

Cuidados numéricos e boas práticas:
  • Usar \texttt{double} para acumular \,S_{n}.
  • Somar termos em ordem crescente de magnitude tende a reduzir erro de arredondamento; aqui a sequência dos termos já diminui com k crescente, então somar do termo k=0 até k=n-1 é aceitável. Se n for muito grande, pode-se considerar soma em dupla precisão (não padrão em C) ou soma em ordem crescente (já é o caso).
  • Evitar convertendo repetidamente usando \texttt{pow}; calcular m como inteiro e fazer \texttt{double denom = (double)m*m*m;}.

Passo 6

Programa em C completo (segue o código que implementa o algoritmo descrito). Esse programa lê um inteiro n, calcula S_{n} como série alternada, calcula \pi_{\text{aprox}}=\sqrt[3]{32S_{n}} usando \texttt{cbrt()} e imprime com 14 casas decimais.
#include <stdio.h>
#include <math.h>

int main(void) {
    int n;
    if (scanf("%d", &n) != 1) return 0;
    if (n <= 0) {
        printf("0.00000000000000\n");
        return 0;
    }

    double S = 0.0;
    for (int k = 0; k < n; ++k) {
        int m = 2*k + 1;                 /* ímpar m = 1,3,5,... */
        double dm = (double)m;
        double term = 1.0 / (dm * dm * dm); /* 1 / m^3 */
        if (k % 2 == 1) {
            term = -term;               /* alterna o sinal: -, +, -, + ... */
        }
        S += term;
    }

    double pi_approx = cbrt(32.0 * S);
    printf("%.14lf\n", pi_approx);

    return 0;
}

Resposta

#include <stdio.h>
#include <math.h>

int main(void) {
    int n;
    if (scanf("%d", &n) != 1) return 0;
    if (n <= 0) {
        printf("0.00000000000000\n");
        return 0;
    }

    double S = 0.0;
    for (int k = 0; k < n; ++k) {
        int m = 2*k + 1;
        double dm = (double)m;
        double term = 1.0 / (dm * dm * dm);
        if (k % 2 == 1) term = -term;
        S += term;
    }

    double pi_approx = cbrt(32.0 * S);
    printf("%.14lf\n", pi_approx);

    return 0;
}

Exercícios relacionados