Pascal-Programme für Pi von Hans-Jürgen Caspar  

(Seite erstellt unter Windows und mit dem Internet Explorer. Mit anderen Systemen und Browsern
sind ein Schreibfehler - lat. p statt griech. pi - und falsche Einrückungen bei den Formeln möglich.)

 

Mit Pi oder p bezeichnet man das Verhältnis Kreisumfang zu Kreisdurchmesser: p = U/d, gleichbedeutend mit U = pd = 2pr, r = Kreisradius. Der genaue Wert von p ist nicht bekannt, doch bewies bereits vor über 2000 Jahren der griechische Mathematiker und Physiker ARCHIMEDES (287-212 v. Chr.), daß p zwischen 310/71 und 310/70 liegt. Für die obere dieser beiden Grenzen, 31/7, schreibt man oft auch 22/7 ; ein guter, für viele Anwendungsszwecke ausreichender, dezimal geschriebener Näherungswert ist 3,14. Wie die folgenden Programme zeigen, beginnt p mit 3,141592...; mit diesen sechs Nachkommastellen läßt sich der Umfang eines Kreises von 1 km Durchmesser auf einen Millimeter genau berechnen.

 

p kommt nicht nur bei der Kreisberechnung (sowohl Umfang wie Flächeninhalt) vor, sondern auch bei zylindrischen und kegelförmigen Gefäßen, deren Volumen man wissen möchte, sowie bei der Kugel. Auch auf vielen anderen mathematischen Gebieten, in der Physik und Technik spielt p eine große Rolle. Sogar in den Abmessungen der ägyptischen Pyramiden soll es nach einer bestimmten Theorie enthalten sein, und selbst die Poeten haben sich der Kreiszahl, wie p auch genannt wird, angenommen. Sie schrieben in verschiedenen Sprachen eine große Anzahl von Versen, zum Teil langen Gedichten, die das Auswendiglernen von p-Dezimalen erleichtern sollten; einige werden in [1] wiedergegeben. Eine weitere, vermutlich unbekannte, vom Verfasser dieser Zeilen durch Zufall entdeckte Kuriosität sei noch erwähnt: Wenn man für Verschlüsselungszwecke jedem Buchstaben eines Textes die Einerziffer seiner ASCII-Nr. zuordnet, ergibt sich beim Wort "geheim" 314159 – der Anfang von p!

 

ARCHIMEDES ging bei seinen Forschungen zur Kreiszahl von regelmäßigen Vielecken aus, die einem Kreis einbeschrieben bzw. umschrieben sind. Je höher die Eckenzahl dieser Vielecke ist, umso mehr nähern sie sich von innen und außen dem Kreis an. Archimedes begann beim regelmäßigen Sechseck, verdoppelte es anschließend zum Zwölfeck, dann zum 24-, 48-, 96-Eck usw. Jedesmal ist hierbei die Vieleckseite neu zu berechnen, und wenn der bei n Ecken erhaltene Wert sn mit n multipliziert wird, entsteht der zugehörige Vielecksumfang Un, der sich vom Kreisumfang U = 2pr immer weniger unterscheidet. Hört man schließlich bei einer bestimmten Eckenzahl k auf und dividiert Uk durch 2r, hat man einen Näherungswert pk für p. Aus geometrischen Überlegungen folgt dabei noch, daß sich die Seitenlänge s2n des Vielecks mit der Eckenzahl 2n aus derjenigen mit der Eckenzahl n nach der Formel

                           

s2n = sqrt(2-sqrt(4r²- sn²))·r                                  (1)

 

berechnen läßt. Dies wird in mehreren Schulbüchern, z.B. [2], die sich mit der näherungsweisen Berechnung von p beschäftigen, begründet und beim Programmieren angewendet.

 

Bei dem folgenden TurboPascal-Programm, welches der Einfachheit halber nur die einbeschriebenen Vielecke berücksichtigt (und die umschriebenen außeracht läßt) wird r=1 vorausgesetzt. Da wir vom Sechseck ausgehen, ist zu Anfang s=r=1. m zählt die einzelnen Näherungsschritte, n ist die Eckenzahl und p=3 der Anfangs-Näherungswert für p, der sich beim Sechseck ergibt.

 

