

100,000,000 million places of π in just under 10 minutes (with Python) - reidrac
http://www.craig-wood.com/nick/articles/pi-chudnovsky/

======
spartango
The mention of python in this is somewhat foolish from a performance
standpoint. It's not that python is slowing them down or speeding things
up...they ultimately are hooking into a pile of C code to get "c-comparable"
performance. If you're going to be using numpy or gmpy, don't bother comparing
your python code to C, its meaningless...

That all said, that's mostly irrelevant! The algorithm is new, kinda neat, and
efficient, which is what matters.

~~~
Terretta
Am I mistaken, or in the final graph, aren't only the last two lines gmpy and
c?

------
sp332
It's 100 million, not 100 million million.

~~~
ethereal
Agreed, but note that the original webpage actually states: > So we have
achieved our goal of calculating 100,000,000 million places of π in just under
10 minutes!

Thus it's not entirely the submitter's fault. But they should check what
they're typing/copy-pasting! :)

Which is too bad, because I wanted to know how they were calculating 100
trillion digits in less than ten minutes . . .

~~~
reidrac
You're right, I shouldn't have copied the typo! :)

------
guelo
Are pi digits useful for anything? Maybe some encryption technique or random
number generation? Are the digits of pi easier or harder to generate than
other irrational numbers?

~~~
cperciva
_Are the digits of pi easier or harder to generate than other irrational
numbers?_

The best known algorithms for computing Pi takes _O(M(n) log n)_ time, where
_M(n)_ is the time required for an _n_ -digit multiplication (approximately
_O(n log n)_ using an FFT).

This makes Pi harder than algebraic numbers -- all algebraics can be computed
in _O(M(n))_ time -- and no easier than any other elementary function -- all
elementary functions can be computed in _O(M(n) log n)_ time.

There are a few numbers for which the current best known algorithm is slower
than Pi, but the only interesting one is Euler's gamma, at _O(M(n) (log
n)^2)_.

~~~
waqf
This is really interesting and I've never seen it laid out like that. Can you
recommend a reference?

~~~
cperciva
The best book I know on this topic is Pi and the AGM:
[http://www.amazon.com/AGM-Computational-Complexity-
Mathemati...](http://www.amazon.com/AGM-Computational-Complexity-Mathematical-
Monographs/dp/047131515X)

------
rorrr
Here's Pi to 5 trillion digits

<http://ja0hxv.calico.jp/pai/estart.html>

