Cálculo isolado das decimais de Pi

Programação Java
#1

[code]public class Pi {
public static void main(String args[]) {
double pi = 0f;
double temp = 0f;
double casas = 3f;
calculaPi(casas, pi, temp);
}

public static void calculaPi(double casas, double pi, double temp) {
	for (double n = 0f; casas > n; n++) {

		temp = ((4 / (8 * n + 1)) - (2 / (8 * n + 4)) - (1 / (8 * n + 5)) - (1 / (8 * n + 6)))
				* (Math.pow(1 / 16, n));

		pi = pi + temp;

		System.out.println("[" + n + "]" + " " + temp);
		temp = 0f;
	}
	System.out.println(pi);
}

}[/code]

[0.0] 3.1333333333333333
[1.0] 0.0
[2.0] 0.0

Não sei onde estou errando! Para n = 1 deveria ser 3,1414224663333333 o resultado das casas deveria ficar assim:

[0.0] 3.1333333333333333
[1.0] 3,1414224663333333
[2.0] 0.0

A recursividade só execulta uma vez! que é para n = 0, quando n é incrementado não funciona mais. Alguém pode me ajudar?


Estou usando esta formula para calculo de Pi.

Acredito que o problema esteja relacionado com numeros muito pequenos em ponto flutuante que são arrendondados pra zero…

#2

Tente trabalhar com a classe BigDecimal.
Mais detalhes aqui.

#3

Bom dia

Se não errei o calculo, e sempre erro(!), para n=1 tá dando um numero negativo. O problema pode estar ai.

Abraço.

#4 
class CalculaPi {
    /** n é o número de iterações */
    double calcula1 (int n) {
        double pi;
        // Usando a fórmula do jeito que está, mas usando um truque
        // ou seja, calculando os termos menores primeiro
        double _16n; // 16 elevado a -n    
        _16n = 1.0;
        for (int k = n; k &gt 0; --k) {
            _16n /= 16.0;
        }
        // Agora usando a fórmula
        pi = 0.0;
        for (int k = n; k &gt= 0; --k) {
            pi += _16n * (
                      4.0 / (8 * k + 1) 
                    - 2.0 / (8 * k + 4) 
                    - 1.0 / (8 * k + 5) 
                    - 1.0 / (8 * k + 6));
            _16n *= 16.0;
            System.out.printf ("%g%n", pi);
        }
        
        return pi;
    }
    /** epsilon é a margem de erro */
    double calcula2 (double epsilon) {
        double pi;
        double _16n; // 16 elevado a -n
        // Agora vamos usar a fórmula calculando os termos maiores primeiro.
        // Para evitar que entre em loop, iremos limitar o número de iterações para 100.
        pi = 0.0;
        _16n = 1.0;
        for (int k = 0; k &lt 100; ++k) {
            double newPi = pi + _16n * (
                      4.0 / (8 * k + 1) 
                    - 2.0 / (8 * k + 4) 
                    - 1.0 / (8 * k + 5) 
                    - 1.0 / (8 * k + 6));
            if (Math.abs (newPi - pi) &lt epsilon) {
                return newPi;
            }
            pi = newPi;
            _16n /= 16.0;
        }
        return pi;
    }


    public static void main(String[] args) {
        CalculaPi p = new CalculaPi();
        double pi = p.calcula2 (1E-10);
        System.out.printf ("pi = %.12g%n", pi);
    }
}
#5

Na verdade descobri o seu erro. É que 1 / 16 == 0 (deveria ser: 1.0 / 16.0)

Dica: em Java, evite usar ao máximo o operador de exponenciação se for usar com expoente inteiro.
Se você viu o que fiz, não usei a exponenciação nenhuma vez.

#6

[quote=thingol]Na verdade descobri o seu erro. É que 1 / 16 == 0 (deveria ser: 1.0 / 16.0)

Dica: em Java, evite usar ao máximo o operador de exponenciação se for usar com expoente inteiro.
Se você viu o que fiz, não usei a exponenciação nenhuma vez. [/quote]

Valeu, era isso mesmo, não acredito como não vi isso… e valeu pela dica. :slight_smile:

#7