Program piarchim; {Vieleckmethode nach Archimedes}

uses dos,crt;

var m,n,s,u,p:real;

    ch:char;

Begin

 clrscr;

 writeln('Drücke fortlaufend die Leertaste!');writeln;

 s:=1;m:=1;n:=6;p:=3;

 repeat

  writeln(m:3:0,' ',n:8:0,'   ',p:3:10);

  m:=m+1;n:=2*n;

  s:=sqrt(2-sqrt(4-s*s));  {*}

  u:=n*s;p:=u/2;

  repeat ch:=readkey until ch=' ';

 until m=21;

End.

 

Läßt man das Programm ablaufen, ist das Ergebnis enttäuschend: die Näherungswerte werden erst besser und dann wieder schlechter. Dies liegt an der begrenzten Rechnergenauigkeit und an dem verwendeten Ausdruck (1), der für diesen Zweck ungünstig ist. Erweitert man ihn mit sqrt(2+sqrt(4r²-sn²))r, ergibt sich eine andere Form, die diesen Nachteil nicht hat. Wird demgemäß die mit {*} gekennzeichnete Programmzeile durch die Zeile s:=s/sqrt(2+sqrt(4-s*s)); ersetzt, funktioniert das Programm einwandfrei und liefert die gewünschten Näherungswerte für p. (Anmerkung: m und n sind natürliche Zahlen, so daß eigentlich zu erwarten wäre, daß sie als Integer-Variable deklariert werden. Hierbei besteht aber die Gefahr, daß bei höherer Eckenzahl der Integer-Bereich überschritten wird. Außerdem ermöglicht die Verwendung von m und n als Real-Variable eine angenehm aussehende, rechtsbündige Ausgabe.)    

 

ARCHIMEDES lebte in Syrakus (Sizilien), und es dauerte über anderthalb Jahrtausende, bis seine Methode nach Mitteleuropa gelangte. Dies geschah zum Teil mit Hilfe der Araber, die damals in vielen Bereichen von Kultur und Wissenschaft führend waren. Der holländische Mathematiker LUDOLF VAN CEULEN (1540-1610) rechnete nach ARCHIMEDES bis zum einbeschriebenen 262-Eck(!) und gewann damit im Laufe mehrerer Monate 32 Nachkommastellen von p, die ihn berühmt machten. Bis ins 19. Jahrhundert bezeichnete man p auch als Ludolphsche Zahl. Anzumerken ist hierbei, daß es für praktische Zwecke völlig unsinnig ist, p auf 32 Stellen zu kennen, siehe das obige Beispiel mit nur sechs Dezimalen. Die Kreiszahl wurde mit LUDOLF VAN CEULEN zu einem eigenständigen, mathematischen Untersuchungsobjekt, und die Jagd nach immer mehr Stellen, die bis heute nicht aufgehört hat, begann mit ihm.

 

                                   xxxxxxx*

 

Die Situation in der p-Forschung änderte sich grundlegend, als im 17. Jahrhundert von LEIBNIZ (1646-1716) und NEWTON (1643-1727) – beide arbeiteten unabhängig voneinander – die Differential- und Integralrechnung erfunden wurden. Losgelöst von den ursprünglichen geometrischen Vorstellungen, beschritt man mit diesen beiden machtvollen mathematischen Werkzeugen völlig neue Wege.

 

Das folgende Programm entspricht nicht dem historischen Ablauf, ist aber sehr kurz und liefert p schon beim vierten Schritt auf zehn Stellen nach dem Komma genau. Es beruht auf NEWTONs Näherungsformel zum Auffinden einer Lösung der Gleichung f(x)=0, in der f(x) irgendeine differenzierbare Funktion von x bedeutet. Die Formel lautet:

 

xn+1 = xn - f(xn)/f'(xn).

 

