3,141592653589793238462643383279502884197169399375105 82097494459230781640628620899862803482534211706798214 80865132823066470938446095505822317253594081284811174 50284102701938521105559644622948954930381964428810975 66593344612847564823378678316527120190914564856692346 03486104543266482133936072602491412737245870066063155 88174881520920962829254091715364367892590360011330530 54882046652138414695194151160943305727036575959195309 21861173819326117931051185480744623799627495673518857 52724891227938183011949129833673362440656643086021394 94639522473719070217986094370277053921717629317675238 46748184676694051320005681271452635608277857713427577 89609173637178721468440901224953430146549585371050792 27968925892354201995611212902196086403441815981362977 47713099605187072113499999983729780499510597317328160 96318595024459455346908302642522308253344685035261931 18817101000313783875288658753320838142061717766914730 35982534904287554687311595628638823537875937519577818 57780532171226806613001927876611195909216420199
Leicht zu berechnende Flächen sind die von Rechtecken. Wir können nun versuchen, den Flächeninhalt des Kreisviertels näherungsweise zu bestimmen. Dazu verwenden wir Rechtecke, die auf der x-Achse stehen und deren auf der x-Achse liegende Seiten immer alle gleich lang sind. Die Rechtecke werden nun so hoch gemacht, dass sie gerade noch in den Kreis passen, sie werden ihm also einbeschrieben. Offensichtlich ist der Kreisinhalt größer als die Summe der Rechteckinhalte. Den Fehler, den wir dabei machen, können wir minimieren, wenn wir mehr und damit schmalere Rechtecke in den Kreis einbeschreiben.
Hier haben wir den Radius 1 in sechs gleich lange Abschnitte unterteilt. Dann lassen sich fünf Rechteckte einbeschreiben.
Außerdem können wir dem Kreis auch Rechtecke umbeschreiben. Dabei ist der Kreisinhalt offensichtlich kleiner als die Summe der Rechteckflächen.
Bei sechs gleich langen Abschnitten können wir sechs Rechtecke umbeschreiben.
Der gesuchte Flächeninhalt liegt also offenbar zwischen diesen Rechteckflächen-Summen. Wir bekommen n Rechtecke mit einer Flächeninhaltssumme, für die gilt: Aa > Pi/4 (da Viertelskreis).
Des weiteren bekommen wir n-1 Rechtecke mit einer Flächeninhaltssumme, für die gilt: Ai < Pi/4.
Bauen wir dies zusammen, erhalten wir:
Ai < Pi/4 < Aa
und damit
4Ai < Pi < 4Aa
Die Berechnung können wir nun von dem folgenden Computerprogramm (für DOS) erledigen lassen:
/*******************************************************************/
/* PI-Naeherung per Rechtecknaeherung */
/*******************************************************************/
#include <math.h>
void main (void)
{
int nanf, nend, s, n, k;
double sum, ai, aa;
printf ("\n\nEin- und Umbeschreibung von Rechtecken:");
printf ("\n\nGib Mindestzahl der Rechtecke: ");
scanf ("%d", &nanf);
printf ("\nGib Hoechstzahl der Rechtecke: ");
scanf ("%d", &nend);
printf ("\nGib Schrittweite: ");
scanf ("%d", &s);
printf ("\n\n n Ai Aa");
printf ("\n-------------------------------------");
for (n= nanf; n <= nend; n+= s)
{
sum= 0.0;
for (k= 1; k <= n - 1; k++)
{
sum+= sqrt (1.0 - pow (((double) k)/((double) n), 2.0));
}
ai= sum/(double) n;
aa= ai + 1.0/(double) n;
printf ("\n %8d %lf %lf", n, 4.0*ai, 4.0*aa);
}
}
Lassen wir uns die Werte für 1 bis 15 Rechtecke ausgeben, so erhalten wir:
Ein- und Umbeschreibung von Rechtecken: Gib Mindestzahl der Rechtecke: 1 Gib Hoechstzahl der Rechtecke: 15 Gib Schrittweite: 1 n Ai Aa ------------------------------------- 1 0.000000 4.000000 2 1.732051 3.732051 3 2.250887 3.584220 4 2.495709 3.495709 5 2.637049 3.437049 6 2.728650 3.395316 7 2.792658 3.364086 8 2.839819 3.339819 9 2.875963 3.320408 10 2.904518 3.304518 11 2.927630 3.291266 12 2.946708 3.280042 13 2.962716 3.270409 14 2.976335 3.262049 15 2.988058 3.254725Der Näherungswert für Pi ist also auch bei 15 Rechtecken noch sehr ungenau. Lassen wir uns daher die Werte im Bereich von 500 bis 10000 Rechtecken in 500er-Schritten ausgeben:
Ein- und Umbeschreibung von Rechtecken: Gib Mindestzahl der Rechtecke: 500 Gib Hoechstzahl der Rechtecke: 10000 Gib Schrittweite: 500 n Ai Aa ------------------------------------- 500 3.137487 3.145487 1000 3.139555 3.143555 1500 3.140239 3.142906 2000 3.140580 3.142580 2500 3.140783 3.142383 3000 3.140919 3.142252 3500 3.141016 3.142158 4000 3.141088 3.142088 4500 3.141144 3.142033 5000 3.141189 3.141989 5500 3.141226 3.141953 6000 3.141257 3.141923 6500 3.141283 3.141898 7000 3.141305 3.141876 7500 3.141324 3.141858 8000 3.141341 3.141841 8500 3.141356 3.141826 9000 3.141369 3.141813 9500 3.141381 3.141802 10000 3.141391 3.141791Selbst bei 10000 Rechtecken sind nur die ersten drei Nachkommastellen des Näherungswertes verläßlich. Das Verfahren konvergiert also sehr langsam.
/*******************************************************************/
/* Pi naeherungsweise */
/*******************************************************************/
#include <limits.h>
void main (void)
{
unsigned long int maxtropf, j, k= 0L, sz= 0L, s;
double rx, ry;
printf ("\n\nMonte-Carlo - Methode:");
printf ("\n\nGib Hoechstzahl der Tropfen: ");
scanf ("%lu", &maxtropf);
printf ("\nGib Schrittweite der Anzeige: ");
scanf ("%lu", &s);
printf ("\n\n Tropfen Pi");
printf ("\n------------------------");
for (j= 0L; j <= maxtropf; j++)
{
rx= ((double) rand ())/(double) INT_MAX;
ry= ((double) rand ())/(double) INT_MAX;
if ((rx*rx + ry*ry) <= 1.0)
{
k++;
}
sz++;
if ((sz > s) && j)
{
printf ("\n %10lu %lf", j, 4.0*((double) k/(double) j));
sz= 1L;
}
}
}
Hier nun die Ergebnisse zweier Programmläufe:
Monte-Carlo - Methode: Gib Hoechstzahl der Tropfen: 100 Gib Schrittweite der Anzeige: 10 Tropfen Pi ------------------------ 10 3.200000 20 3.200000 30 3.466667 40 3.400000 50 3.280000 60 3.266667 70 3.200000 80 3.150000 90 3.111111 100 3.040000
Monte-Carlo - Methode: Gib Hoechstzahl der Tropfen: 1000000 Gib Schrittweite der Anzeige: 100000 Tropfen Pi ------------------------ 100000 3.149520 200000 3.144900 300000 3.145880 400000 3.144700 500000 3.143552 600000 3.143720 700000 3.142760 800000 3.142010 900000 3.141636 1000000 3.141484Es sind also sehr große Tropfenzahlen erforderlich, um eine brauchbare Statistik zu erhalten.
Pi/4= 1 - 1/3 + 1/5 - 1/7 + 1/9 - 1/11 + 1/13 - ...
Das nachfolgende Programm (für DOS) berechnet uns nun diese Summe:
/*******************************************************************/
/* Pi naeherungsweise: Leibniz-Reihe */
/*******************************************************************/
void main (void)
{
int sz, maxsum, as, asz= 1, nenner= 3;
double piv= 1.0;
printf ("\n\nReihenentwicklung nach Leibniz:");
printf ("\n\nGib Maximalzahl der Summanden: ");
scanf ("%d", &maxsum);
printf ("\nGib Anzeigeschrittweite: ");
scanf ("%d", &as);
printf ("\n\n Summmand Nr. Pi");
printf ("\n-----------------------------------");
printf ("\n 1 1.000000");
for (sz= 2; sz <= maxsum; sz++)
{
if (!(sz%2))
{
piv-= 1.0/(double) nenner;
}
else
{
piv+= 1.0/(double) nenner;
}
nenner+= 2;
asz++;
if (asz >= as)
{
printf ("\n %5d %lf", sz, piv*4.0);
asz= 0;
}
}
}
Jetzt zwei Programmläufe:
Reihenentwicklung nach Leibniz: Gib Maximalzahl der Summanden: 10 Gib Anzeigeschrittweite: 1 Summmand Nr. Pi ----------------------------------- 1 1.000000 2 2.666667 3 3.466667 4 2.895238 5 3.339683 6 2.976046 7 3.283738 8 3.017072 9 3.252366 10 3.041840
Reihenentwicklung nach Leibniz: Gib Maximalzahl der Summanden: 20000 Gib Anzeigeschrittweite: 2000 Summmand Nr. Pi ----------------------------------- 1 1.000000 2000 3.141093 4000 3.141343 6000 3.141426 8000 3.141468 10000 3.141493 12000 3.141509 14000 3.141521 16000 3.141530 18000 3.141538 20000 3.141549[zurück][Anfang][Start] [Stichwörter]