Errechnung der Zahl Pi in Java

Diskutiere Errechnung der Zahl Pi in Java im Java/Mono/dotGNU Forum im Bereich Programmieren unter Linux/Unix; 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...

  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

    Anzeige

    Wenn du mehr über Linux erfahren möchtest, dann solltest du dir mal folgende Shellkommandos anschauen.


    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 Gast

    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. java pi berechnen

    ,
  3. java pi errechnen

    ,
  4. pi brechnen java,
  5. java mit pi rechnen,
  6. zahl pi in java erstellen,
  7. java pi kommazahlen berechnen,
  8. java kreis pi,
  9. pi berechnen mit java,
  10. pi mit java berechnen,
  11. leibniz pi berechnen java for,
  12. Pi in java,
  13. java coding pi berechnen,
  14. pi berechnungsarten,
  15. pi mit leibniz berechnen java,
  16. Berechung und Ausgabe von PI java,
  17. mit welchen zahlen errechnet man pi,
  18. Zahl pi long,
  19. pi java berechnung
Die Seite wird geladen...

Errechnung der Zahl Pi in Java - Ähnliche Themen

  1. »Humble Sakura Collection« mit zahlreichen Linux-Titeln

    »Humble Sakura Collection« mit zahlreichen Linux-Titeln: Das Humble-Bundle-Team hat ein neues Paket erstellt. Unter dem Titel »The Humble Sakura Collection Bundle« finden sich insgesamt 20 Anime-Spiele,...
  2. Qt: LTS nur noch für zahlende Kunden

    Qt: LTS nur noch für zahlende Kunden: Das zum finnischen Softwareunternehmen Digia gehörende Anwendungs-Framework Qt erfährt 2020 einige wichtige Änderungen. Unter anderem werden...
  3. Wine 5.0 mit zahlreichen Neuerungen

    Wine 5.0 mit zahlreichen Neuerungen: Über ein Jahr nach der Freigabe von Version 4.0 hat das Wine-Projekt die nächste stabile Version der Windows-Laufzeitumgebung veröffentlicht. In...
  4. Blender 2.81 mit zahlreichen Korrekturen

    Blender 2.81 mit zahlreichen Korrekturen: Knapp vier Monate nach Blender 2.80 steht mit Blender 2.81 eine neue Version des 3D-Modellierungs- und Animationsprogramms zum Download bereit....
  5. Fedora 31 mit zahlreichen Neuerungen

    Fedora 31 mit zahlreichen Neuerungen: Die Linux-Distribution Fedora wurde in Version 31 veröffentlicht. Sie setzt auf Gnome 3.34 als Desktop auf und bringt neben Verbesserungen bei...
  1. Diese Seite verwendet Cookies um Inhalte zu personalisieren. Außerdem werden auch Cookies von Diensten Dritter gesetzt. Mit dem weiteren Aufenthalt akzeptierst du diesen Einsatz von Cookies.
    Information ausblenden