Hierbei ist xn der bereits gefundene (oder angenommene) n-te Näherungswert der gesuchten Nullstelle von f(x) und xn+1 der daraus gewonnene, verbesserte (n+1)-te Näherungswert. f '(xn) bedeutet den Wert der Ableitungsfunktion von f(x) an der Stelle xn und darf nicht 0 werden. Für unser Programm verwenden wir die Sinusfunktion: f(x) = sin x, die bei x=p ihre erste Nullstelle >0 hat. Da p ungefähr gleich 3 ist, wählen wir als ersten Näherungswert x1=3. Aus ihm folgt wegen f '(x) = cos x der zweite: x2 = x1 – (sin x1)/(cos x1), daraus der dritte x3 = x2 – (sin x2)/(cos x2) usw.

 

Program pinewton;

uses dos,crt;

var n:integer;x:real;

Begin

clrscr;x:=3;

for n:=1 to 5 do

 begin

 writeln(x:1:10);

 x:=x-sin(x)/cos(x);

end;

repeat until keypressed;

End.

 

Den Mathematikern des 17. Jahrhunderts stand bereits eine große Palette von Möglichkeiten zur angenäherten Berechnung von p zur Verfügung, die im Laufe der Zeit immer mehr erweitert wurde: unendliche Reihen, Kettenbrüche, Kettenwurzeln und Produkte. Manches wurde auch fern von Europa, vor allem in China und Indien, erdacht. Vieles davon wird in dem Buch [3] ausführlich beschrieben bzw. zitiert; es gibt die Entwicklung der p-Forschung bis zum Ende des 20. Jahrhunderts wieder. Zahlreiche Formeln für p enthält auch das Internet-Dokument [4] (PDF-Datei, 60 Seiten in französischer Sprache).

 

Wir wollen uns hier nur der erstgenannten Möglichkeit zuwenden: den unendlichen Reihen. Schon den damaligen Forschern war aufgefallen, daß die Nachkommastellen von p keinerlei Regelmäßigkeit aufweisen und sich insbesondere nicht periodisch wiederholen, wie dies bei Brüchen der Fall ist. Der Verdacht lag nahe, daß es sich bei p um eine irrationale Zahl handelt wie Wurzel aus 2 oder lg 5. (Dies wurde von J. H. LAMBERT 1761 bewiesen.) So erregte es großes Aufsehen, als sich herausstellte, daß es doch eine einfache, leicht zu beschreibende Gesetzmäßigkeit für p gibt, wenn auch nicht bei der Darstellung im Dezimalsystem. Sie kommt in der Leibnizschen Reihe zum Ausdruck:

 

p/4 = 1 – 1/3 + 1/5 – 1/7 + 1/9 - + ... ,                         (2)

 

die im englischen Sprachraum oft auch als Gregory-Reihe bezeichnet wird.

 

Die Leibnizreihe ist der Sonderfall x=1 der Reihe für die Arkustangensfunktion:

 

arctan x = x – x^3/3 + x^5/5 – x^7/7 + - ...                      (3)

 

(Zur Erinnerung: arctan x = y ist gleichbedeutend mit tan y = x. Weil tan p/4 = 1 ist, ist arctan 1 = p/4.)

 

Faßt man je zwei aufeinanderfolgende Glieder der Leibnizreihe zu einem zusammen, entsteht aus (2) die Reihe

 

 p/8 = 1/(1·3) + 1/(5·7) + 1/(9·11) + .... ;                       (4)

 

sie entspricht der Reihe des Inders NILAKANTHA:

 

        1        1         1

p/8 = ------ + ------ + ------- + ... ,                            (4a) 

      2² - 1   6² - 1   10² - 1

 

der im 15. Jahrhundert, also lange vor LEIBNIZ und GREGORY (1638-1675), lebte. (Die Reihe (4a) wird übrigens in der Formelsammlung von [3] falsch zitiert: dort steht sie mit alternierenden Vorzeichen.)

 

Sowohl die Leibnizreihe (2) wie die aus ihr durch Umformung gewonnenen Reihen (4) bzw. (4a) sind, so schön sie aussehen, für die praktische Berechnung von p leider gänzlich ungeeignet. Dies erkennt man z. B. an (2): Das 1000. Glied dieser Reihe ist ungefähr gleich 0,0005; d. h., um nur vier sichere Nachkommastellen von p zu erhalten, muß man mindestens 10000 Glieder der Leibnizreihe berücksichtigen!

 

