# Methoden zur Berechnung und Rückgabe von π



## Terence86 (24. Nov 2016)

Kurze Info zur Aufgabe: 
	

	
	
		
		

		
			




Meine Frage ist zu pi3(double eps), wie löse ich das ganze in der Schleife?
Das ganze ist ja eine Annäherung, also muss meine Schleife solange laufen bis ich in dem Wertebereich zwischen Math.PI - eps  und Math.PI + eps bin. Richtig soweit?
Zweite Frage zu  wenn kein Argument übergeben wird, sei eps = 0.000000001. (Hinweis Überladen), wie mach ich das am besten? Und wie sieht dann die Main Anweisung dazu aus?
Hier der Code Schnipsel:

```
public static double pi2(double eps) {
        int i = 0;
        double summand;
        double pi = 0.0;
        do {
            summand = Math.pow(-1, i) / (2 * i + 1);
            i++;
            pi += summand;
        } while (Math.abs(summand) > eps);

        return 4 * pi;
    }

    public static void pi2() {
        pi2(0.00000001);
    }

    public static double pi3(double eps) {
        double piViertel = (Math.PI / 4);
        int i = 0;
        double summand;
        double pi = 0.0;
        do {
            summand = Math.pow(-1, i) / (2 * i + 1);
            i++;
            pi += summand;
        } while (pi > (piViertel + eps) & pi < (piViertel - eps));

        //System.out.println((Math.PI / 4));
        //System.out.println((piViertel + eps));
        //System.out.println((piViertel - eps));
        return pi; // Ja den müsste ich dann mit 4 Multiplizieren zu testen hatte ich aber so gelassen.

    }
```


----------



## Terence86 (24. Nov 2016)

Kann ich das in der While-Schleife so überhaupt lösen? So wie es steht funktioniert es ja nicht.


----------



## mariane (25. Nov 2016)

Hmm, du musst natürlich | Pi - PI_Berechnet | > EPS als Bedingung hernehmen.

Dann kann man solche Dinge auch etwas geschickter angehen. Das alternierende Vorzeichen lässt sich mittels einem Boolean elegant umsetzen, Math.pow(-1, i) als Vorzeichengenerierer ist mit Kanonen auf Spatzen, ebenso reicht eine einfache Addition +2 aus statt 2 * i + 1.


```
public class Test {

   private static final double PI4 = Math.PI / 4.0;
   private static final double EPS = 10e-8;
 
   public static void main(String[] args) {

     int i = 1;
     double pi = 0.0;
     boolean sign = true;

     while (Math.abs(pi - PI4) > EPS) {
       pi += sign ? 1.0 / i : -1.0 / i;
       sign = !sign;
       i += 2;
     }

     System.out.println(pi * 4.0);
   }

}
```


----------



## Meniskusschaden (25. Nov 2016)

Alternativ kann man es so auch ohne Fallunterscheidung machen:

```
public class Sign {
    private static final double PI4 = Math.PI / 4.0;
    private static final double EPS = 10e-8;

    public static void main(String[] args) {
        int i = 1;
        double pi = 0.0;
        double sign = 1;
        while (Math.abs(pi - PI4) > EPS) {
            pi += sign/i;
            sign *= -1;
            i += 2;
        }
        System.out.println(pi * 4.0);
    }
}
```


----------



## Terence86 (26. Nov 2016)

Danke euch, hat fast alles geklappt. Habe leider für den Praktomat unterschiedlicher Ergebnisse erhalten. Schuld daran waren Rundungsfehler von Math.PI / 4 , und eps. Aber das ausgebessert hat geklappt.


----------



## Xyz1 (26. Nov 2016)

Ich habe mal drübergeschaut, mach besser Folgendes:

```
static double pi1(int n) {
        // ....
        return d * 4;
    }

    static double pi2(double eps) {
        // ...
        return d2;
    }

    static double pi2() {
        return pi2(Math.pow(10, -4));
    }

    static double pi3(double eps) {
        // ...
        return d1;
    }

    static double pi3() {
        return pi3(Math.pow(10, -4));
    }
```

Also multi die Summe mit 4, anstatt PI durch 4 zu teilen!

Math.abs() wusste ich aber auch nicht zu umgehen. 

Bei weiterer Hilfe nochmal melden


----------



## Flown (26. Nov 2016)

@DerWissende Math.pow kann man getrost weglassen. Es geht viel einfacher mit `1e-8`, was nichts anderes ist als `0.00000001`.


----------

