Wie wird pi (p) berechnet?

StackOverflow https://stackoverflow.com/questions/2654749

  •  27-09-2019
  •  | 
  •  

Frage

Wie kann ich eine Funktion schreiben, das pi (p) auf eine bestimmte Anzahl von Dezimalstellen angezeigt werden kann?

Die Geschwindigkeit ist kein Problem. Ich habe mich unter http://bellard.org/pi/ , aber ich weiß immer noch nicht verstehen wie die n-te Ziffer von Pi erhalten.

War es hilfreich?

Lösung

In Kalkül gibt es eine Sache, Taylor-Reihe genannt, die eine einfache Möglichkeit bietet viele irrationale Werte beliebiger Genauigkeit zu berechnen.

Pi / 4 = 1 - 1/3 + 1/5 - 1/7 + ...
(Von http://www.math.hmc.edu/funfacts/ffiles /30001.1-3.shtml )

Halten Sie diese Bedingungen bis die Anzahl der Ziffern der Präzision Hinzufügen Sie stabilisieren wollen.

Satz von Taylor ist ein mächtiges Werkzeug, aber die Ableitung dieser Serie den Satz über den Rahmen der Frage verwenden ist. Es ist Standard-First-Jahres-Universität Kalkül und ist leicht googlable, wenn Sie näher interessiert sind.

habe ich nicht gemein implizieren, dass dies die praktischste Methode zu berechnen pi. Das würde davon abhängen, warum Sie tun müssen, um es wirklich. Aus praktischen Gründen sollten Sie kopieren Sie einfach so viele Ziffern wie man es von einem der vielen veröffentlichten Versionen benötigen. Ich war darauf hindeutet, dies als eine einfache Einführung, wie irrational Werte können auf unendliche Reihe gleichgesetzt werden.

Andere Tipps

Es gibt viele Algorithmen für numerische Approximation von p .

Als Alternative zu JeffH Methode der jede Variation speichern, können Sie speichern nur die maximale Anzahl der Ziffern und abgeschnitten, was Sie nicht brauchen: 

#include <string>
#include <iostream>
using std::cout; using std::endl; using std::string;

// The first 99 decimal digits taken from:
// http://www.geom.uiuc.edu/~huberty/math5337/groupe/digits.html
// Add more as needed.
const string pi =
  "1415926535"
  "8979323846"
  "2643383279"
  "5028841971"
  "6939937510"
  "5820974944"
  "5923078164"
  "0628620899"
  "8628034825"
  "342117067";

// A function in C++ that returns pi to X places
string CalcPi(const size_t decimalDigitsCount) 
{
  string returnValue = "3";
  if (decimalDigitsCount > 0)
  {
    returnValue += "." + pi.substr(0, decimalDigitsCount);
  }
  return returnValue;
} 

int main()
{
  // Loop through all the values of "pi at x digits" that we have. 
  for (size_t i = 0; i <= pi.size(); ++i) 
  {
    cout << "pi(" << i << "): " << CalcPi(i) << endl;
  } 
}

http://codepad.org/6mqDa1zj

Ich glaube, dass der Algorithmus Sie suchen ist, was als bekannt ist „Spigot-Algorithmus.“ Eine besondere Art ist die BBP (Bailey-Borwein-Plouffe) Formel.

Ich glaube, dass das, was Sie suchen.

Versuchen „ Berechnung der n-ten Stelle von PU in jeder Base in O (n ^ 2) “. Es ist wahrscheinlich der schnellste bekannte Algorithmus, der nicht willkürlich benötigt (lesen Sie große ) Präzision Schwimmer und können Sie das Ergebnis direkt in der Basis 10 (oder andere) geben.

" p IN DER Mandelbrot-Menge “erkundet die neugierige Beziehung zwischen einer Folge von Punkten in der komplexen Ebene und wie ihre Berechnung‚Mandelbrot-Nummer‘(mangels einen besseren Begriffs ... die Anzahl der Iterationen erforderlich, um festzustellen, dass die Punkte in der Reihenfolge sind nicht Mitglieder der Mandelbrot-Menge) bezieht sich auf PI.

Praktische? Wahrscheinlich nicht.

Unerwartete und interessant? Ich denke schon.

Sind Sie bereit, Werte zu suchen, anstatt sie der Berechnung?

Da Sie nicht explizit angeben, dass Ihre Funktion zu berechnet Werte, hier ist eine mögliche Lösung , wenn Sie bereit sind, eine Obergrenze für die Anzahl der Stellen, um es kann „berechnen „: 

// Initialize pis as far out as you want. 
// There are lots of places you can look up pi out to a specific # of digits.
double pis[] = {3.0, 3.1, 3.14, 3.141, 3.1416}; 

/* 
 * A function that returns pi out to a number of digits (up to a point)
 */
double CalcPi(int x)
{
    // NOTE: Should add range checking here. For now, do not access past end of pis[]
    return pis[x]; 
}

int main()
{
    // Loop through all the values of "pi at x digits" that we have.
    for (int ii=0; ii<(int)sizeof(pis)/sizeof(double); ii++)
    {
        double piAtXdigits = CalcPi(ii);
    }
}

Schreiben CalcPi () auf diese Weise (wenn es Ihren Bedürfnissen entspricht) eine Seiten profitieren gleichermaßen von Sein Schreien schnell für jeden Wert von X innerhalb Ihrer Obergrenze.

würde ich mit der Formel

starten 
pi = 16 arctan (1/5) - 4 arctan (1/239)

Google wird leicht einen Beweis für diese Formel findet, dass normale Menschen verstehen können, und eine Formel, um die Arcustangens-Funktion zu berechnen. Dies ermöglicht es Ihnen ein paar tausend Dezimalstellen von Pi berechnen ganz einfach und schnell.

Sie können die Genauigkeit sagen, basierend auf dem letzten Begriff, den Sie hinzugefügt (oder abgezogen). Da die Amplitude jeder Sequenz Begriff in Alans immer abnimmt, und jeder Begriff wechselt das Vorzeichen, wird die Summe mehr verändern als die letzte Begriff.

Die Übertragung dieses Geplapper: Nach 1/5 Zugabe wird die Summe nicht mehr ändern als 1/5, so dass Sie innerhalb 1/5 präzise sind. Natürlich, werden Sie diese um 4 zu multiplizieren, also bist du wirklich nur genau bis 4/5.

Leider Mathematik nicht immer leicht in Dezimalstellen übersetzen.

Meine zwei Cents ... Dies könnte nicht die schnellsten, aber ich denke, es ist ganz einfach zu verstehen. Ich kam mit ihm selbst während einer Mathe-Vorlesung, und ich habe nicht wirklich es in der Literatur nirgends gesehen. Entweder bin ich ein Genie, wirklich dumm, oder nicht wirklich achten Sie auf Bücher über Mathematik zu lesen, oder alle der oben genannten ...:)