Die Leibnizreihe liefert deshalb so schlechte Ergebnisse, weil die Arkustangensreihe (3) für x=1 nur noch äußerst langsam konvergiert. (Daß sie es überhaupt tut und nicht divergiert, ist nicht selbstverständlich und in der Hochschulmathematik Gegenstand eines eigenen Beweises.) 

 

Wählt man das Argument x in (3), absolut gesehen, kleiner als 1, konvergiert die Reihe schneller, und dies kann man auf andere Weise für die angenäherte Berechnung von p ausnutzen. Es gilt nämlich nicht nur p/4 = arctan 1, sondern nach dem Schweizer Mathematiker EULER (1707-1783) auch: 

    

p/4 = arctan1/2 + arctan1/3.

 

Hiermit läßt sich die Kreiszahl auf eine vorgegebene Anzahl von Stellen sehr viel leichter berechnen als mit der Leibnizreihe. Mit der von EULER ebenfalls gefundenen Formel

 

p/4 = 5·arctan1/7 + 2·arctan3/79 ,

 

in der die Argumente der Arkustangensterme noch kleiner sind als in der vorhergehenden, erhielt er nach [3] zwanzig Stellen von p in weniger als einer Stunde – ein gewaltiger Fortschritt gegenüber dem, was oben über Ludolf van Ceulen berichtet wurde!

 

Bei den p-Berechnern war bis zur Erfindung des Computers und noch eine Weile danach die Formel von MACHIN (1680-1751):

          

p/4 = 4·arctan1/5 – arctan1/239                               (5)

 

eine der beliebtesten. Bei ihr ist das Argument des zweiten Arkustangensterms besonders klein. Sie spielt auch bei einem der folgenden Programme eine Rolle. Im übrigen bestehen die meisten anderen, auf Arkustangensbasis zur angenäherten Berechnung von p geeigneten Formeln aus drei oder mehr Termen.

 

Im Jahre 1995 wandten sich die beiden Amerikaner STANLEY RABINOWITZ und STANLEY WAGON wieder der ursprünglichen Leibnizreihe zu, die sie mit Hilfe der sog. Euler-Transformation wie folgt umformten [3a],[5],[6]:

 

        1     2     3

p = 2 + -(2 + -(2 + -(2 + ...))) .                            (6)

        3     5     7         

 

Wie diese Umformung im einzelnen vor sich ging, kann hier nicht erklärt werden und ist für das Weitere auch nicht erforderlich. Die geschachtelte Klammerschreibweise in (6) bewirkt, daß nicht mehr nur addiert, sondern auch multipliziert wird. Dadurch erhöht sich die Konvergenzgeschwindigkeit beträchtlich, so daß es bei geeigneter Programmierung nicht schwerfällt, 1000 Stellen von p und mehr in kurzer Zeit zu berechnen.

 

                                                                              xxxxxxxxxxxx*

 

Nun aber gibt es außer der Arkustangensreihe noch eine andere Reihe, die ebenfalls zur p-Berechnung herangezogen werden kann: die Arkussinusreihe:

 

                1  x^3    1·3 x^5   1·3·5 x^7

arcsin x = x + ---·--- + ---·--- + -----·--- + ....

                2   3     2·4  5    2·4·6  7 

 

Setzt man in ihr x=1/2, so ergibt sich wegen sin p/6=1/2 nach leichter Umformung:

     

        1    3·3       3·3·5       3·3·5·7 

p = 3 + - + ------ + --------- + ----------- + ...  .          (7)

        8   4·32·5   4·6·128·7   4·6·8·512·9

 

Dies läßt sich, ohne Benutzung der Euler-Transformation, durch fortgesetztes, einfaches Ausklammern, auf die Form

 

           1·1       3·3       5·5           

p  =  3 + -----(3 + -----(3 + -----(3 + ...)))                 (8)

          8·1·3     8·2·5     8·3·7 

 

bringen. Sie ähnelt der Darstellung (6) von RABINOWITZ und WAGON, weist aber zwei Besonderheiten auf: Zum einen ist Gl.(8) allem Anschein nach neu; in den ausgedehnten Formelsammlungen von [3] und [4] wird sie nicht erwähnt. Zum andern – und das ist für das weitere Vorgehen von größerer Bedeutung – konvergiert (8) doppelt so schnell wie (7); auf den Beweis dieser Behauptung, den der Verfasser für sich durchgeführt hat, werde hier verzichtet. 

 

 

