Data commit

Task/Gaussian-elimination/Modula-3/gaussian-elimination-1.mod3

@@ -0,0 +1,41 @@
+GENERIC INTERFACE Matrix(RingElem);
+
+(*
+"RingElem" must export the following:
+- a type T;
+- procedures
+  + "Nonzero(a: T): BOOLEAN", which indicates whether "a" is nonzero;
+  + "Minus(a, b: T): T" and "Times(a, b: T): T",
+    which return the results you'd guess from the procedures' names; and
+  + "Print(a: T)", which does what the name implies.
+*)
+
+TYPE
+
+  T <: Public;
+
+  Public = OBJECT
+  METHODS
+    init(READONLY data: ARRAY OF ARRAY OF RingElem.T): T;
+    (* use this to copy the entries in "data"; returns "self" *)
+    initDimensions(m, n: CARDINAL): T;
+    (* use this for an mxn matrix of random entries *)
+    num_rows(): CARDINAL;
+    (* returns the number of rows in "self" *)
+    num_cols(): CARDINAL;
+    (* returns the number of columns in "self" *)
+    entries(): REF ARRAY OF ARRAY OF RingElem.T;
+    (* returns the entries in "self" *)
+    triangularize();
+    (*
+      Performs Gaussian elimination in the context of a ring.
+      We can add scalar multiples of rows,
+      and we can swap rows, but we may lack multiplicative inverses,
+      so we cannot necessarily obtain 1 as a row's first entry.
+    *)
+  END;
+
+  PROCEDURE PrintMatrix(m: T);
+  (* prints the matrix row-by-row; sorry, no special padding to line up columns *)
+
+END Matrix.

Task/Gaussian-elimination/Modula-3/gaussian-elimination-2.mod3

@@ -0,0 +1,158 @@
+GENERIC MODULE Matrix(RingElem);
+
+IMPORT IO;
+
+TYPE
+
+  REVEAL T = Public BRANDED OBJECT
+    rows, cols: CARDINAL;
+    data: REF ARRAY OF ARRAY OF RingElem.T;
+  OVERRIDES
+    init := Init;
+    initDimensions := InitDimensions;
+    num_rows := Rows;
+    num_cols := Columns;
+    entries := Entries;
+    triangularize := Triangularize;
+  END;
+
+PROCEDURE Init(self: T; READONLY d: ARRAY OF ARRAY OF RingElem.T): T =
+BEGIN
+  self.rows := NUMBER(d);
+  self.cols := NUMBER(d[0]);
+  self.data := NEW(REF ARRAY OF ARRAY OF RingElem.T, self.rows, self.cols);
+  FOR i := FIRST(d) TO LAST(d) DO
+    FOR j := FIRST(d[0]) TO LAST(d[0]) DO
+      self.data[i-FIRST(d)][j-FIRST(d[0])] := d[i][j];
+    END;
+  END;
+  RETURN self;
+END Init;
+
+PROCEDURE InitDimensions(self: T; r, c: CARDINAL): T =
+BEGIN
+  self.rows := r;
+  self.cols := c;
+  self.data := NEW(REF ARRAY OF ARRAY OF RingElem.T, r, c);
+  RETURN self;
+END InitDimensions;
+
+PROCEDURE Rows(self: T): CARDINAL =
+BEGIN
+  RETURN self.rows;
+END Rows;
+
+PROCEDURE Columns(self: T): CARDINAL =
+BEGIN
+  RETURN self.cols;
+END Columns;
+
+PROCEDURE Entries(self: T): REF ARRAY OF ARRAY OF RingElem.T =
+BEGIN
+  RETURN self.data;
+END Entries;
+
+PROCEDURE SwapRows(VAR data: ARRAY OF ARRAY OF RingElem.T; i, j: CARDINAL) =
+(* swaps rows i and j of data *)
+VAR
+  a: RingElem.T;
+BEGIN
+  WITH Ai = data[i], Aj = data[j], m = FIRST(data[0]), n = LAST(data[0]) DO
+    FOR k := m TO n DO
+      a     := Ai[k];
+      Ai[k] := Aj[k];
+      Aj[k] := a;
+    END;
+  END;
+END SwapRows;
+
+PROCEDURE PivotExists(
+    VAR data: ARRAY OF ARRAY OF RingElem.T;
+    r: CARDINAL;
+    VAR i: CARDINAL;
+    j: CARDINAL
+): BOOLEAN =
+(*
+  Returns true iff column j of data has a pivot in some row at or after r.
+  The row with a pivot is stored in i.
+*)
+VAR
+  searching := TRUE;
+  result := LAST(data) + 1;
+BEGIN
+  i := r;
+  WHILE searching AND i <= LAST(data) DO
+    IF RingElem.Nonzero(data[i,j]) THEN
+      searching := FALSE;
+      result := i;
+    ELSE
+      INC(i);
+    END;
+  END;
+  RETURN NOT searching;
+END PivotExists;
+
+PROCEDURE Pivot(VAR data: ARRAY OF ARRAY OF RingElem.T; i, j, k: CARDINAL) =
+(*
+  Pivots on row i, column j to eliminate row k, column j.
+*)
+BEGIN
+  WITH n = LAST(data[0]), Ai = data[i], Ak = data[k] DO
+    VAR a := Ai[j]; b := Ak[j];
+    BEGIN
+      FOR l := j TO n DO
+        IF RingElem.Nonzero(Ai[l]) THEN
+          Ak[l] := RingElem.Minus(
+              RingElem.Times(Ak[l], a),
+              RingElem.Times(Ai[l], b)
+          );
+        ELSE
+          Ak[l] := RingElem.Times(Ak[l], a);
+        END;
+      END;
+    END;
+  END;
+END Pivot;
+
+PROCEDURE Triangularize(self: T) =
+VAR
+  i: CARDINAL;
+  r := FIRST(self.data[0]);
+BEGIN
+  WITH data = self.data, m = FIRST(data[0]), n = LAST(data[0]) DO
+    FOR j := m TO n DO
+      IF PivotExists(data^, r, i, j) THEN
+        IF i # j THEN
+          SwapRows(data^, i, r);
+        END;
+        FOR k := r + 1 TO LAST(data^) DO
+          IF RingElem.Nonzero(data[k][j]) THEN
+            Pivot(data^, r, j, k);
+          END;
+        END;
+        INC(r);
+      END;
+    END;
+  END;
+END Triangularize;
+
+PROCEDURE PrintMatrix(self: T) =
+BEGIN
+  WITH data = self.data DO
+    FOR i := FIRST(data^) TO LAST(data^) DO
+      IO.Put("[ ");
+      WITH Ai = data[i] DO
+        FOR j := FIRST(Ai) TO LAST(Ai) DO
+          RingElem.Print(Ai[j]);
+          IF j # LAST(Ai) THEN
+            IO.PutChar(' ');
+          END;
+        END;
+      END;
+      IO.Put(" ]\n");
+    END;
+  END;
+END PrintMatrix;
+
+BEGIN
+END Matrix.

