Errechnung der Zahl Pi in Java

Dieses Thema im Forum "Java/Mono/dotGNU" wurde erstellt von BoneCracker, 12.02.2005.

  1. #1 BoneCracker, 12.02.2005
    BoneCracker

    BoneCracker Mitglied

    Dabei seit:
    27.08.2004
    Beiträge:
    46
    Zustimmungen:
    0
    Hi,
    ich habe mich heute mal dran gesetzt und ein paar Methoden geschrieben, mit welchen man in Java die Zahl Pi errechnen kann. Ich weiß, dass es Math.PI gibt, aber das ist ja langweilig .. Very Happy

    Hier mal das, was ich bisher gemacht habe:
    Code:
     /*
     * Created on 12.02.2005
     */
    package pi;
    
    /**
     * @author Bone
     */
    public final class Pi {
        private Pi() {} // Keine Instanz erlaubt
       
        /**
         * Eine Rechnung, welche von den alten Ägyptern
         * benutzt wurde.
         *
         * Pi =~ (16/9)²
         */
        public static double agypten_pi() {
            return (((double)16 / 9) * ((double)16 / 9));
        }
       
        /**
         * Eine Rechnung, welche im alten Babylon benutzt
         * wurde. Sie leitet sich aus einem 12-Eck her, welches
         * in einem Kreis ist.
         * @see http://magnet.atp.tuwien.ac.at/scholz/projects/fba/graf2.gif
         */
        public static double babylonien_pi() {
            // Grad Zahl in Radiant umwandeln
            double rad   = 2 * Math.PI / 360 * (30 / 2);
            double hoehe = Math.cos(rad);
            double seite = Math.sin(rad);
            return 12 * seite * hoehe;
        }
       
        /**
         * Antiphon (430 v. Chr) war der Meinung, dass man
         * Pi errechnen könnte, in dem man sich den Kreis
         * einfach als ein Vieleck mit "unendlich" Ecken
         * vorstellt.
         */
        public static double griechenland_pi(int dreieck_anzahl) {
            int anzahl   = dreieck_anzahl;
            double grad  = ((double)360 / anzahl / 2);
            // Grad -> Radiant
            double rad   = 2 * Math.PI / 360 * grad;
            double hoehe = Math.cos(rad);
            double seite = Math.sin(rad);
            return anzahl * seite * hoehe;
        }
       
        /**
         * Um 510 n.Chr. gab Aryabhatiya folgende Regel zur
         * Bestimmung von pi an: "Addiere 4 zu 100,
         * multipliziere mit 8, und addiere 62 000.
         * Das Resultat ist der ungefähre Wert des
         * Umfanges eines Kreises mit dem Durchmesser 20 000."
         */
        public static double indien_pi() {
            // sonst wird eine Ganzzahl zurückgegeben   
            double vier = 4;
            return ((vier + 100) * 8 + 62000) / 20000;
        }
       
        /**
         * @see http://magnet.atp.tuwien.ac.at/scholz/projects/fba/fba.html#sec_Leibniz
         */
        public static double leibniz_pi(int durchlauf) {
            double pi   = 1;
            double eins = 1;
            int nenner  = 1;
           
            for (int i = 1; i <= durchlauf; i++) {
                nenner = nenner + 2;
                if ((i % 2) == 1) { // ist die Zahl gerade?
                    pi = pi - (eins/nenner);
                } else {
                    pi = pi + (eins/nenner);
                }
            }
           
            return 4 * pi;
        }
       
        /**
         * @see http://magnet.atp.tuwien.ac.at/scholz/projects/fba/fba.html#sec_Wallis
         */
        public static double wallis_pi(int zahlen) {
            double pi   = 1;
            int zaehler = 0;
            int nenner  = 0;
           
            for (int i = 2; i < zahlen+1; i++) { // mit 2 Anfangen
                if ((i % 2) == 1) { // 0.5 er Zahl
                    zaehler = new Double(((i/2)-0.5)*2).intValue()+1;
                    nenner  = i;
                } else {
                    zaehler = i;
                    nenner  = new Double(((i/2)-0.5)*2).intValue();
                }
                pi = pi * zaehler/nenner;
            }
            return pi*2;
        }
       
        /**
         * WARNING: Die nenner und zaehler werden leicht gesprengt
         *  -> durchlauf darf maximal 31 sein
         * @see http://magnet.atp.tuwien.ac.at/scholz/projects/fba/fba.html#sec_Machin
         */
        public static double machin_pi(int durchlauf) {
            double pi      = 0.5;
            long hilfzahl2 = 1;
            long nenner2   = 1;
            long zaehler   = 1;
            long nenner    = 1;
            int hilfzahl   = 1;
            int y          = 0;
           
            for (int i = 1; i <= durchlauf; i++) {
                y       = 1;
                zaehler = 1;
                nenner  = 1;
                for (int a = 0; a < i; a++) {
                    zaehler = zaehler * y;
                    nenner  = nenner  * ++y;
                    y++;
                }
                hilfzahl  = hilfzahl + 2;
                hilfzahl2 = 1;
                for (int z = 0; z < hilfzahl; z++) {
                    hilfzahl2 = hilfzahl2 * 2;
                }
                nenner2 = hilfzahl * hilfzahl2;
                pi = pi + ((double)zaehler / nenner) * ((double)1 / nenner2);
            }
           
            return 6 * pi;
        }
       
        /**
         * @see http://magnet.atp.tuwien.ac.at/scholz/projects/fba/fba.html#sec_Euler
         */
        public static double euler_pi(int durchlauf) {
            // TODO: implementieren
            return -1;
        }
       
        /**
         * Yoshiaki Tamura und Tasumasa Kanada haben mit
         * folgendem die meisten Stellen bisher von Pi
         * berechnet.
         */
        public static double tamura_pi(int durchlauf) {
            double pi = 0;
            double a = 1;
            double x = 1;
            double b = 1 / Math.sqrt(2);
            double c = 1 / 4;
            double y = 0;
           
            for (int i = 0; i < durchlauf; i++) {
                y = a;
                a = (a + b) / 2;
                b = Math.sqrt(b * y);
                c = c - x * ((a - y) * (a - y));
                x = 2 * x;
            }
            // TODO: Fehler - es kommt immer etwa "-33.343" heraus
            return ((a + b) * (a + b)) / (4 * c);
        }
       
        /**
         * TODO: Herausfinden, wie dieser Berechnungsart heißt
         */
        public static double nenner_pi(int durchlauf) {
            double pi  = 0;
            for (int i = 1; i < durchlauf; i++) {
                pi = pi + ((double)1/(i*i));
            }
            return Math.sqrt(pi*6);
        }
       
        /**
         * TODO: Herausfinden, wie dieser Berechnungsart heißt
         */
        public static double nenner2_pi(int durchlauf) {
            double  pi  = 0;
            int  hilfz  = 2;
            long nenner = 1;
           
            for (int i = 0; i < durchlauf; i++) {
                nenner = hilfz * ++hilfz * ++hilfz;
                if ((i % 2) == 1) { // gerade Zahl?
                    pi = pi - ((double)1 / nenner);
                } else {
                    pi = pi + ((double)1 / nenner);
                }
            }
           
            return pi * 4 + 3;
        }
       
        /**
         * Eine Monte-Carlo Methode, mit welcher man
         * Pi "erschießen" kann.
         */
        public static double erschiesse_pi(int tropfenzahl) {
            double pi = 0;
            int innerhalb = 0;
            int gesamt = tropfenzahl;
    
            while (tropfenzahl > 0) { // generiere Tropfen und addiere je nach Zugehörigkeit
                double dotx = 2 * Math.random() - 1;
                double doty = 2 * Math.random() - 1;
    
                if (Math.sqrt(dotx*dotx + doty*doty) <= 1) {
                    // Punkt liegt innerhalb des Kreises
                    innerhalb++;
                } else {
                    // Punkt liegt außerhalb des Kreises
                }
    
                tropfenzahl--;
            }
    
            pi = 4*(double)innerhalb/gesamt;
            return pi;
        }
    }
    
    Die Funktion tamura_pi() funktioniert leider noch nicht.

    Fallen euch noch ein paar Ideen mehr ein, wie man Pi berechnen kann oder wisst ihr, wie man diese noch etwas optimieren könnte?

    Die letze Methode ist ürigens nicht von mir... diese habe ich bei wikipedia gefunden.

    Mfg
     
  2. Anzeige

    Schau dir mal diesen Ratgeber an. Viele Antworten inkl. passender Shell-Befehle!
    Registrieren bzw. einloggen, um diese und auch andere Anzeigen zu deaktivieren
  3. #2 Leno, 12.02.2005
    Zuletzt bearbeitet: 27.04.2007
    Leno

    Leno -

    Dabei seit:
    26.10.2003
    Beiträge:
    139
    Zustimmungen:
    0
    -Pi)^2.
     
  4. #3 BoneCracker, 12.02.2005
    BoneCracker

    BoneCracker Mitglied

    Dabei seit:
    27.08.2004
    Beiträge:
    46
    Zustimmungen:
    0
    Hi,
    Vielen Dank, ja, die fehlt noch. :)

    Mfg
     
  5. hawker

    hawker Grünschnabel

    Dabei seit:
    27.09.2005
    Beiträge:
    1
    Zustimmungen:
    0
    Hallo
    vor ein paar Jahren hat mir mal ein Maschinenmonteur aus dem damaligen Ostblock folgende Berechnung für PI gezeigt: 355/113. KISS! (keep it simple and stupid!)
    Gruss aus der Schweiz
    Hawker
     
  6. oenone

    oenone Freier Programmierer[Mod]

    Dabei seit:
    22.08.2002
    Beiträge:
    599
    Zustimmungen:
    0
    Ort:
    Mannheim
    toll.. schon wieder ein nekromant..

    auf bald
    oenone

    *trollt sich*
     