Auf (8) beruht das nächste Programm:

 

Program pitau; {1000 Stellen von Pi}

 uses crt,dos;const n=1000;

 Var  i,j,k:integer;c,d,q,u,x:word;

      a    :array[1..n+1] of word;

procedure divi(y:word);

begin

 c:=0;for j:=1 to n+1 do

 begin x:=a[j]+c;q:=x div y;a[j]:=q;

 d:=x-y*q;c:=10*d;end;

end;

procedure mult(y:word);

begin

 for j:=1 to n+1 do a[j]:=y*a[j];

 for j:=n+1 downto 2 do

 begin u:=a[j] div 10;a[j-1]:=a[j-1]+u;

 a[j]:=a[j] mod 10;end;

end;

Begin

 clrscr;k:=trunc(n*ln(10)/ln(4));

 for i:=k downto 1 do begin divi(8);

 divi(i);mult(2*i-1);divi(2*i+1);

 mult(2*i-1);a[1]:=a[1]+3;end;write(' ');

 for i:=1 to n+1 do begin write(a[i]);

 if i=1 then write('.');if (i mod 6=0) then

 write(' ');if wherex=80 then write('   ');

 end;write('... (1000 Stellen)');repeat

 until keypressed;

End.

 

Es liefert bei 500 MHz Taktfrequenz 1000 Stellen von p in einer Sekunde. Das Programm ist insofern besonders einfach, als es nur zwei Prozeduren enthält, in denen das schriftliche Dividieren und Multiplizieren nachgeahmt wird. Eine besondere Additionsprozedur ist nicht erforderlich: es genügt, bei jedem Schritt den Inhalt der ersten Speicherplatz-Zelle des verwendeten Arrays um 3 zu erhöhen.

 

Für einen möglichst schnellen Ablauf wurden hauptsächlich Word-Variable verwendet. Dies hat zur Folge, daß sich das Programm nur auf knapp 2000 Stellen erweitern läßt.

 

                                                                                xxxxxxxxxxxx*

 

Die verschachtelte Klammerschreibweise wie in (6) und (8) wirkt sich auch günstig bei der Arkustangensreihe aus, wenn p mit deren Hilfe berechnet werden soll. Hier gilt, was anscheinend auch nirgends erwähnt wird:

 

                         1       1         3         5  

arctan(1/m) = -(1 - -----(1 - -----(1 - -----(1 - ...)))), m>1.   (9)  

              m     3·m·m     5·m·m     7·m·m

 

Wird (9) auf die Formel (5) von MACHIN angewendet, kann man wie folgt programmieren:

 

 Program pimachin;{1000 Stellen, mit der Formel von Machin berechnet}

 uses crt,dos;{ pi/4 = 4 arctan(1/5) - arctan(1/239) }

  const n=1005;{5 Sicherheitsstellen}

  var i,j,k,m,nr,di:integer;

      c,d,q,u,x:word;

      a:array[1..2,1..n+1] of word;

      ta,te:real;h,mi,se,hs:word;

 procedure divi(y:word);

 begin

  c:=0;for j:=1 to n+1 do

  begin x:=a[nr,j]+c;q:=x div y;a[nr,j]:=q;

  d:=x-y*q;c:=10*d;end;

 end;

 procedure mult(y:word);

 begin

  for j:=1 to n+1 do a[nr,j]:=y*a[nr,j];

  for j:=n+1 downto 2 do

  begin u:=a[nr,j] div 10;a[nr,j-1]:=a[nr,j-1]+u;

  a[nr,j]:=a[nr,j] mod 10;end;

 end;

 procedure atn;

 begin

  a[nr,1]:=1;k:=trunc(n*ln(10)/ln(m)/2);

  for i:=k downto 1 do

  begin

   divi(2*i+1);mult(2*i-1);divi(m);divi(m);

   for j:=2 to n-1 do a[nr,j]:=9-a[nr,j];

   a[nr,n]:=10-a[nr,n];

  end;

  divi(m);

 end;

  Begin

   gettime(h,mi,se,hs);ta:=3600*h+60*mi+se+hs/100;

   clrscr;writeln;

   nr:=1;m:=5;atn;mult(4);

   nr:=2;m:=239;atn;

   for i:=n downto 2 do

   begin

    di:=a[1,i]-a[2,i];

    if di<0 then

    begin di:=di+10;a[1,i-1]:=a[1,i-1]-1;end;

    a[1,i]:=di;

   end;

   nr:=1;mult(4);

   writeln('    ¶=3.');write('    ');

   gettime(h,mi,se,hs);te:=3600*h+60*mi+se+hs/100;

   for i:=2 to n-4 do

   begin

    write(a[1,i]);

    if ((i-1) mod 10=0) then write(' ');

    if ((i-1) mod 50=0) then begin write('(',i-1,')');

    writeln;write('    ');end;

   end;

   write('Rechenzeit ',te-ta:3:2,' s');

   repeat until keypressed;

  End.

 