Wie auch immer ... Beginnen Sie mit dem Einheitskreis. Wir wissen, dass x ^ 2 + y ^ 2 = 1, so sqrt y (1-x ^ 2) =. Wir wissen auch, dass der Bereich des Einheitskreises ist PI. Wenn wir nun das Integral der Funktion sqrt nehmen (1-x ^ 2) im Bereich von 0 bis 1, werden wir ein Viertel des PIS erhalten. So multiplizieren es von 4 zu erhalten PI:

Wenn wir versuchen würden, diese analytisch zu lösen, ich bin sicher, wir würden nur PI zurück. Aber es ist ganz einfach, ein Programm zu schreiben, es numerisch zu lösen. Das folgende ist in C: 

#include <math.h>
#include <stdio.h>

void main(void) {
    double interval=0.0000001,area=0,x,y;

    for (x=0; x<1; x+=interval)
        area+=4*interval*sqrt(1-x*x);

    printf("pi ~ %.20f\n",area);
}

es mit der obigen Einstellung für interval Rennen, erhalten wir: 

pi ~ 3.14159285415672595576

So 10.000.000 Iterationen geben 6 richtige Dezimalstellen. Nicht die effizienteste, aber es ist mein Baby ...:) 

pi = function () {
    let pi = 3;
    let a = 3;
    let even = false;
    let turn;

    while (a <= 90000) {
        turn = (4/((Math.pow(a, 3)) - (a)));

        if(even){
            turn = turn*-1;
            even = false;
        } else {
            even = true;
        }
        pi = pi + turn;
        a = a + 2;
    }
    return pi;
};

Betrachten Sie dies eine grobe Skizze, aber es ist ein einfacher Ansatz, dass ein Anfänger implementieren könnte. 

int x = 9;
double pi = double(22/7);
String piAsString = pi.toString();
String valueAtXPosition = piAsString.subString(x, x+1);
int valueAtXPosAsInt = Integer.parseInt(valueAtXPosition);
Lizenziert unter: CC-BY-SA mit Zuschreibung
Nicht verbunden mit StackOverflow
scroll top