modules

Author: Blattvorhang

Week_10/Homework_01_ModulesModellingMatrices/.ocamlformat

@@ -0,0 +1,88 @@
+# Modules Modelling Matrices
+We define the signature
+
+```ocaml
+module type Ring = sig
+  type t
+  val zero : t
+  val one : t
+  val add : t -> t -> t
+  val mul : t -> t -> t
+  val compare : t -> t -> int
+  val to_string : t -> string
+end
+```
+
+of an [algebraic ring structure](https://en.wikipedia.org/wiki/Ring_(mathematics)), where `add` and `mul` are the two binary operations on the set of elements of type `t`. Values `zero` and `one` represent the identity elements with respect to *addition* and *multiplication*. The function `compare` establishes a total order on the elements of the set. The auxiliary function `to_string` is used to generate a string representation of an element. This signature is available in `ring/libRing.ml`.
+
+Furthermore, a matrix is given by the signature:
+
+```ocaml
+module type Matrix = sig
+  type elem
+  type t
+  val create : int -> int -> t
+  val identity : int -> t
+  val from_rows : elem list list -> t
+  val row_count : t -> int
+  val col_count : t -> int
+  val set : int -> int -> elem -> t -> t
+  val get : int -> int -> t -> elem
+  val transpose : t -> t
+  val add : t -> t -> t
+  val mul : t -> t -> t
+  val to_string : t -> string
+end
+```
+
+Here, `elem` and `t` represent the types of the elements of the matrix and the matrix itself, respectively. The functions have the following semantics:
+
+- `create n m` creates an empty (all zeroes) $n\times m$ matrix.
+- `identity n` creates an $n\times n$ identity matrix.
+- `row_count m` and `col_count m` return the number of rows and columns in `m`, respectively.
+- `from_rows l` creates a matrix from the given list of rows (lists of elements). You may assume that `l` is non-empty and all lists have the same length.
+- `set r c v m` sets the element at row `r` and column `c` in matrix `m` to value `v`.
+- `get r c m` returns the element at row `r` and column `c` from matrix `m`.
+- `transpose m` returns the transpose of matrix `m`.
+- `add a b` adds matrices `a` and `b` component-wise.
+- `mul a b` computes the matrix multiplication of `a` and `b`.
+- `to_string m` produces a string representation of `m`. Columns shall be separated by single whitespaces and rows by a newline character `\n`.
+
+This signature is available in `matrix/libMatrix.ml`.
+
+Perform these tasks:
+
+- **IntRing**  
+    In the file `intring/libIntRing.ml`: Implement a module `IntRing` that implements the `Ring` signature for the `int` type. [0.5 points]
+- **FloatRing**  
+    In the file `floatring/libFloatRing.ml`: Implement a module `FloatRing` that implements the `Ring` signature for the `float` type. [0.5 points]
+- **FiniteRing**  
+    In the file `finitering/libFiniteRing.ml`: Define a signature `FiniteRing` that extends the `Ring` signature with a value `elems` that represents a list of all elements of the ring's finite set. Make sure that everything in the `Ring` signature is part of `FiniteRing` (without copy-pasting them)! [0.5 points]
+- **BoolRing**  
+    In the file `boolring/libBoolRing.ml`: Implement a module `BoolRing` that implements the `FiniteRing` signature for the `bool` type. The multiplication in a bool ring is *conjunction*, the addition is the *exclusive or*. [0.5 points]
+- **SetRing**  
+    In the file `setring/libSetRing.ml`: Implement a functor `SetRing` that models a ring over the power set of the set in the `FiniteRing` passed as the functor's argument. `SetRing` has to implement the `Ring` signature. We use union and intersection as `add` and `mul` operations. The representation produced by `to_string` is $\{e_1,\dots,e_n\}$. For `compare` we use a bit of an unconventional order. First, we order the elements in the set by their own order and then compare the sets lexicographically, e.g. $\emptyset<\{1,2,3\}<\{2\}<\{2,3\}<\{3\}$. The type `t` in `SetRing` should be `D.t list`, if `D` is the module that is passed to the functor. Make sure that this information about `t` is exposed to the outside. [1.5 points]
+- **DenseMatrix**  
+    In the file `densematrix/libDenseMatrix.ml`: Implement a functor `DenseMatrix` that satisfies the `Matrix` signature. The argument of the functor is a `Ring` that provides everything to implement the matrix operations. The `DenseMatrix` is supposed to store all elements in the matrix in a list of rows, which are lists of elements. [3 points]
+- **SparseMatrix**  
+    In the file `sparsematrix/libSparseMatrix.ml`: Implement a functor `SparseMatrix` that satisfies the `Matrix` signature. The argument of the functor is a `Ring` that provides everything to implement the matrix operations. The `SparseMatrix` stores only those elements of the matrix that are non-zero. More precisely, the representation of a sparse matrix must have memory usage proportional to the number of non-zero entries in the matrix ($\mathcal{O}(n)$). [3.5 points]
+
+*Hint: You may assume that all inputs are valid, e.g. no out-of-bounds access. If you wish to handle invalid input, just throw an exception.*
+
+*Hint: The function implementations need not be particularly efficient or tail-recursive, just keep your implementations simple where possible.*
+
+## Assignment Repository Layout and Tests
+Testing your solutions is more difficult this week as a test cannot compile if any module it depends on is not correctly implemented or a module signature is incorrectly defined. Thus, we have separated each module into its own `dune` library (one per directory). This way, we can compile and test each library independently. However, since some tasks require implementations of previous tasks, we have introduced dependencies between the libraries. If building any dependency of a library fails, we cannot test that library (and the corresponding task will receive zero points) as building it would fail too. You can consult the `dune` files or the graph below to see exactly what the dependencies are. If you don't want to submit a solution for some task, check Artemis to make sure that the public tests for the tasks that you do want to submit pass. In particular, look for the `*:build` tests, which pass only if that library can be tested and tell you why it cannot otherwise.
+
+Write any code you want to share between tasks in `common/common.ml`.
+
+To not cause issues with the tests, you should not change the provided `dune` files (the tests on Artemis will ignore your `dune` files).
+
+<details>
+    <summary>Overview of dependencies</summary>
+    Example: If your implementation of `libFiniteRing` can't compile, then `libBoolRing` and `libSetRing` will not be tested and receive zero points.
+
+    Example: You can reuse any implementations you write in `libMatrix` in `libDenseMatrix` and `libSparseMatrix`, but don't change the `Matrix` signature.
+
+    *Tip: You can generate similar graphs for any dune project by installing dune-deps with opam install dune-deps, then running e.g. `dune-deps | dot -Tpng > deps.png`*
+</details>

Week_10/Homework_01_ModulesModellingMatrices/README.md

@@ -0,0 +1,6 @@
+; auto-generated by deps.sh
+(library
+ (name libBoolRing)
+ (libraries common libRing libFiniteRing)
+ (flags
+ (:standard -warn-error -27-33)))

Week_10/Homework_01_ModulesModellingMatrices/boolring/dune

@@ -0,0 +1,13 @@
+open Common
+open LibRing
+
+module BoolRing = struct
+  type t = bool
+  let elems = [true; false]
+  let zero = false
+  let one = true
+  let add = ( <> ) (* exclusive or *)
+  let mul = ( && ) (* conjunction *)
+  let compare = compare
+  let to_string = string_of_bool
+end

Week_10/Homework_01_ModulesModellingMatrices/boolring/libBoolRing.ml

@@ -0,0 +1,5 @@
+; auto-generated by deps.sh
+(library
+ (name common)
+ (flags
+ (:standard -warn-error -27-33)))

Week_10/Homework_01_ModulesModellingMatrices/common/common.ml

@@ -0,0 +1,6 @@
+; auto-generated by deps.sh
+(library
+ (name libDenseMatrix)
+ (libraries common libRing libMatrix)
+ (flags
+ (:standard -warn-error -27-33)))

Week_10/Homework_01_ModulesModellingMatrices/common/dune

@@ -0,0 +1,124 @@
+open Common
+open LibRing
+open LibMatrix
+
+module DenseMatrix = functor (R : Ring) ->
+  struct
+    type elem = R.t
+    (* for matrix m*n, rows from 0 to m-1, columns from 0 to n-1 *)
+    type t = elem list list (* Define that t_{00} is the top of stack *)
+
+    let create n m =
+      let rec create_row j =
+        if j = 0 then [] else R.zero :: create_row (j - 1)
+      in
+      let row = create_row m in
+      let rec create_rows i =
+        if i = 0 then [] else row :: create_rows (i - 1)
+      in
+      create_rows n
+
+    let identity n =
+      let rec identity_row i j =
+        if j = 0 then [] else
+          if i = j then R.one :: identity_row i (j - 1)
+          else R.zero :: identity_row i (j - 1)
+      in
+      let rec identity_rows i =
+        if i = 0 then [] else identity_row i n :: identity_rows (i - 1)
+      in
+      identity_rows n
+      
+    let row_count m = 
+      let rec row_count_aux acc = function
+        | [] -> acc
+        | _::xs -> row_count_aux (acc + 1) xs
+      in row_count_aux 0 m
+
+    let col_count m = 
+      let rec col_count_aux acc = function
+        | [] -> acc
+        | _::xs -> col_count_aux (acc + 1) xs
+      in col_count_aux 0 (List.hd m)
+
+    let from_rows l = l
+
+    let set r c v m =
+      let rec set_column c v = function
+        | [] -> failwith "set: column out of bounds"
+        | x::xs -> if c = 0 then v::xs else x::set_column (c - 1) v xs
+      in
+      let rec set_row r c v = function
+        | [] -> failwith "set: row out of bounds"
+        | x::xs -> if r = 0 then set_column c v x::xs else x::set_row (r - 1) c v xs
+      in
+      set_row r c v m
+
+    let get r c m =
+      let rec get_column c = function
+        | [] -> failwith "get: column out of bounds"
+        | x::xs -> if c = 0 then x else get_column (c - 1) xs
+      in
+      let rec get_row r c = function
+        | [] -> failwith "get: row out of bounds"
+        | x::xs -> if r = 0 then get_column c x else get_row (r - 1) c xs
+      in
+      get_row r c m
+
+    let transpose m =
+      let rec transpose_row i j m acc =
+        if j = 0 then acc else
+          transpose_row i (j - 1) m (get (j - 1) (i - 1) m :: acc) (* set i j *)
+      in
+      let rec transpose_rows i j m acc =
+        if i = 0 then acc else
+          transpose_rows (i - 1) j m (transpose_row i j m [] :: acc)
+      in
+      transpose_rows (col_count m) (row_count m) m [] (* swap rows and columns *)
+
+    let add a b = 
+      let rec add_row = function
+        | [], [] -> []
+        | x::xs, y::ys -> R.add x y :: add_row (xs, ys)
+        | _ -> failwith "add: matrices have different dimensions"
+      in
+      let rec add_rows = function
+        | [], [] -> []
+        | x::xs, y::ys -> add_row (x, y) :: add_rows (xs, ys)
+        | _ -> failwith "add: matrices have different dimensions"
+      in
+      add_rows (a, b)
+
+    let mul a b = (* c_{ij} = \Sigma_k a_{ik} b_{kj} *)
+      let a_col = col_count a in
+      let b_row = row_count b in
+      let rec sum r c k =
+        if k = 0 then R.zero else
+          R.add (R.mul (get (r - 1) (k - 1) a) (get (k - 1) (c - 1) b)) (sum r c (k - 1))
+      in
+      let rec mul_row r c acc =
+        if c = 0 then acc else
+          mul_row r (c - 1) (sum r c a_col :: acc)
+      in
+      let rec mul_rows r c acc =
+        if r = 0 then acc else
+          mul_rows (r - 1) c (mul_row r c [] :: acc)
+      in
+      if a_col <> b_row then
+        failwith "mul: matrices have incompatible dimensions"
+      else
+        mul_rows (row_count a) (col_count b) []
+
+    let to_string m =
+      let rec to_string_row = function
+        | [] -> ""
+        | [x] -> R.to_string x
+        | x::xs -> R.to_string x ^ " " ^ to_string_row xs
+      in
+      let rec to_string_rows = function
+        | [] -> ""
+        | [x] -> to_string_row x
+        | x::xs -> to_string_row x ^ "\n" ^ to_string_rows xs
+      in
+      to_string_rows m
+  end

Week_10/Homework_01_ModulesModellingMatrices/densematrix/dune

@@ -0,0 +1 @@
+(lang dune 2.0)

Week_10/Homework_01_ModulesModellingMatrices/densematrix/libDenseMatrix.ml

@@ -0,0 +1,6 @@
+; auto-generated by deps.sh
+(library
+ (name libFiniteRing)
+ (libraries common libRing)
+ (flags
+ (:standard -warn-error -27-33)))

Week_10/Homework_01_ModulesModellingMatrices/dune-project

@@ -0,0 +1,7 @@
+open Common
+open LibRing
+
+module type FiniteRing = sig
+  include Ring
+  val elems : t list
+end

Week_10/Homework_01_ModulesModellingMatrices/finitering/dune

@@ -0,0 +1,6 @@
+; auto-generated by deps.sh
+(library
+ (name libFloatRing)
+ (libraries common libRing)
+ (flags
+ (:standard -warn-error -27-33)))

Week_10/Homework_01_ModulesModellingMatrices/finitering/libFiniteRing.ml

@@ -0,0 +1,12 @@
+open Common
+open LibRing
+
+module FloatRing = struct
+  type t = float
+  let zero = 0.
+  let one = 1.
+  let add = ( +. )
+  let mul = ( *. )
+  let compare = compare
+  let to_string = string_of_float
+end

Week_10/Homework_01_ModulesModellingMatrices/floatring/dune

@@ -0,0 +1,6 @@
+; auto-generated by deps.sh
+(library
+ (name libIntRing)
+ (libraries common libRing)
+ (flags
+ (:standard -warn-error -27-33)))

Week_10/Homework_01_ModulesModellingMatrices/floatring/libFloatRing.ml

@@ -0,0 +1,12 @@
+open Common
+open LibRing
+
+module IntRing = struct
+  type t = int
+  let zero = 0
+  let one = 1
+  let add = ( + )
+  let mul = ( * )
+  let compare = compare
+  let to_string = string_of_int
+end

Week_10/Homework_01_ModulesModellingMatrices/intring/dune

@@ -0,0 +1,6 @@
+; auto-generated by deps.sh
+(library
+ (name libMatrix)
+ (libraries common)
+ (flags
+ (:standard -warn-error -27-33)))

Week_10/Homework_01_ModulesModellingMatrices/intring/libIntRing.ml

@@ -0,0 +1,15 @@
+module type Matrix = sig
+  type elem
+  type t
+  val create : int -> int -> t
+  val identity : int -> t
+  val from_rows : elem list list -> t
+  val to_string : t -> string
+  val set : int -> int -> elem -> t -> t
+  val get : int -> int -> t -> elem
+  val transpose : t -> t
+  val add : t -> t -> t
+  val mul : t -> t -> t
+  val row_count : t -> int
+  val col_count : t -> int
+end

Week_10/Homework_01_ModulesModellingMatrices/matrix/dune

@@ -0,0 +1,6 @@
+; auto-generated by deps.sh
+(library
+ (name libRing)
+ (libraries common)
+ (flags
+ (:standard -warn-error -27-33)))

Week_10/Homework_01_ModulesModellingMatrices/matrix/libMatrix.ml

@@ -0,0 +1,9 @@
+module type Ring = sig
+  type t
+  val zero : t
+  val one : t
+  val compare : t -> t -> int
+  val to_string : t -> string
+  val add : t -> t -> t
+  val mul : t -> t -> t
+end

Week_10/Homework_01_ModulesModellingMatrices/ring/dune

@@ -0,0 +1,6 @@
+; auto-generated by deps.sh
+(library
+ (name libSetRing)
+ (libraries common libRing libFiniteRing)
+ (flags
+ (:standard -warn-error -27-33)))

Week_10/Homework_01_ModulesModellingMatrices/ring/libRing.ml

@@ -0,0 +1,35 @@
+open Common
+open LibRing
+open LibFiniteRing
+
+module SetRing = functor (D : FiniteRing) ->
+  struct
+    type t = D.t list (* set *)
+    let zero = []     (* empty set *)
+    let one = D.elems (* universe *)
+
+    let rec add a b = (* union *)
+      match a with
+      | [] -> b
+      | x::xs -> if List.mem x b then add xs b else add xs (x::b) (* tail recursive *)
+
+    let rec mul a b = (* intersection *)
+      match a with
+      | [] -> []
+      | x::xs -> if List.mem x b then x::(mul xs b) else mul xs b
+
+    let compare a b = (* lexicographical *)
+      let rec compare_aux a b = match a, b with
+        | [], [] -> 0
+        | [], _ -> -1
+        | _, [] -> 1
+        | x::xs, y::ys -> let c = D.compare x y in if c = 0 then compare_aux xs ys else c
+      in compare_aux (List.sort_uniq D.compare a) (List.sort_uniq D.compare b)
+      
+    let to_string s =
+      let rec to_string_aux = function
+        | [] -> ""
+        | [x] -> D.to_string x (* no comma *)
+        | x::xs -> (D.to_string x) ^ ", " ^ (to_string_aux xs)
+      in "{" ^ (to_string_aux s) ^ "}"
+  end

Week_10/Homework_01_ModulesModellingMatrices/setring/dune

@@ -0,0 +1,6 @@
+; auto-generated by deps.sh
+(library
+ (name libSparseMatrix)
+ (libraries common libRing libMatrix)
+ (flags
+ (:standard -warn-error -27-33)))