Pi mit Monte-Carlo-Simulation und Leibnitz-Formel berechnen

Die Kreiszahl π≈3,14159 ist jedem bekannt, aber wie berechnet man sie? Viele Mathematiker haben sich damit beschäftigt und sehr viele interessante und mächtige Algorithmen entwickelt, so das mittlerweile über 5 Billionen Nachkommastellen von Pi bekannt sind.

Am einfachsten bestimmt man die Kreiszahl nach ihrer Definition. Man nimmt also einen Kreis, misst seinen Durchmesser und seinen Umfang und berechnet das Verhältnis Durchmesser/Umfang, welches der Kreiszahl entspricht. Das kann auch jeder Zuhause sehr schnell mit einen Faden, einen Lineal und einem kreisförmigen Gegenstand überprüfen :).
Besonders genau ist diese Methode aber nicht – man braucht eine mathematische Herangehensweise.

Eine andere interessante Methode ist die Leibniz-Reihe die folgendermaßen lautet.

[math] \sum_{n=0}^\infty \frac{(-1)^n}{2n+1} = 1 -\frac{1}{3} + \frac{1}{5} -\frac{1}{7} + … = \frac{\pi}{4} [/math]

Je mehr Glieder man berechnet, desto mehr nähert sich der berechnete Wert π/4 an.
Ich habe eine Funktion in C++ geschrieben, die Pi nach dieser Methode berechnet.

// berechnet Pi nach Leibniz-Formel
double piWithPowerSeries(unsigned int steps)
{
	// pi/4
	double piQuarter = 0.0;

	for(unsigned n = 0; n < steps; n++)
	{
		piQuarter = piQuarter + pow(-1.0, static_cast<int>(n)) / (2*n +1);
	}

	// pi/4 * 4 = pi
	return piQuarter*4;
}

Die Berechneten Werte sehen dann folgendermaßen aus.

Eine andere und meiner Meinung nach intuitive Methode ist die Monte-Carlo-Simulation.
Die Idee dahinter ist ziemlich simpel. Man lege einen Kreis oder noch simpler einen Viertelkreis in einen Quadrat, so dass der Durchmesser des Kreises gerade der Seitenlängen des Quadrats entspricht.

Jetzt verteilt man in dem ganzen Quadrat zufällig Koordinatenpunkte.

Hat man die Punkte verteilt, so zählt man wie viele von ihnen im Kreis liegen. Für große Anzahl der Punkte geht die Häufigkeitsvertelung der Punkte in die Wahrscheinlichkeit über. Mit anderen Worten: die Anzahl der Punkte im Kreis im Verhältnis zu der Gesamtzahl gibt die Wahrscheinlichkeit an, dass der nächste zufällig gesetzte Punkt auch im Kreis landet und somit entspricht diese Wahrscheinlichkeit auch dem Verhältnis der Kreisfläche zur Gesamtfläche.

[math] \frac{Punkte\ im\ Kreis}{Punkt\ im\ Quadrat} \approx \frac{Kreisflaeche}{Quadratflaeche} = \frac{\pi r^2}{(2 r)^2} = \frac{\pi}{4} [/math]

Ziemlich cool oder? ;)

Zur diesen Methode habe ich auch eine C++ Funktion geschrieben.

// erzeugt (Pseudo-)Zufallswerte zwischen 0.0 und 1.0 
double getRand()
{
	return static_cast<double>(rand())/static_cast<double>(RAND_MAX);
}

// berechnet Pi mit Monte-Carlo-Simulation
double piWithMCS(unsigned int steps)
{
	// Zufallsgenerator initialisieren
	srand(time(0));

	// Anzahl der Punkte in einem Viertel eines Einheitskreises
	double in = 0.0;
	
	for(unsigned n = 0; n < steps; n++)
	{
		// Zufälligen Punkt generieren
		double x = getRand();
		double y = getRand();

		// schauen ob der Punkt im Kreis liegt
		if(x*x + y*y <= 1.0)
			in++;
	}

	return 4*(in/steps);
}

Das Ergebnis sieht dann so aus.

Der Wert konvergiert nicht so schnell gegen Pi, wie mit der Leibniz-Formel, aber er konvergiert.

Ich finde es schon irgendwie faszinierend, dass das einfache Auswerten von Zufallswerten sich auf so eine Art und Weise nutzen lässt.
Wer Lust und Zeit hat, kann ja versuchen das Ergebnis auch mit einem Spielwürfel zu bestimmen ;)

Hier ist noch mal der komplette Quelltext als Cpp-Datei: Pi-Berechnung