Einzelne Ziffern von Pi nach Bailey, Borwein Plouffe

Universität Paderborn
Fakultät für Elektrotechnik, Informatik und Mathematik
WS 2004/05
Seminararbeit
Einzelne Ziffern von Pi nach Bailey,
Borwein & Plouffe
Sebastian Aland
[email protected]
6. April 2005
Teil des Seminars Zahlen: Berechnung von Pi“
”
Prof. Dr. Joachim von zur Gathen
Betreuer: Dr. Michael Nüsken
Seminararbeit: Einzelne Ziffern von Pi nach Bailey, Borwein & Plouffe
Inhaltsverzeichnis
1. Einführung
3
2. Die BBP-Formel für π
4
3. Der BBP-Algorithmus
8
4. Abschließende Bemerkungen
11
A. Der PSLQ-Algorithmus
12
B. Berechnungen einiger Konstanten
13
C. Eine effiziente Implementierung in C
14
Literatur
17
2
Seminararbeit: Einzelne Ziffern von Pi nach Bailey, Borwein & Plouffe
Bailey, Borwein und Plouffe präsentierten 1997 einen Algorithmus, mit
dem sich einzelne Hexadezimal-Stellen von π bestimmen lassen, ohne
dass die voherigen Stellen berechnet werden müssen. Hierfür verwendeten
sie eine Darstellung von π als Summe, die man schnell berechnen kann.
1. Einführung
Die Aufgabe π auf möglichst viele Nachkommastellen zu berechnen ist nicht neu, in
der Tat ist sie eine der ältesten mathematischen Aufgaben, die es gibt. Dabei haben
sich die Verfahren zur Bestimmung von π zwar stets verbessert und es wurden immer
mehr Stellen von π bekannt, jedoch beruhte die Berechnung einer Nachkommastelle
immer auf der Kenntnis ihrer Vorgänger.
Dank Bailey, Borwein und Plouffe ist es seit kurzem möglich, eine bestimmte Stelle
von π direkt zu berechnen, ohne alle Stellen davor kennen zu müssen. Ihre Ergebnisse
([01]), auf denen diese Arbeit aufbaut, veröffentlichten sie 1997 in Mathematics of
”
Computation“.
Natürlich ist es möglich, eine bestimmte Stelle von π mit Hilfe der bekannten Algorithmen zu bestimmen, indem man π einfach bis zu der gewünschten Stelle berechnet - und dies ist von der Laufzeit her auch nicht unbedingt schlechter. Jedoch
erweist sich das Verfahren von Bailey, Borwein und Plouffe aus anderen Gründen als
besonders empfehlenswert. Es benötigt keine multiple-precision“-Arithmetik, lässt
”
sich sehr einfach implementieren und kann dadurch auch erfolgreich auf Heim-PCs
angewandt werden.
Ausgangspunkt für das Bailey-Borwein-Plouffe-Verfahren“ (im Folgenden mit BBP”
”
Verfahren“ bezeichnet) ist die Darstellung von π als einfache Summe mit besonderer
Eigenschaft - sie lässt sich besonders schnell berechnen:
∞
X
1
2
1
1
4
π=
·
−
−
−
i
16
8i
+
1
8i
+
4
8i
+
5
8i + 6
i=0
3
Seminararbeit: Einzelne Ziffern von Pi nach Bailey, Borwein & Plouffe
2. Die BBP-Formel für π
Durch eine Kombination aus inspiriertem Raten und extensiven Forschungen mit
Hilfe des PSLQ integer relation algorithm“ (siehe Anhang A für eine kurze Be”
schreibung) haben Bailey, Borwein und Plouffe folgende Gleichheit für π gefunden:
∞
X
1
2
1
1
4
−
−
−
)
π=
·(
i
16
8i
+
1
8i
+
4
8i
+
5
8i
+
6
i=0
(1)
Um diese Gleichheit zu beweisen wird zunächst gezeigt, dass das folgende Integral
eine Darstellung von π liefert:
√
1/
Z 2
π=
√
√
4 2 − 8x3 − 4 2x4 − 8x5
dx
1 − x8
0
Beweis von (2). Durch Partialbruchzerlegung erhält man:
√
1/
Z 2
0
√
√
4 2 − 8x3 − 4 2x4 − 8x5
dx
1 − x8
√
1/
Z 2
=
√
4 2
2
2
−4x
√
√
+
+
+
dx
2
2
x − 2x + 1 x − 2x + 1 x − 1 x + 1
0
√
1/
Z 2
=
0
−4x
√
dx +
2
x − 2x + 1
√
1/
Z 2
√
1/
Z 2
√
1/
Z 2
√
4 2
√
dx
x2 − 2x + 1
0
2
2
dx +
dx
x−1
x+1
0
0
√
√
√
1/ 2
= [−4 arctan ( 2x − 1) − 2 ln (x2 − 2x + 1)]0
√
√
√
√
1/ 2
1/ 2
1/ 2
+ [8 arctan ( 2x − 1)]0
+ [2 ln x − 1]0
+ [2 ln x + 1]0
√
3
3 √
= 2 ln 2 − π + 2π + ln ( − 2) + ln ( 2 + )
2}
| 2
{z
+
=−2 ln 2
=π .
4
(2)
Seminararbeit: Einzelne Ziffern von Pi nach Bailey, Borwein & Plouffe
Des Weiteren benötigt man folgende Gleichungen als Hilfsmittel:
n
X
1 − xn+1
xi =
,
1−x
i=0
∞
X
xi =
i=0
1
für |x| < 1 .
1−x
(3)
(4)
Beweis. Zu (3): Der Beweis lässt sich per vollständiger Induktion über n führen.
P
0+1
Induktionsanfang (n = 0): 0i=0 xi = x0 = 1 = x x−1−1 X .
Induktionsvoraussetzung (I.V.): Es gelte (3) für beliebiges, festes n ∈ N.
Induktionsschluss (n → n + 1):
n+1
X
xi =
i=0
n
X
I.V.
xi + xn+1 =
i=0
n+1
=
xn+1 − 1
+ xn+1
x−1
− 1 + xn+2 − xn+1
1 − x(n+1)+1
=
.
x−1
1−x
x
Zu (4):
∞
X
i
x = lim
n
X
n→∞
i=0
xi
i=0
=0, da |x|<1
(3)
xn+1 − 1
=
n→∞ x − 1
= lim
z }| {
lim (xn+1 ) −1
n→∞
=
x−1
1
.
1−x
Mit Hilfe von (4) lässt sich nun diese wichtige Gleichung zeigen (k ∈ N):
√
1/
Z 2
xk−1
(I)
dx =
8
1−x
√
1/
Z 2
0
∞
X
x
k−1+8i
dx =
i=0
0
∞
1 X
(II)
2k/2
i=0
16i
1
· (8i + k)
(5)
Beweis von (5). Zu (I):
√
Es gilt |x| < 1, da 0 ≤ x ≤ 1/ 2, somit lässt sich (4) anwenden.
∞
X
x
k−1+8i
=x
i=0
k−1
∞
X
i=0
(4)
= xk−1 ·
8i
x =x
k−1
∞
X
(x8 )i
i=0
k−1
1
x
=
.
8
1−x
1 − x8
5
Seminararbeit: Einzelne Ziffern von Pi nach Bailey, Borwein & Plouffe
Zu (II): Aus den Ableitungsregeln folgt:
!0
∞
∞
X
X
1
· xk+8i =
xk−1+8i .
k
+
8i
i=0
i=0
Und damit:
√
1/
Z 2
∞
X
0
"
xk−1+8i dx =
i=0
∞
X
i=0
=
∞
X
i=0
=
=
1
2k/2
1
2k/2
1
· xk+8i
k + 8i
#1/√2
0
1
1
· ( √ )k+8i − 0
k + 8i
2
·
·
∞
X
i=0
∞
X
i=0
1
√
(k + 8i) · ( 2)8i
1
.
16i · (8i + k)
Nun ist es möglich (1), also die BBP-Formel für π zu beweisen:
6
Seminararbeit: Einzelne Ziffern von Pi nach Bailey, Borwein & Plouffe
Beweis. Dies zeigt man nun durch (2) und (5), denn
(2)
√
1/
Z 2
π=
√
√
4 2 − 8x3 − 4 2x4 − 8x5
dx
1 − x8
0
√
=4 2·
√
1/
Z 2
0
√
−4 2·
0
x
dx − 8 ·
1 − x8
√
1/
Z 2
√
1/
Z 2
0
4
x
dx − 8 ·
1 − x8
0
x3
dx
1 − x8
√
1/
Z 2
x5
dx
1 − x8
0
∞
∞
1 X
1 X
1
1
(5) √
= 4 2·( √
)−8·( √
)
i
i
1
4
( 2) i=0 16 (8i + 1)
( 2) i=0 16 (8i + 4)
∞
∞
√
1 X
1 X
1
1
√
)
−
8
·
(
)
−4 2·( √
( 2)5 i=0 16i (8i + 5)
( 2)6 i=0 16i (8i + 6)
∞
∞
X
X
4
2
=
−
i
i
16 (8i + 1) i=0 16 (8i + 4)
i=0
−
∞
X
i=0
∞
X
1
1
−
i
i
16 (8i + 5) i=0 16 (8i + 6)
∞
X
1
4
2
1
1
=
·(
−
−
−
).
i
16
8i
+
1
8i
+
4
8i
+
5
8i
+
6
i=0
7
Seminararbeit: Einzelne Ziffern von Pi nach Bailey, Borwein & Plouffe
3. Der BBP-Algorithmus
Um nun eine einzelne Stelle von π effizient berechnen zu können unterteilt man (1)
zunächst wie folgt in Teilsummen:
π=
∞
X
2
1
1
1
4
−
−
−
)
·
(
i
16
8i
+
1
8i
+
4
8i
+
5
8i
+
6
i=0
=:S1
=4·
z
∞
X
}|
=:S2
{
1
−2 ·
i
16 · (8i + 1)
i=0
∞
X
−1·
|i=0
16i
z
∞
X
}|
{
1
16i · (8i + 4)
i=0
∞
X
1
1
−1 ·
i
· (8i + 5)
16 · (8i + 6)
{z
}
|i=0
{z
}
=:S3
=:S4
= 4 · S1 − 2 · S2 − S3 − S 4
Die Hexadezimal-Ziffern der Teilsumme Si , beginnend ab Stelle d + 1 erhält man
durch den Nachkomma-Anteil von 16d Si (im Folgenden bezeichnet mit frac (16d Si )“).
”
Diesen Anteil kann man durch die Modulo-Funktion mod erhalten, die wie folgt definiert sei:
x
mod y := x − bx/yc · y
Damit erhält man beispielsweise für den Nachkomma-Anteil von S1 :
∞
X
16d−k
frac (16 S1 ) =
8k + 1
k=0
d
d
X
16d−k
=
8k + 1
k=0
(∗)
=
d
X
16d−k
k=0
mod 1
∞
X
16d−k
mod 1 +
8k + 1
k=d+1
mod 8k + 1
8k + 1
mod 1 +
mod 1
∞
X
16d−k
8k + 1
k=d+1
mod 1
Für wen (∗) nicht sofort einsehbar ist, wird im Folgenden für x, a ∈ N die Gleichung
x mod a
= xa mod 1 bewiesen:
a
8
Seminararbeit: Einzelne Ziffern von Pi nach Bailey, Borwein & Plouffe
Beweis von (∗). Sei x = ma + r, mit m, r ∈ N0 , r < a. Dann gilt:
x
x − bx/ac · a
mod a
=
a
a
=m, da r<a
z
}|
{
ma + r − b(ma + r)/ac ·a
r
=
= .
a
a
Außerdem ergibt sich:
x
a
ma r
+ ) mod 1
a
a
k
r j
r
r
= m + − (m + )/1 · 1 = .pslq
a
a
a
mod 1 = (
Bemerkung: Es genügt hier tatsächlich diese Gleichung nur“ für a, n ∈ N zu zeigen,
”
da mit k ≤ d (k ∈ N0 , d ∈ N) sowohl 16d−k , als auch 8k + 1 (bzw. 8k + 4, 8k + 5,
8k + 6 für die Teilsummen S2 , S3 und S4 ) in N liegen.
Damit man aus dieser Gleichung für die Hexadezimal-Ziffer ab der (d + 1)-ten Stelle
einen effizienten Algorithmus ableiten kann, benötigt man noch eine Methode um
effizient das Ergebnis einer Potenzierung modulo einer positiven ganzen Zahl zu
berechnen. Dies lässt sich mittels wiederholten Quadrierens realisieren:
Um r = bn mod c zu berechnen (b, c ∈ N, n ∈ N0 ) geht man also wie folgt vor:
Algorithmus PotenziereModuloC
Eingabe: b, c ∈ N, n ∈ N0
Ausgabe: r = bn mod c
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
if n = 0 then
Gebe aus: 1 mod c
exit
end if
t := maxi∈N0 2i ≤ n
r := 1
repeat
if n ≥ t then
r := br mod c
n := n − t
end if
t := t/2
if t ≥ 1 then
r := r2 mod c
end if
until t < 1
Gebe aus: r
9
Seminararbeit: Einzelne Ziffern von Pi nach Bailey, Borwein & Plouffe
Zur Verdeutlichung der Arbeitsweise des Algorithmus, hier ein kleines Anwendungsbeispiel. Zu berechnen sei: 316 mod 100 = 43046721 mod 100 = 21. Da 16 = 24
quadriert man 4 mal hintereinander modulo 100:
32
92
812
612
=9
= 81
= 6561
= 3721
−→
−→
−→
−→
9
81
6561
3721
mod
mod
mod
mod
100 = 9
100 = 81
100 = 61
100 = 21
Das korrekte Ergebnis (nämlich 21) wurde durch PotenziereModuloC mittels lediglich 4 Multiplikationen und 4 Modulo-Operationen berechnet, ohne dabei Zahlen
größer als 1002 = 10000 zu verwenden. Allgemein benötigt PotenziereModuloC
weniger als 2 log2 n Multiplikationen um bn mod c zu berechnen.
Mittels der von PotenziereModuloC durchführbaren schnellen Potenzierung modulo einer ganzen Zahl lässt sich nun die erste Summe von frac(16d S1 ) effizient und
ohne die Notwendigkeit einer besonderen multiple-precision“-Arithmetik
berechnen.
” P
16d−k
mod
1
reicht
es aus nur
Für die zweite Summe von frac(16d S1 ), also ∞
k=d+1 8k+1
wenige Terme zu berechnen, nämlich soviele, bis sicher ist, dass der verbleibende
Restterm sich auf einen Wert kleiner als das epsilon“ (die Maschinengenauigkeit)
”
der verwendeten floating-point“-Arithmetik addiert. Das Ergebnis von frac(16d Si )
”
(i = 1, . . . , 4) liegt zwischen 0 und 1 und muss nur noch in Hexadezimal-Form, also
die Darstellung zur Basis 16, konvertiert werden.
In abkürzender Schreibweise lässt sich der Algorithmus, der die (d + 1)-te Nachkommastelle von π ausgibt, nun folgendermaßen zusammenfassen:
Algorithmus BBP
1: Berechne si := 16d Si mod 1 für i = 1, . . . , 4 unter Verwendung von PotenziereMo-
duloC
2: pid := (4 · s1 − 2 · s2 − s3 − s4 ) mod 1
3: Gebe aus: HEX[16·pid ]
Hier sei mit HEX[i] die Funktion gemeint, die für i = 0, . . . , 15 den entsprechenden Hexadezimalwert (0, . . . , 9, A, . . . , F ) zurückgibt.
Der schnellste bekannte Algorithmus um π (vollständig) bis zur d-ten Stelle zu berechnen
ist zwar asymptotisch um den Faktor log(log(log(d))) schneller als BBP, dafür benötigt er
allerdings die Schönhage-Strassen-Multiplikation, die zwar im Komplexitätskalkül schnell,
allerdings in der Praxis, auf Grund einer hohen Konstante, erst bei hoher Stellenzahl
praktikabel wird.
Sich allerdings nur auf die Laufzeit der Algorithmen zu konzentrieren, führt hier in die
falsche Richtung, denn die Tatsache, dass BBP sehr einfach zu implementieren ist, und das
10
Seminararbeit: Einzelne Ziffern von Pi nach Bailey, Borwein & Plouffe
ohne dabei FFT-basierte Verfahren benutzen zu müssen, und dass man schon auf Systemen
der Leistungsstärke, Rechengenauigkeit und der Speichergröße eines üblichen Heim-PCs
sehr hohe Stellen von π berechnen kann, stellt BBP als einen besonders eleganten und
effizienten Algorithmus heraus.
4. Abschließende Bemerkungen
Mit dieser Vorgehensweise lassen sich natürlich auch andere bekannte transzendente Zahlen
berechnen, wie z.B. log(2), π 2 oder log(9/10). Allgemeiner kann man alle Zahlen der
Form
S=
∞
X
p(i)
bci q(i)
i=0
mit leichten Abwandlungen durch BBP berechnen, wobei p, q ganzzahlige Polynome sind
und c ∈ N>0 . Entsprechende Gleichungen wie (1) können für diese Konstanten in [01,
S.4f, S.8] nachgelesen werden. Anhand dieser Gleichungen wurden einige exemplarische
Berechnungen durchgeführt, die in Anhang B zu finden sind.
In Anhang C ist der Quellcode einer effizienten Implementierung des BBP abgedruckt,
wie er in [02] zu finden ist.
11
Seminararbeit: Einzelne Ziffern von Pi nach Bailey, Borwein & Plouffe
A. Der PSLQ-Algorithmus
Der PSLQ-Algorithmus wurde 1992 von Ferguson und Bailey entwickelt (siehe [03]). Er
ermöglicht es sogenannte Ganzzahl-Beziehungen (integer relations) von reellwertigen Zahlen zu finden.
Eine Menge M = {x1 , . . . , xn } ⊂ R besitzt genau dann eine Ganzahl-Beziehung, wenn es
ai ∈ Z (i = 1, . . . , n) gibt, die nicht alle Null sind, mit:
a1 x1 + · · · + an xn = 0.
Ein interessantes Beispiel ist der Vektor (1, x, x2 , . . . , x16 ) mit x = 31/4 − 21/4 , der die
Ganzzahl-Beziehung (1, 0, 0, 0, −3860, 0, 0, 0, −666, 0, 0, 0, −20, 0, 0, 0, 1) hat, d.h. es gilt:
1 − 3860x4 − 666x8 − 20x12 + x16 = 0.
Der PSLQ-Algorithmus terminiert nach einer (von einem Polynom über n = |M | beschränkten) Anzahl Iterationen. Er benutzt eine numerisch stabile Methode zur MatrizenReduktion (die ebenfalls von Ferguson und Bailey 1992 entwickelt wurde) und ist auf
Grund cleverer Techniken schneller als der ebenfalls sehr bekannte LLL-Algorithmus von
Lenstra, Lenstra, and Lovasz (1982) [04].
Die BBP-Gleichung für π wurde folgendermaßen gefunden: Man suchte nach ganzzahligen
ai (i = 0, . . . , 7) mit:
∞
X
a0
a1
a2
a3
a4
a5
a6
a7
1
π=
+
+
+
+
+
+
+
16i 8i 8i + 1 8i + 2 8i + 3 8i + 4 8i + 5 8i + 6 8i + 7
i=0
= a0
∞
X
i=0
∞
∞
i=0
i=0
X
X
1
1
1
+ a1
+ · · · + a7
i
i
i
16 (8i)
16 (8i + 1)
16 (8i + 7)
P
1
Die Summen ∞
i=0 16i (8i+j) wurden bis auf sehr hohe Genauigkeit berechnet (im Folgenden mit Sej bezeichnet) (j = 0, . . . , 7) und dann eine Ganzzahl-Beziehung für den Vektor
(π, Se0 , Se1 , Se2 , Se3 , Se4 , Se5 , Se6 , Se7 ) gesucht. Der PSLQ-Algorithmus gab als Ergebnis den Vektor (−1, 0, 4, 0, 0, −2, −1, −1, 0) aus, dies entspricht genau der BBP-Formel für π.
Näheres dazu findet man in [05, S.11-14].
12
Seminararbeit: Einzelne Ziffern von Pi nach Bailey, Borwein & Plouffe
B. Berechnungen einiger Konstanten
Die folgenden Berechnungen stammen aus [01, S.10]:
Konstante:
Basis:
Position:
Ziffern ab Position:
π
16
106
107
108
109
1010
26C65E52CB4593
17AF5863EFED8D
ECB840E21926EC
85895585A0428B
921C73C6838FB2
log(2)
16
106
107
108
109
418489A9406EC9
815F479E2B9102
E648F40940E13E
B1EEF1252297EC
π2
16
106
107
108
109
685554E1228505
9862837AD8AABF
4861AAF8F861BE
437A2BA4A13591
log2 (2)
16
106
107
108
109
2EC7EDB82B2DF7
33374B47882B32
3F55150F1AB3DC
8BA7C885CEFCE8
log(9/10)
10
106
107
108
109
1010
80174212190900
21093001236414
01309302330968
44066397959215
82528693381274
13
Seminararbeit: Einzelne Ziffern von Pi nach Bailey, Borwein & Plouffe
C. Eine effiziente Implementierung in C
/*
This program employs the recently discovered digit extraction scheme
to produce hex digits of pi. This code is valid up to ic = 2^24 on
systems with IEEE arithmetic. */
/*
David H. Bailey
2000-03-28 */
#include <stdio.h>
#include <math.h>
main()
{
double pid, s1, s2, s3, s4;
double series (int m, int n);
void ihex (double x, int m, char c[]);
int ic = 1000000;
#define NHX 16
char chx[NHX];
/*
ic is the hex digit start position. */
s1 = series (1, ic - 1);
s2 = series (4, ic - 1);
s3 = series (5, ic - 1);
s4 = series (6, ic - 1);
pid = 4. * s1 - 2. * s2 - s3 - s4;
pid = pid - (int) pid + 1.;
ihex (pid, NHX, chx);
printf (" start position = %i\n hex digits =
%10.10s\n", ic, chx);
}
void ihex (double x, int nhx, char chx[])
/*
This returns, in chx, the first nhx hex digits of the fraction of x. */
{
int i;
double y;
char hx[] = "0123456789ABCDEF";
y = fabs (x);
for (i = 0; i < nhx; i++){
y = 16. * (y - floor (y));
chx[i] = hx[(int) y];
}
}
double series (int m, int ic)
/*
This routine evaluates the series sum_k 16^(ic-k)/(8*k+m)
using the modular exponentiation technique. */
{
int k;
double ak, eps, p, s, t;
double expm (double x, double y);
#define eps 1e-17
s = 0.;
14
Seminararbeit: Einzelne Ziffern von Pi nach Bailey, Borwein & Plouffe
/*
Sum the series up to ic. */
for (k = 0; k < ic; k++){
ak = 8 * k + m;
p = ic - k;
t = expm (p, ak);
s = s + t / ak;
s = s - (int) s;
}
/*
Compute a few terms where k >= ic. */
for (k = ic; k <= ic + 100; k++){
ak = 8 * k + m;
t = pow (16., (double) (ic - k)) / ak;
if (t < eps) break;
s = s + t;
s = s - (int) s;
}
return s;
}
double expm (double p, double ak)
/*
expm = 16^p mod ak. This routine uses the left-to-right binary
exponentiation scheme. It is valid for ak <= 2^24. */
{
int i, j;
double p1, pt, r;
#define ntp 25
static double tp[ntp];
static int tp1 = 0;
/*
If this is the first call to expm, fill the power of two table tp. */
if (tp1 == 0) {
tp1 = 1;
tp[0] = 1.;
for (i = 1; i < ntp; i++) tp[i] = 2. * tp[i-1];
}
if (ak == 1.) return 0.;
/*
Find the greatest power of two less than or equal to p. */
for (i = 0; i < ntp; i++) if (tp[i] > p) break;
pt = tp[i-1];
p1 = p;
r = 1.;
/*
Perform binary exponentiation algorithm modulo ak. */
for (j = 1;
if (p1 >=
r = 16.
r = r p1 = p1
}
j <= i; j++){
pt){
* r;
(int) (r / ak) * ak;
- pt;
15
Seminararbeit: Einzelne Ziffern von Pi nach Bailey, Borwein & Plouffe
pt = 0.5 * pt;
if (pt >= 1.){
r = r * r;
r = r - (int) (r / ak) * ak;
}
}
return r;
}
16
Seminararbeit: Einzelne Ziffern von Pi nach Bailey, Borwein & Plouffe
Literatur
[01]
David Bailey, Peter B. Borwein and Simon Plouffe. On The Rapid Computation Of Various Polylogarithmic Constants. Mathematics of Computation, vol. 66, no. 218 (April 1997), S. 903-913 (Online verfügbar
unter http://crd.lbl.gov/~dhbailey/dhbpapers/digits.pdf, Aufruf: 06.12.2004) 3, 11, 13
[02]
Homepage von David Bailey (http://www.dhbailey.com/).
(Quellcode verfügbar unter http://crd.lbl.gov/~dhbailey/piqp.c, Aufruf: 06.12.2004) 11
[03]
H. R. P. Ferguson and D. H. Bailey
A Polynomial Time, Numerically Stable Integer Relation Algorithm. RNR Techn. Rept. RNR-91-032, Jul.
14, 1992 12
[04]
PSLQ Algorithm
http://mathworld.wolfram.com/PSLQAlgorithm.html, Aufruf: 14.12.2004 12
[05]
D. Bailey and S. Plouffe. On The Rapid Computation Of Various Polylogarithmic Constants.
http://www.cecm.sfu.ca/organics/papers/bailey/, Aufruf: 20.12.2004 12
17