First commit of partial RosettaCode contents.

Pushing this for testing purposes. Lots of work still needed.

Task/Pi/0DESCRIPTION

@@ -0,0 +1,4 @@
+Create a program to continually calculate and output the next digit of <math>\pi</math> (pi). The program should continue forever (until it is aborted by the user) calculating and outputting each digit in succession. The output should be a decimal sequence beginning 3.14159265 ...
+
+
+Note: this task is about calculating pi. For information on built-in pi constants see [[Real constants and functions]].

Task/Pi/1META.yaml

@@ -0,0 +1,2 @@
+---
+note: Irrational numbers

Task/Pi/C/pi.c

@@ -0,0 +1,68 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <gmp.h>
+
+mpz_t tmp1, tmp2, t5, t239, pows;
+void actan(mpz_t res, unsigned long base, mpz_t pows)
+{
+	int i, neg = 1;
+	mpz_tdiv_q_ui(res, pows, base);
+	mpz_set(tmp1, res);
+	for (i = 3; ; i += 2) {
+		mpz_tdiv_q_ui(tmp1, tmp1, base * base);
+		mpz_tdiv_q_ui(tmp2, tmp1, i);
+		if (mpz_cmp_ui(tmp2, 0) == 0) break;
+		if (neg) mpz_sub(res, res, tmp2);
+		else	  mpz_add(res, res, tmp2);
+		neg = !neg;
+	}
+}
+
+char * get_digits(int n, size_t* len)
+{
+	mpz_ui_pow_ui(pows, 10, n + 20);
+
+	actan(t5, 5, pows);
+	mpz_mul_ui(t5, t5, 16);
+
+	actan(t239, 239, pows);
+	mpz_mul_ui(t239, t239, 4);
+
+	mpz_sub(t5, t5, t239);
+	mpz_ui_pow_ui(pows, 10, 20);
+	mpz_tdiv_q(t5, t5, pows);
+
+	*len = mpz_sizeinbase(t5, 10);
+	return mpz_get_str(0, 0, t5);
+}
+
+int main(int c, char **v)
+{
+	unsigned long accu = 16384, done = 0;
+	size_t got;
+	char *s;
+
+	mpz_init(tmp1);
+	mpz_init(tmp2);
+	mpz_init(t5);
+	mpz_init(t239);
+	mpz_init(pows);
+
+	while (1) {
+		s = get_digits(accu, &got);
+
+		/* write out digits up to the last one not preceding a 0 or 9*/
+		got -= 2; /* -2: length estimate may be longer than actual */
+		while (s[got] == '0' || s[got] == '9') got--;
+
+		printf("%.*s", (int)(got - done), s + done);
+		free(s);
+
+		done = got;
+
+		/* double the desired digits; slows down at least cubically */
+		accu *= 2;
+	}
+
+	return 0;
+}

Task/Pi/Go/pi.go

@@ -0,0 +1,83 @@
+package main
+
+import (
+    "fmt"
+    "math/big"
+)
+
+type lft struct {
+    q,r,s,t big.Int
+}
+
+func (t *lft) extr(x *big.Int) *big.Rat {
+    var n, d big.Int
+    var r big.Rat
+    return r.SetFrac(
+        n.Add(n.Mul(&t.q, x), &t.r),
+        d.Add(d.Mul(&t.s, x), &t.t))
+}
+
+var three = big.NewInt(3)
+var four = big.NewInt(4)
+
+func (t *lft) next() *big.Int {
+    r := t.extr(three)
+    var f big.Int
+    return f.Div(r.Num(), r.Denom())
+}
+
+func (t *lft) safe(n *big.Int) bool {
+    r := t.extr(four)
+    var f big.Int
+    if n.Cmp(f.Div(r.Num(), r.Denom())) == 0 {
+        return true
+    }
+    return false
+}
+
+func (t *lft) comp(u *lft) *lft {
+    var r lft
+    var a, b big.Int
+    r.q.Add(a.Mul(&t.q, &u.q), b.Mul(&t.r, &u.s))
+    r.r.Add(a.Mul(&t.q, &u.r), b.Mul(&t.r, &u.t))
+    r.s.Add(a.Mul(&t.s, &u.q), b.Mul(&t.t, &u.s))
+    r.t.Add(a.Mul(&t.s, &u.r), b.Mul(&t.t, &u.t))
+    return &r
+}
+
+func (t *lft) prod(n *big.Int) *lft {
+    var r lft
+    r.q.SetInt64(10)
+    r.r.Mul(r.r.SetInt64(-10), n)
+    r.t.SetInt64(1)
+    return r.comp(t)
+}
+
+func main() {
+    // init z to unit
+    z := new(lft)
+    z.q.SetInt64(1)
+    z.t.SetInt64(1)
+
+    // lfts generator
+    var k int64
+    lfts := func() *lft {
+        k++
+        r := new(lft)
+        r.q.SetInt64(k)
+        r.r.SetInt64(4*k+2)
+        r.t.SetInt64(2*k+1)
+        return r
+    }
+
+    // stream
+    for {
+        y := z.next()
+        if z.safe(y) {
+            fmt.Print(y)
+            z = z.prod(y)
+        } else {
+            z = z.comp(lfts())
+        }
+    }
+}

