Python 59 byte
print reduce(lambda x,p:p/2*x/p+2*10**999,range(6637,1,-2))
Questo stampa 1000 cifre; leggermente più di quanto richiesto 5. Invece di utilizzare l'iterazione prescritta, utilizza questo:
pi = 2 + 1/3*(2 + 2/5*(2 + 3/7*(2 + 4/9*(2 + 5/11*(2 + ...)))))
Il 6637(denominatore più interno) può essere formulato come:
cifre * 2 * registro 2 (10)
Ciò implica una convergenza lineare. Ogni iterazione più profonda produrrà un altro bit binario di pi .
Se , tuttavia, insisti nell'usare l'identità tan -1 , si può ottenere una convergenza simile, se non ti dispiace affrontare il problema in modo leggermente diverso. Dando un'occhiata alle somme parziali:
4.0, 2.66667, 3.46667, 2.89524, 3.33968, 2.97605, 3.28374, ...
è evidente che ogni termine salta avanti e indietro su entrambi i lati del punto di convergenza; la serie ha una convergenza alternata. Inoltre, ogni termine è più vicino al punto di convergenza rispetto al termine precedente; è assolutamente monotonico rispetto al suo punto di convergenza. La combinazione di queste due proprietà implica che la media aritmetica di due termini vicini è più vicina al punto di convergenza di uno dei termini stessi. Per darti un'idea migliore di ciò che intendo, considera la seguente immagine:
La serie esterna è l'originale e la serie interna si trova prendendo la media di ciascuno dei termini vicini. Una differenza notevole. Ma ciò che è veramente straordinario, è che questa nuova serie ha anche una convergenza alternata, ed è assolutamente monotona rispetto al suo punto di convergenza. Ciò significa che questo processo può essere applicato più volte, fino alla nausea.
Ok. Ma come?
Alcune definizioni formali. Let P 1 (n) sia il n esimo termine della prima sequenza, P 2 (n) sia il n esimo termine della seconda sequenza, e similmente P k (n) il n esimo termine della k esima sequenza come sopra definiti .
P 1 = [P 1 (1), P 1 (2), P 1 (3), P 1 (4), P 1 (5), ...]
P 2 = [(P 1 (1) + P 1 (2)) / 2, (P 1 (2) + P 1 (3)) / 2, (P 1 (3) + P 1 (4)) / 2, (P 1 (4) + P 1 (5)) / 2, ...]
P 3 = [(P 1 (1) + 2P 1 (2) + P 1 (3)) / 4, (P 1 (2) + 2P 1 (3) + P 1 (4)) / 4, (P 1 (3) + 2P 1 (4) + P 1 (5)) / 4, ...]
P 4 = [(P 1 (1) + 3P 1 (2) + 3P 1 (3) + P 1 (4)) / 8, (P 1 (2) + 3P 1 (3) + 3P 1 (4) + P 1 (5)) / 8, ...]
Non sorprende che questi coefficienti seguano esattamente i coefficienti binomiali e possano essere espressi come una singola riga del triangolo di Pascal. Da una riga arbitraria del triangolo di Pascal è banale per calcolare, arbitrariamente 'profonda' serie possono essere trovati, semplicemente muovendo i primi n parziali somme, moltiplicare ciascuna con il termine corrispondente nella k esima fila di triangolo di Pascal, e dividendo per 2 k-1 .
In questo modo, è possibile ottenere la massima precisione in virgola mobile a 32 bit (~ 14 posizioni decimali) con solo 36 iterazioni, a quel punto le somme parziali non sono nemmeno convergenti sulla seconda posizione decimale. Questo ovviamente non è golfato:
# used for pascal's triangle
t = 36; v = 1.0/(1<<t-1); e = 1
# used for the partial sums of pi
p = 4; d = 3; s = -4.0
x = 0
while t:
t -= 1
p += s/d; d += 2; s *= -1
x += p*v
v = v*t/e; e += 1
print "%.14f"%x
Se si desidera una precisione arbitraria, questo può essere ottenuto con una piccola modifica. Qui di nuovo calcolando 1000 cifre:
# used for pascal's triangle
f = t = 3318; v = 1; e = 1
# used for the partial sums of pi
p = 4096*10**999; d = 3; s = -p
x = 0
while t:
t -= 1
p += s/d; d += 2; s *= -1
x += p*v
v = v*t/e; e += 1
print x>>f+9
Il valore iniziale di p inizia 2 10 più grande, per contrastare gli effetti di divisione di s / d man mano che d diventa più grande, facendo sì che le ultime cifre non convergano. Si noti di nuovo che 3318è anche:
cifre * registro 2 (10)
Lo stesso numero di iterazioni del primo algoritmo (dimezzato perché t diminuisce di 1 anziché 2 per ciascuna iterazione). Ancora una volta, questo indica una convergenza lineare: un bit binario di pi per iterazione. In entrambi i casi sono necessarie 3318 iterazioni per calcolare 1000 cifre di pi , come quota leggermente migliore di 1 milione di iterazioni per calcolare 5.
p=lambda:3.14159