Das Programm ist nur wenig komplizierter als das erste, aber doppelt so schnell. Mit ihm erhält man bei derselben Taktfrequenz wie oben (die auch im folgenden weiter vorausgesetzt wird), 1000 Stellen in einer halben Sekunde. Es läßt sich bis auf 4600 Stellen erweitern.

 

Bereits 1994 veröffentlichte DAVID ADAMSON [7] ein Programm für 2150 Stellen, in dem er die Machin-Formel in folgender Form anwandte:

 

p = 3.2 + 1/25(-3.2/3 + 1/25(3.2/5 + 1/25(-3.2/7 + ...).).) 

    

    - 1/239(4 +1/239^2(-4/3 +1/239^2(4/5 +1/239^2(-4/7 +...).).).  

                                       

Sie ähnelt unserer geschachtelten Klammerschreibweise (9), ist aber aus leicht erkennbaren Gründen für das Programmieren weniger vorteilhaft als diese. Bei gleicher Schnelligkeit ist das Programm von Adamson recht lang und unübersichtlich.

 

                                                                               xxxxxxxxxxxx*

 

10000 Stellen in einer Minute erhält man mit einer Formel von GAUSS (1777-1855):

 

 p=48*arctan(1/38)+80*arctan(1/57)+28*arctan(1/239)+96*arctan(1/268)

      

und dem Programm

 

 Program pigauss;{10000 Stellen von pi mit der Gauss-Formel}

 uses crt,dos;{pi=48*atn(1/38)+80*atn(1/57)+28*atn(1/239)+96*atn(1/268)}

 const n=10005;{5 Sicherheitsstellen}

 var i,j,k,m,nr,di:integer;

     c,d,q,u,x:word;

     a:array[1..2,1..n] of word;

     ch:char;

 procedure divi(y:word);

 begin

  c:=0;for j:=1 to n+1 do

  begin x:=a[nr,j]+c;q:=x div y;a[nr,j]:=q;

  d:=x-y*q;c:=10*d;end;

 end;

 procedure mult(y:word);

 begin

  for j:=1 to n+1 do a[nr,j]:=y*a[nr,j];

  for j:=n+1 downto 2 do

  begin u:=a[nr,j] div 10;a[nr,j-1]:=a[nr,j-1]+u;

  a[nr,j]:=a[nr,j] mod 10;end;

 end;

 procedure atn;

 begin

  a[nr,1]:=1;k:=trunc(n*ln(10)/ln(m)/2);

  for i:=k downto 1 do

  begin

   divi(2*i+1);mult(2*i-1);divi(m);divi(m);

   for j:=2 to n-1 do a[nr,j]:=9-a[nr,j];

   a[nr,n]:=10-a[nr,n];

  end;

  divi(m);

 end;

 procedure addi;

 begin

  for i:=n downto 2 do

   begin

    a[1,i]:=a[1,i]+a[2,i];u:=a[1,i]div 10;

    a[1,i-1]:=a[1,i-1]+u;

   end;

  for i:=1 to n do a[1,i]:=a[1,i] mod 10;

  end;

  procedure warten;

  begin

   writeln;writeln;

   write(i-1,' Stellen. ');

   if (i<n-4) then write('Weiter mit der Leertaste.')

   else write('Zurueck zum Programm mit der Leertaste.');

   repeat ch:=readkey until ch=' ';

   clrscr;writeln;

  end;

  Begin

   clrscr;writeln('Berechnet werden 10000 Stellen von Pi.');

   writeln('Bitte (bei 500 MHz Taktfrequenz) eine Minute warten!');

   nr:=1;m:=38;atn;mult(12);nr:=2;m:=57;atn;mult(20);addi;

   m:=239;atn;mult(7);addi;m:=268;atn;mult(24);addi;

   nr:=1;mult(4);clrscr;writeln('3.');

   for i:=2 to n-4 do

   begin

    write(a[1,i]);if i=1 then write('.');

    if (i-1) mod 4=0 then write(' ');

    if (i-1) mod 1000=0 then warten;

   end;

  End.

 

Angezeigt werden sie zu je 1000 beim Drücken der Leertaste. Ihre Richtigkeit überprüfen kann man bis zu 5000 mit [3], darüber hinaus mit [8].

 

                                     

Literatur

[1] Peter Mäder: Mathematik hat Geschichte, Metzler Schulbuch, 1992

[2] Kilian Keidel, Hans Joachim Müller: Informatik Pascal, Bayerischer

     Schulbuch-Verlag, 1988

[3] Jörg Arndt, Christoph Haenel: Pi, Springer Verlag, 2. Auflage, 2000

[3a] "    "        "        "     "  S. 78

[4] Gérard Sookahet: Formules et Algorithmes pour évaluer Pi,       

     http://www.multimania.com/gersoo/docs/pi/pi.pdf

[5] Rabinowitz S. and Wagon S., A spigot algorithm for p, American Mathematical

     Monthly 102(1995), p. 195-203 

[6] Internet-Dokument http://www.jjj.de/hfloat/spigot.txt   

[7] David Adamson: Getting Big Pi http://prog.cz/swag/swag/math/0081.htm.

[8] Liste mit 50000 Dezimalen:

     http://members.tripod.de/McSquirrel/en/forum/pi.htm 

[9] Werner Scholz: Die Geschichte der Approximation der Zahl Pi, 3. verb.

Version Nov. 2001, http://magnet.atp.tuwien.ac.at/scholz/projects/fba/fba.html 

 

 

Programm-Download:

 

piarchim.pas

pinewton.pas

pitau.pas

pimachin.pas

pigauss.pas

 

Wenn die unterstrichenen Programme mit "Speichern unter" als Textdateien auf die eigene Festplatte heruntergeladen wurden, erscheinen sie dort mit der Bezeichung name_pas.txt und müssen, um unter TurboPascal verwendbar zu sein, in name.pas umbenannt werden.



       Zur Ansicht: 1000 Stellen, mit pitau.pas berechnet

 

 

Seite erstellt am 9.10.01            

 

 

Nachtrag Dez. 2001:

Die angebene Seite von David Adamson ist inzwischen im Archiv von google gelandet (Suchwort: Getting Big Pi), und die Liste mit den 50000 Dezimalen ist ebenfalls nicht mehr verfügbar. Empfehlung: Wiederum google (im gesamten Web), Suchwort "pi digits" o. ä.

 

Nachtrag Jan. 2002:

In [9] wird eine Formel von G. F. FREEMAN aus dem Jahre 1958 zitiert mit drei Arkustangenstermen, in der nur subtrahiert wird: p=32arctan(1/10)–16arctan(1/515)-4arctan(1/239). Das Programm pifreem.pas ist ebenso schnell wie pimachin.pas, liefert aber 2000 richtige Stellen mehr als dieses.

 

Nachtrag März 2003:

Das oben erwähnte PDF-Dokument [4] findet man jetzt unter http://gersoo.free.fr/docs/docs.html ("Documentations personelles").


Nachtrag Juni 2008:

Ein C-Programm unter Verwendung von (8) für1000 Stellen von Pi in 70 ms gibt lagalopex am 22.8.06 (02:56) hier wieder: http://www.hackerboard.de/thread.php?threadid=27204 (mit Quellenangabe: dieser Artikel).

Zurück zur Pi-Eingangsseite