Task/Pi/Haskell/pi.hs

@@ -0,0 +1,5 @@
+pi_ = g(1,0,1,1,3,3) where
+  g (q,r,t,k,n,l) =
+   if 4*q+r-t < n*t
+    then n : g (10*q, 10*(r-n*t), t, k, div (10*(3*q+r)) t - 10*n, l)
+    else g (q*k, (2*q+r)*l, t*l, k+1, div (q*(7*k+2)+r*l) (t*l), l+2)

Task/Pi/Java/pi.java

@@ -0,0 +1,45 @@
+import java.math.BigInteger ;
+
+public class Pi {
+  final BigInteger TWO = BigInteger.valueOf(2) ;
+  final BigInteger THREE = BigInteger.valueOf(3) ;
+  final BigInteger FOUR = BigInteger.valueOf(4) ;
+  final BigInteger SEVEN = BigInteger.valueOf(7) ;
+
+  BigInteger q = BigInteger.ONE ;
+  BigInteger r = BigInteger.ZERO ;
+  BigInteger t = BigInteger.ONE ;
+  BigInteger k = BigInteger.ONE ;
+  BigInteger n = BigInteger.valueOf(3) ;
+  BigInteger l = BigInteger.valueOf(3) ;
+
+  public void calcPiDigits(){
+    BigInteger nn, nr ;
+    boolean first = true ;
+    while(true){
+        if(FOUR.multiply(q).add(r).subtract(t).compareTo(n.multiply(t)) == -1){
+          System.out.print(n) ;
+          if(first){System.out.print(".") ; first = false ;}
+          nr = BigInteger.TEN.multiply(r.subtract(n.multiply(t))) ;
+          n = BigInteger.TEN.multiply(THREE.multiply(q).add(r)).divide(t).subtract(BigInteger.TEN.multiply(n)) ;
+          q = q.multiply(BigInteger.TEN) ;
+          r = nr ;
+          System.out.flush() ;
+        }else{
+          nr = TWO.multiply(q).add(r).multiply(l) ;
+          nn = q.multiply((SEVEN.multiply(k))).add(TWO).add(r.multiply(l)).divide(t.multiply(l)) ;
+          q = q.multiply(k) ;
+          t = t.multiply(l) ;
+          l = l.add(TWO) ;
+          k = k.add(BigInteger.ONE) ;
+          n = nn ;
+          r = nr ;
+        }
+    }
+  }
+
+  public static void main(String[] args) {
+    Pi p = new Pi() ;
+    p.calcPiDigits() ;
+  }
+}

Task/Pi/Perl/pi.pl