Thema: Errechnung der Zahl Pi in Java
Besucher kamen mit folgenden Suchen
  1. pi berechnen java

    ,
  2. mit welchen zahlen errechnet man pi

    ,
  3. Zahl pi long

    ,
  4. pi java berechnung
Die Seite wird geladen...

Errechnung der Zahl Pi in Java - Ähnliche Themen

  1. Dateien selektieren und zählen

    Dateien selektieren und zählen: Hallo, das ist mein erster Beitrag, bitte entschuldigt, falls nicht alles richtig geschrieben ist. Ich muss meine erste Hausaufgabe als...
  2. »Humble Staff Picks« mit zahlreichen Linux-Spielen

    »Humble Staff Picks« mit zahlreichen Linux-Spielen: Das Humble-Bundle-Team hat ein weiteres »Humble Bundle« geschnürt. Unter dem Titel »Humble Staff Picks« finden sich zahlreiche Spiele, die auch...
  3. Linux Presentation Day 2016.1 in zahlreichen Städten

    Linux Presentation Day 2016.1 in zahlreichen Städten: Am 30. April wollen User Groups, Studenten, Unternehmen und Bildungseinrichtungen in mehr als 80 deutschen Städten den Linux Presentation Day...
  4. Nmap 7.10 mit zahlreichen neuen Skripten und Fingerabdrücken

    Nmap 7.10 mit zahlreichen neuen Skripten und Fingerabdrücken: Der Nmap-Entwickler Gordon »Fyodor« Lyon hat bekannt gegeben, dass eine neue Version des populären, freien Netzwerkscanners veröffentlicht wurde....
  5. Nmap 7.10 mit zahlreichen neuen Skripten und Fingerabdrücken

    Nmap 7.10 mit zahlreichen neuen Skripten und Fingerabdrücken: Der Nmap-Entwickler Gordon »Fyodor« Lyon hat bekannt gegeben, dass eine neue Version des populären, freien Netzwerkscanners veröffentlicht wurde....