Cálculo isolado das decimais de Pi

12 de setembro de 2007 5 respostas

gledson85 12 de setembro de 2007

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);
	}
}

[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?

[img]http://upload.wikimedia.org/math/f/9/7/f9733b62958be8751fbab97431c27af5.png[/img]
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...

5 Respostas

ze_kiefa 12 de set. de 2007

Tente trabalhar com a classe BigDecimal.
Mais detalhes aqui.

Marck 12 de set. de 2007

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.

thingol 12 de set. de 2007

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);
    }
}

thingol 12 de set. de 2007

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.

gledson85 12 de set. de 2007

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

(Math.pow(1 / 16, n));

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.

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

Criado 12 de setembro de 2007

Ultima resposta 12 de set. de 2007

Respostas 5

Participantes 4

5 Respostas

Topicos relacionados