new files

Task/Pi/Ada/pi.ada

@@ -0,0 +1,112 @@
+with Ada.Command_Line;
+with Ada.Text_IO;
+with GNU_Multiple_Precision.Big_Integers;
+with GNU_Multiple_Precision.Big_Rationals;
+use GNU_Multiple_Precision;
+
+procedure Pi_Digits is
+   type Int is mod 2 ** 64;
+   package Int_To_Big is new Big_Integers.Modular_Conversions (Int);
+
+   -- constants
+   Zero : constant Big_Integer := Int_To_Big.To_Big_Integer (0);
+   One : constant Big_Integer := Int_To_Big.To_Big_Integer (1);
+   Two : constant Big_Integer := Int_To_Big.To_Big_Integer (2);
+   Three : constant Big_Integer := Int_To_Big.To_Big_Integer (3);
+   Four : constant Big_Integer := Int_To_Big.To_Big_Integer (4);
+   Ten : constant Big_Integer := Int_To_Big.To_Big_Integer (10);
+
+   -- type LFT = (Integer, Integer, Integer, Integer
+   type LFT is record
+      Q, R, S, T : Big_Integer;
+   end record;
+
+   -- extr :: LFT -> Integer -> Rational
+   function Extr (T : LFT; X : Big_Integer) return Big_Rational is
+      use Big_Integers;
+      Result : Big_Rational;
+   begin
+      -- extr (q,r,s,t) x = ((fromInteger q) * x + (fromInteger r)) /
+      --                    ((fromInteger s) * x + (fromInteger t))
+      Big_Rationals.Set_Numerator (Item         => Result,
+                                   New_Value    => T.Q * X + T.R,
+                                   Canonicalize => False);
+      Big_Rationals.Set_Denominator (Item      => Result,
+                                     New_Value => T.S * X + T.T);
+      return Result;
+   end Extr;
+
+   -- unit :: LFT
+   function Unit return LFT is
+   begin
+      -- unit = (1,0,0,1)
+      return LFT'(Q => One, R => Zero, S => Zero, T => One);
+   end Unit;
+
+   -- comp :: LFT -> LFT -> LFT
+   function Comp (T1, T2 : LFT) return LFT is
+      use Big_Integers;
+   begin
+      -- 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)
+      return LFT'(Q => T1.Q * T2.Q + T1.R * T2.S,
+                  R => T1.Q * T2.R + T1.R * T2.T,
+                  S => T1.S * T2.Q + T1.T * T2.S,
+                  T => T1.S * T2.R + T1.T * T2.T);
+   end Comp;
+
+   -- lfts = [(k, 4*k+2, 0, 2*k+1) | k<-[1..]
+   K : Big_Integer := Zero;
+   function LFTS return LFT is
+      use Big_Integers;
+   begin
+      K := K + One;
+      return LFT'(Q => K,
+                  R => Four * K + Two,
+                  S => Zero,
+                  T => Two * K + One);
+   end LFTS;
+
+   -- next z = floor (extr z 3)
+   function Next (T : LFT) return Big_Integer is
+   begin
+      return Big_Rationals.To_Big_Integer (Extr (T, Three));
+   end Next;
+
+   -- safe z n = (n == floor (extr z 4)
+   function Safe (T : LFT; N : Big_Integer) return Boolean is
+   begin
+      return N = Big_Rationals.To_Big_Integer (Extr (T, Four));
+   end Safe;
+
+   -- prod z n = comp (10, -10*n, 0, 1)
+   function Prod (T : LFT; N : Big_Integer) return LFT is
+      use Big_Integers;
+   begin
+      return Comp (LFT'(Q => Ten, R => -Ten * N, S => Zero, T => One), T);
+   end Prod;
+
+   procedure Print_Pi (Digit_Count : Positive) is
+      Z : LFT := Unit;
+      Y : Big_Integer;
+      Count : Natural := 0;
+   begin
+      loop
+         Y := Next (Z);
+         if Safe (Z, Y) then
+            Count := Count + 1;
+            Ada.Text_IO.Put (Big_Integers.Image (Y));
+            exit when Count >= Digit_Count;
+            Z := Prod (Z, Y);
+         else
+            Z := Comp (Z, LFTS);
+         end if;
+      end loop;
+   end Print_Pi;
+
+   N : Positive := 250;
+begin
+   if Ada.Command_Line.Argument_Count = 1 then
+      N := Positive'Value (Ada.Command_Line.Argument (1));
+   end if;
+   Print_Pi (N);
+end Pi_Digits;

Task/Pi/Ruby/pi-1.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/Tcl/pi-1.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]
+	}
+    }
+}