@@ -0,0 +1,55 @@
+use Math::BigInt;
+use bigint;
+
+# Pi/4 = 4 arctan 1/5 - arctan 1/239
+# expanding it with Taylor series with what's probably the dumbest method
+
+my ($ds, $ns) = (1, 0);
+my ($n5, $d5) = (16 * (25 * 3 - 1), 3 * 5**3);
+my ($n2, $d2) = (4 * (239 * 239 * 3 - 1), 3 * 239**3);
+
+sub next_term {
+	my ($coef, $p) = @_[1, 2];
+	$_[0] /= ($p - 4) * ($p - 2);
+	$_[0] *= $p * ($p + 2) * $coef**4;
+}
+
+my $p2 = 5;
+my $pow = 1;
+
+$| = 1;
+for (my $x = 5; ; $x += 4) {
+	($ns, $ds) = ($ns * $d5 + $n5 * $pow * $ds, $ds * $d5);
+
+	next_term($d5, 5, $x);
+	$n5 = 16 * (5 * 5 * ($x + 2) - $x);
+
+	while ($d5 > $d2) {
+		($ns, $ds) = ($ns * $d2 - $n2 * $pow * $ds, $ds * $d2);
+		$n2 = 4 * (239 * 239 * ($p2 + 2) - $p2);
+		next_term($d2, 239, $p2);
+		$p2 += 4;
+	}
+
+	my $ppow = 1;
+	while ($pow * $n5 * 5**4 < $d5 && $pow * $n2 * $n2 * 239**4 < $d2) {
+		$pow *= 10;
+		$ppow *= 10;
+	}
+
+	if ($ppow > 1) {
+		$ns *= $ppow;
+	#FIX?	my $out = $ns->bdiv($ds);   # bugged?
+		my $out = $ns / $ds;
+		$ns %= $ds;
+
+		$out = ("0" x (length($ppow) - length($out) - 1)) . $out;
+		print $out;
+	}
+
+	if ( $p2 % 20 == 1) {
+		my $g = Math::BigInt::bgcd($ds, $ns);
+		$ds /= $g;
+		$ns /= $g;
+	}
+}

Task/Pi/PicoLisp/pi.l

@@ -0,0 +1,21 @@
+#!/usr/bin/picolisp /usr/lib/picolisp/lib.l
+
+(de piDigit ()
+   (job '((Q . 1) (R . 0) (S . 1) (K . 1) (N . 3) (L . 3))
+      (while (>= (- (+ R (* 4 Q)) S) (* N S))
+         (mapc set '(Q R S K N L)
+            (list
+               (* Q K)
+               (* L (+ R (* 2 Q)))
+               (* S L)
+               (inc K)
+               (/ (+ (* Q (+ 2 (* 7 K))) (* R L)) (* S L))
+               (+ 2 L) ) ) )
+      (prog1 N
+         (let M (- (/ (* 10 (+ R (* 3 Q))) S) (* 10 N))
+            (setq Q (* 10 Q)  R (* 10 (- R (* N S)))  N M) ) ) ) )
+
+(prin (piDigit) ".")
+(loop
+   (prin (piDigit))
+   (flush) )

Task/Pi/Python/pi.py

