langs a-z

Task/Pi/NetRexx/pi.netrexx

@@ -0,0 +1,62 @@
+/* NetRexx */
+options replace format comments java crossref symbols binary
+import java.math.BigInteger
+
+runSample(arg)
+return
+
+-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+method runSample(arg) private static
+  parse arg places .
+  if places = '' then places = -1
+
+  TWO   = BigInteger.valueOf(2)
+  THREE = BigInteger.valueOf(3)
+  FOUR  = BigInteger.valueOf(4)
+  SEVEN = BigInteger.valueOf(7)
+
+  q_ = BigInteger.ONE
+  r_ = BigInteger.ZERO
+  t_ = BigInteger.ONE
+  k_ = BigInteger.ONE
+  n_ = BigInteger.valueOf(3)
+  l_ = BigInteger.valueOf(3)
+
+  nn = BigInteger
+  nr = BigInteger
+
+  first = isTrue()
+  digitCt = 0
+  loop forever
+    if FOUR.multiply(q_).add(r_).subtract(t_).compareTo(n_.multiply(t_)) == -1 then do
+      digitCt = digitCt + 1
+      if places > 0 & digitCt - 1 > places then leave
+      say n_'\-'
+      if first then do
+        say '.\-'
+        first = isFalse()
+        end
+      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
+      end
+    else do
+      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
+      end
+    end
+  say
+
+  return
+
+method isTrue() private static returns boolean
+  return (1 == 1)
+method isFalse() private static returns boolean
+  return \isTrue()

Task/Pi/OCaml/pi-1.ocaml

@@ -0,0 +1,12 @@
+open Creal;;
+
+let block = 100 in
+let segment n =
+   let s = to_string pi (n*block) in
+   String.sub s ((n-1)*block) block in
+let counter = ref 1 in
+while true do
+   print_string (segment !counter);
+   flush stdout;
+   incr counter
+done

Task/Pi/OCaml/pi-2.ocaml

@@ -0,0 +1,43 @@
+open Num
+
+(* series for: c*atan(1/k) *)
+class atan_sum c k = object
+   val kk = k*/k
+   val mutable n = 0
+   val mutable kpow = k
+   val mutable pterm = c*/k
+   val mutable psum = Int 0
+   val mutable sum = c*/k
+   method next =
+      n <- n+1; kpow <- kpow*/kk;
+      let t = c*/kpow//(Int (2*n+1)) in
+      pterm <- if n mod 2 = 0 then t else minus_num t;
+      psum <- sum;
+      sum <- sum +/ pterm
+   method error = abs_num pterm
+   method bounds = if pterm </ Int 0 then (sum, psum) else (psum, sum)
+end;;
+
+let inv i = (Int 1)//(Int i) in
+let t1 = new atan_sum (Int 16) (inv 5) in
+let t2 = new atan_sum (Int (-4)) (inv 239) in
+let base = Int 10 in
+let npr = ref 0 in
+let shift = ref (Int 1) in
+let d_acc = inv 10000 in
+let acc = ref d_acc in
+let shown = ref (Int 0) in
+while true do
+   while t1#error >/ !acc do t1#next done;
+   while t2#error >/ !acc do t2#next done;
+   let (lo1, hi1), (lo2, hi2) = t1#bounds, t2#bounds in
+   let digit x = int_of_num (floor_num ((x -/ !shown) */ !shift)) in
+   let d, d' = digit (lo1+/lo2), digit (hi1+/hi2) in
+   if d = d' then (
+      print_int d;
+      if !npr = 0 then print_char '.';
+      flush stdout;
+      shown := !shown +/ ((Int d) // !shift);
+      incr npr; shift := !shift */ base;
+   ) else (acc := !acc */ d_acc);
+done

Task/Pi/PARI-GP/pi.pari

@@ -0,0 +1,11 @@
+pi()={
+  my(x=Pi,n=0,t);
+  print1("3.");
+  while(1,
+    if(n>=default(realprecision),
+      default(realprecision,default(realprecision)*2);
+      x=Pi
+    );
+    print1(floor(x*10^n++)%10)
+  )
+};

Task/Pi/PL-I/pi.pli

