Transmit Pi... precisely
Python, 138 bytes
q,r,t,i=1,180,60,2
while 1:u,y=27*i*(i+1)+6,(q*(27*i-12)+5*r)//(5*t);print(y,end="");q,r,t,i=10*q*i*(2*i-1),10*u*(q*(5*i-2)+r-y*t),t*u,i+1
Implementation of http://www.cs.ox.ac.uk/jeremy.gibbons/publications/spigot.pdf.
CJam - 48
3.1o{1YAZ2*:Z#*{_2$*2$2*)/@)\}h*]:+sX2*:X>X<o1}g
This calculates π as 2*sum(k!/(2k+1)!!) with greater and greater precision and at every step prints a bunch of digits from where it left off.
You can try online a modified version that does only 8 (outer loop) iterations and prints 512 digits, or use the java interpreter for the real thing. On my laptop it gets to 16384 digits in about 6 seconds.
Note: this program is very memory-hungry; a better behaved but slightly longer version is:
3.1o{T2AZ2*:Z#*1{@2$+@2$*2$2*)/@)1$}g;;sX2*:X>X<o1}g
Explanation:
3.1o print 3.1
{…1}g repeat indefinitely
1YA push 1, 2 and 10 (Y=2, A=10)
Z2*:Z push Z*2 (Z=3 initially) and store back in Z
#* calculate 2*10^Z (2 from the formula and 10^Z for precision)
this is the term for k=0, and the earlier 1 represents k
{…}h do-while
at each iteration, the stack contains: terms, k, last-term
_2$* copy the previous term and k and multiply them
2$2*)/ divide the previous number by 2*k+1
this is the current term of the series
@)\ increment k and move it before the current term
the current term now serves as the loop condition
so the loop terminates when the term becomes 0
* multiply k and the last term (0), to get rid of k
]:+s put all the terms in an array, add them and convert to string
we obtain an approximation of π*10^Z
X2*:X push X*2 (X=1 initially) and store back in X
>X<o print X digits starting from the X position
GolfScript (81 chars)
1:i:^3{3i):i*(.(*3*.@*.5*3$27i*12-*+@^*:^5*/.print^*2$5i*2-*--\10*i*2i*(*\10*.}do
Online demo (that's much slower than a reasonable desktop, and has trivial code changes to loop a finite number of times).
I have, of course, used the spigot algorithm which I mentioned in an earlier comment, but it took me a while to golf it to my satisfaction. The algorithm as presented in Gibbons' paper is (pseudocode)
q = 1; r = 180; t = 60; i = 2
while (true) {
u = 3*(3*i+1)*(3*i+2)
y = (q*(27*i-12)+5*r) / (5*t)
print y
r += q*(5*i-2)-y*t
r *= 10*u
q *= 10*i*(2*i-1)
t *= u
i += 1
}
The GolfScript above is equivalent to (pseudocode)
t = i = q = 1; r = 3
while (true) {
u = 3*(3*i+1)*(3*i+2)
i += 1
r *= u
t *= u
y = (q*(27*i-12)+5*r) / (5*t)
print y
r -= y*t - q*(5*i-2)
q *= 10*i*(2*i-1)
r *= 10
}
which saves some characters in the initialisation and in the stack management.