@@ -0,0 +1,26 @@
+def calcPi():
+    q, r, t, k, n, l = 1, 0, 1, 1, 3, 3
+    while True:
+        if 4*q+r-t < n*t:
+            yield n
+            nr = 10*(r-n*t)
+            n  = ((10*(3*q+r))//t)-10*n
+            q  *= 10
+            r  = nr
+        else:
+            nr = (2*q+r)*l
+            nn = (q*(7*k)+2+(r*l))//(t*l)
+            q  *= k
+            t  *= l
+            l  += 2
+            k += 1
+            n  = nn
+            r  = nr
+
+import sys
+pi_digits = calcPi()
+i = 0
+for d in pi_digits:
+    sys.stdout.write(str(d))
+    i += 1
+    if i == 40: print(""); i = 0

Task/Pi/REXX/pi.rexx

@@ -0,0 +1,24 @@
+/*REXX program to spit out pi digits (few at a time) until  Ctrl-Break. */
+
+arg digs .; if digs=='' then digs=1e6  /*allow the specification of digs*/
+fn='PI_DIGITS.OUT'                     /*file that can be written to.   */
+numeric digits digs                    /*big digs, the slower the spits.*/
+pi=0;  s=16;  r=4;  v=5;  vs=v*v;  g=239;  gs=g*g;  old=;  spewed=0;  j=1
+call time 'E'
+
+/*─────────────────────────────────────John Machin's formula for  pi.   */
+  do n=1  by 2
+  pi=pi + s/(n*v) - r/(n*g)
+  if pi==old  then leave               /*no further with current DIGITS.*/
+  s=-s;  r=-r;  v=v*vs;  g=g*gs
+  if n\==1  then do j=spewed+1  to compare(pi,old)
+                 spit=substr(pi,j,1)
+                 call charout   ,spit          /*spit out 1 digit of pi.*/
+                 call charout fn,spit          /* ...and also to a file.*/
+                 end
+  spewed=j-1
+  old=pi
+  end   /*n*/
+
+say;    say  n%2+1   'iterations took'   format(time("E"),,2)   'seconds.'
+                                       /*stick a fork in it, we're done.*/

Task/Pi/Ruby/pi-2.rb

@@ -0,0 +1,28 @@
+def pi
+  q, r, t, k, n, l = 1, 0, 1, 1, 3, 3
+  dot = nil
+  loop do
+    if 4*q+r-t < n*t
+      yield n
+      if dot.nil?
+        yield '.'
+        dot = '.'
+      end
+      nr = 10*(r-n*t)
+      n = ((10*(3*q+r)) / t) - 10*n
+      q *= 10
+      r = nr
+    else
+      nr = (2*q+r) * l
+      nn = (q*(7*k+2)+r*l) / (t*l)
+      q *= k
+      t *= l
+      l += 2
+      k += 1
+      n = nn
+      r = nr
+    end
+  end
+end
+
+pi {|digit| print digit; $stdout.flush}

Task/Pi/Ruby/pi.rb

@@ -0,0 +1,20 @@
+# Calculate Pi using the Arithmetic Geometric Mean of 1 and 1/sqrt(2)
+#
+#
+#  Nigel_Galloway
+#  March 8th., 2012.
+#
+require 'flt'
+Flt::BinNum.Context.precision = 8192
+a = n = 1
+g = 1 / Flt::BinNum(2).sqrt
+z = 0.25
+(0..17).each{
+  x = [(a + g) * 0.5, (a * g).sqrt]
+  var = x[0] - a
+  z -= var * var * n
+  n += n
+  a = x[0]
+  g = x[1]
+}
+puts a * a / z

Task/Pi/Scala/pi.scala

@@ -0,0 +1,35 @@
+object Pi {
+  class PiIterator extends Iterable[BigInt]{
+    var r:BigInt=0
+    var q, t, k:BigInt=1
+    var n, l:BigInt=3
+    var nr, nn:BigInt=0
+		
+    def iterator: Iterator[BigInt]=new Iterator[BigInt]{
+      def hasNext=true
+      def next():BigInt={
+        while((4*q+r-t) >= (n*t)) {
+          nr = (2*q+r)*l
+          nn = (q*(7*k)+2+(r*l))/(t*l)
+          q = q * k
+          t = t * l
+          l = l + 2
+          k = k + 1
+          n  = nn
+          r  = nr			
+        }
+        val ret=n
+        nr = 10*(r-n*t)
+        n  = ((10*(3*q+r))/t)-(10*n)
+        q  = q * 10
+        r  = nr
+        ret
+      }
+    }
+  }
+
+  def main(args: Array[String]): Unit = {
+    val it=new PiIterator
+    println((it head) + "." + (it take 300 mkString))
+  }
+}

Task/Pi/Tcl/pi-2.tcl

@@ -0,0 +1,5 @@
+coroutine piDigit piDigitsBySpigot 10000
+fconfigure stdout -buffering none
+while 1 {
+    puts -nonewline [piDigit]
+}

Task/Pi/Tcl/pi.tcl

@@ -0,0 +1,31 @@
+package require Tcl 8.6
+
+# http://www.cut-the-knot.org/Curriculum/Algorithms/SpigotForPi.shtml
+# http://www.mathpropress.com/stan/bibliography/spigot.pdf
+proc piDigitsBySpigot n {
+    yield [info coroutine]
+    set A [lrepeat [expr {int(floor(10*$n/3.)+1)}] 2]
+    set Alen [llength $A]
+    set predigits {}
+    while 1 {
+	set carry 0
+	for {set i $Alen} {[incr i -1] > 0} {} {
+	    lset A $i [expr {
+		[set val [expr {[lindex $A $i] * 10 + $carry}]]
+		% [set modulo [expr {2*$i + 1}]]
+	    }]
+	    set carry [expr {$val / $modulo * $i}]
+	}
+	lset A 0 [expr {[set val [expr {[lindex $A 0]*10 + $carry}]] % 10}]
+	set predigit [expr {$val / 10}]
+	if {$predigit < 9} {
+	    foreach p $predigits {yield $p}
+	    set predigits [list $predigit]
+	} elseif {$predigit == 9} {
+	    lappend predigits $predigit
+	} else {
+	    foreach p $predigits {yield [incr p]}
+	    set predigits [list 0]
+	}
+    }
+}