Task/Gaussian-elimination/Modula-3/gaussian-elimination-3.mod3

@@ -0,0 +1,32 @@
+INTERFACE ModularRing;
+
+(*
+Implements arithmetic modulo a nonzero integer.
+Assertions check that the modulus is nonzero.
+*)
+
+TYPE
+
+  T = RECORD
+    value, modulus: CARDINAL;
+  END;
+
+PROCEDURE Init(VAR a: T; value: INTEGER; modulus: CARDINAL);
+(* initializes a to the given value and modulus *)
+
+PROCEDURE Nonzero(n: T): BOOLEAN;
+
+PROCEDURE Plus(a, b: T): T;
+
+PROCEDURE Minus(a, b: T): T;
+
+PROCEDURE Times(a, b: T): T;
+
+PROCEDURE Print(a: T; withModulus := FALSE);
+(*
+   when "withModulus" is "TRUE",
+   this adds after "a" the letter "m",
+   followed by the modulus
+*)
+
+END ModularRing.

Task/Gaussian-elimination/Modula-3/gaussian-elimination-4.mod3

@@ -0,0 +1,67 @@
+MODULE GaussianElimination EXPORTS Main;
+
+IMPORT IO, ModularRing AS MR, IntMatrix AS IM, ModMatrix AS MM;
+
+CONST
+
+  (* data to set up the matrices *)
+
+  A1 = ARRAY OF INTEGER { 2, 1, 0 };
+  A2 = ARRAY OF INTEGER { 1, 2, 0 };
+  A3 = ARRAY OF INTEGER { 0, 3, 0 };
+  A = ARRAY OF ARRAY OF INTEGER { A1, A2, A3 };
+
+  B1 = ARRAY OF INTEGER {  4,  8, 0, -4, 0 };
+  B2 = ARRAY OF INTEGER { -3, -6, 0,  9, 0 };
+  B3 = ARRAY OF INTEGER {  1,  3, 5,  7, 2 };
+  B4 = ARRAY OF INTEGER {  7,  5, 3,  1, 2 };
+  B = ARRAY OF ARRAY OF INTEGER { B1, B2, B3, B4 };
+
+PROCEDURE IntToModArray(READONLY A: IM.T; VAR B: MM.T; mod: CARDINAL) =
+(*
+   copies a two-dimensional array of integers
+   to a two-dimension array of integers modulo "mod"
+*)
+BEGIN
+  B := NEW(MM.T).initDimensions(A.num_rows(), A.num_cols());
+  WITH Adata = A.entries(), Bdata = B.entries() DO
+    FOR i := FIRST(Adata^) TO LAST(Adata^) DO
+      WITH Ai = Adata[i], Bi = Bdata[i] DO
+        FOR j := FIRST(Ai) TO LAST(Ai) DO
+          MR.Init(Bi[j], Ai[j], mod);
+        END;
+      END;
+    END;
+  END;
+END IntToModArray;
+
+VAR
+
+  M: IM.T;
+  N: MM.T;
+
+BEGIN
+
+  (* triangularize the data in A *)
+  M := NEW(IM.T).init(A);
+  IO.Put("Initial A:\n");
+  IM.PrintMatrix(M);
+  IO.PutChar('\n');
+  M.triangularize();
+  IO.Put("Final A:\n");
+  IM.PrintMatrix(M);
+  IO.PutChar('\n');
+  IO.PutChar('\n');
+
+  (* triangularize the data in B, all computations modulo 46 *)
+  M := NEW(IM.T).init(B);
+  IntToModArray(M, N, 46);
+  IO.Put("Initial B:\n");
+  MM.PrintMatrix(N);
+  IO.PutChar('\n');
+  N.triangularize();
+  IO.Put("Final B:\n");
+  MM.PrintMatrix(N);
+  IO.PutChar('\n');
+
+END GaussianElimination.