@@ -0,0 +1,42 @@
+/* Uses the algorithm of S. Rabinowicz and S. Wagon, "A Spigot Algorithm */
+/* for the Digits of Pi".                                                */
+(subrg, fofl, size):
+Pi_Spigot: procedure options (main);                 /* 21 January 2012. */
+   declare (n, len) fixed binary;
+
+   n = 1000;
+   len = 10*n / 3;
+   begin;
+      declare ( i, j, k, q, nines, predigit ) fixed binary;
+      declare x fixed binary (31);
+      declare a(len) fixed binary (31);
+
+      a = 2; /* Start with 2s */
+      nines, predigit = 0; /* First predigit is a 0 */
+      do j = 1 to n;
+         q = 0;
+         do i = len to 1 by -1; /* Work backwards */
+            x = 10*a(i) + q*i;
+            a(i) = mod (x, (2*i-1));
+            q = x / (2*i-1);
+         end;
+         a(1) = mod(q, 10); q = q / 10;
+         if q = 9 then nines = nines + 1;
+         else if q = 10 then
+            do;
+               put edit(predigit+1) (f(1));
+               do k = 1 to nines;
+                  put edit ('0')(a(1)); /* zeros */
+               end;
+               predigit, nines = 0;
+            end;
+         else
+            do;
+               put edit(predigit) (f(1)); predigit = q;
+               do k = 1 to nines; put edit ('9')(a(1)); end;
+               nines = 0;
+            end;
+      end;
+      put edit(predigit) (f(1));
+   end; /* of begin block */
+end Pi_Spigot;

Task/Pi/Pascal/pi.pascal

@@ -0,0 +1,51 @@
+Program Pi_Spigot;
+
+const
+  n   = 1000;
+  len = 10*n div 3;
+
+var
+  i, j, k, q, x, nines, predigit: integer;
+  a: array[1..len] of longint;
+
+begin
+  for j := 1 to len do
+    a[j] := 2;                 {Start with 2s}
+  nines := 0;
+  predigit := 0;               {First predigit is a 0}
+  for j := 1 to n do
+  begin
+    q := 0;
+    for i := len downto 1 do   {Work backwards}
+    begin
+      x    := 10*a[i] + q*i;
+      a[i] := x mod (2*i - 1);
+      q    := x div (2*i - 1);
+    end;
+    a[1] := q mod 10;
+    q := q div 10;
+    if q = 9 then
+      nines := nines + 1
+    else
+      if q = 10 then
+      begin
+	write(predigit+1);
+	for k := 1 to nines do
+	  write(0);            {zeros}
+	predigit := 0;
+	nines := 0
+      end
+      else
+      begin
+	write(predigit);
+	predigit := q;
+	if nines <> 0 then
+	begin
+	  for k := 1 to nines do
+	    write(9);
+	  nines := 0
+	end
+      end
+  end;
+  writeln(predigit);
+end.

Task/Pi/Perl-6/pi.pl6

@@ -0,0 +1,41 @@
+# based on http://www.mathpropress.com/stan/bibliography/spigot.pdf
+
+sub stream(&next, &safe, &prod, &cons, $z is copy, @x) {
+    my $x-list = @x.iterator.list;
+    gather loop {
+        my $y = next($z);
+        if safe($z, $y) {
+            take $y;
+            $z = prod($z, $y);
+        } else {
+            $z = cons($z, $x-list.shift);
+        }
+    }
+}
+
+sub extr([$q, $r, $s, $t], $x) {
+    ($q * $x + $r) div ($s * $x + $t);
+}
+
+my $unit = [1, 0, 0, 1];
+
+sub comp([$q,$r,$s,$t], [$u,$v,$w,$x]) {
+    [$q * $u + $r * $w,
+     $q * $v + $r * $x,
+     $s * $u + $t * $w,
+     $s * $v + $t * $x];
+}
+
+sub pi-stream() {
+    stream -> $z { extr($z, 3) },
+           -> $z, $n { $n == extr($z, 4) },
+           -> $z, $n { comp([10, -10*$n, 0, 1], $z) },
+           &comp,
+           $unit,
+           (1..*).map: { [$_, 4 * $_ + 2, 0, 2 * $_ + 1] }
+}
+
+my @pi := pi-stream;
+
+print @pi[0], '.';
+print @pi[$_] for 1..*;

Task/Pi/PureBasic/pi.purebasic

@@ -0,0 +1,40 @@
+#SCALE = 10000
+#ARRINT=  2000
+
+Procedure Pi(Digits)
+  Protected First=#True, Text$
+  Protected Carry, i, j, sum
+  Dim Arr(Digits)
+  For i=0 To Digits
+    Arr(i)=#ARRINT
+  Next
+  i=Digits
+  While i>0
+    sum=0
+    j=i
+    While j>0
+      sum*j+#SCALE*arr(j)
+      Arr(j)=sum%(j*2-1)
+      sum/(j*2-1)
+      j-1
+    Wend
+    Text$ = RSet(Str(Carry+sum/#SCALE),4,"0")
+    If First
+      Text$ = ReplaceString(Text$,"3","3.")
+      First = #False
+    EndIf
+    Print(Text$)
+    Carry=sum%#SCALE
+    i-14
+  Wend
+EndProcedure
+
+If OpenConsole()
+  SetConsoleCtrlHandler_(?Ctrl,#True)
+  Pi(24*1024*1024)
+EndIf
+End
+
+Ctrl:
+PrintN(#CRLF$+"Ctrl-C was pressed")
+End