Data update

Task/Pi/Ada/pi.adb

@@ -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/PowerShell/pi-1.ps1

@@ -0,0 +1,57 @@
+Function Get-Pi ( $Digits )
+    {
+    $Big = [bigint[]](0..10)
+
+    $ndigits = 0
+    $Output = ""
+
+    $q = $t = $k = $Big[1]
+    $r =           $Big[0]
+    $l = $n =      $Big[3]
+    # Calculate first digit
+    $nr = ( $Big[2] * $q + $r ) * $l
+    $nn = ( $q * ( $Big[7] * $k + $Big[2] ) + $r * $l ) / ( $t * $l )
+    $q *= $k
+    $t *= $l
+    $l += $Big[2]
+    $k = $k + $Big[1]
+    $n = $nn
+    $r = $nr
+
+    $Output += [string]$n + '.'
+    $ndigits++
+
+    $nr = $Big[10] * ( $r - $n * $t )
+    $n = ( ( $Big[10] * ( 3 * $q + $r ) ) / $t ) - 10 * $n
+    $q *= $Big[10]
+    $r = $nr
+
+    While ( $ndigits -lt $Digits )
+        {
+        While ( $ndigits % 100 -ne 0 -or -not $Output )
+            {
+            If ( $Big[4] * $q + $r - $t -lt $n * $t )
+                {
+                $Output += [string]$n
+                $ndigits++
+                $nr = $Big[10] * ( $r - $n * $t )
+                $n = ( ( $Big[10] * ( 3 * $q + $r ) ) / $t ) - 10 * $n
+                $q *= $Big[10]
+                $r = $nr
+                }
+            Else
+                {
+                $nr = ( $Big[2] * $q + $r ) * $l
+                $nn = ( $q * ( $Big[7] * $k + $Big[2] ) + $r * $l ) / ( $t * $l )
+                $q *= $k
+                $t *= $l
+                $l += $Big[2]
+                $k = $k + $Big[1]
+                $n = $nn
+                $r = $nr
+                }
+            }
+        $Output
+        $Output = ""
+        }
+    }

Task/Pi/PowerShell/pi-2.ps1

@@ -0,0 +1 @@
+[math]::pi

Task/Pi/PowerShell/pi-3.ps1

@@ -0,0 +1,2 @@
+.Net digits of pi
+3.14159265358979

Task/Pi/REXX/pi-3.rexx

@@ -0,0 +1,29 @@
+-- 12 Sep 2025
+include Setting
+signal on halt
+parse arg digs','slice
+if digs = '' then
+   digs=1000
+if slice = '' then
+   slice=1
+
+say 'PI - Chudnovsky or AGM repeated pi calculation (in' 1000%slice 'slices)'
+say version
+say
+do i = 1 to digs+1
+   if i//slice = 0 then do
+      numeric digits i+2; call CharOut ,SubStr(Pi(),i-slice+1,slice)
+   end
+end
+say
+say 'Specified' digs 'digits exhausted.'
+call Timer
+exit
+
+Halt:
+say
+say 'Halted because of Ctrl-Break.'
+call Timer
+exit
+
+include Math