1 files changed, 298 insertions, 0 deletions

diff --git a/src/lib/src/matrix.c b/src/lib/src/matrix.c
new file mode 100644
index 0000000..a7a4ce6
--- /dev/null
+++ b/src/lib/src/matrix.c
@@ -0,0 +1,298 @@
+#include <neuralnet/matrix.h>
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+nnMatrix nnMatrixMake(int rows, int cols) {
+  R* values = calloc(rows * cols, sizeof(R));
+  assert(values != 0);
+
+  return (nnMatrix) {
+    .rows = rows,
+    .cols = cols,
+    .values = values,
+  };
+}
+
+void nnMatrixDel(nnMatrix* matrix) {
+  assert(matrix != 0);
+
+  if (matrix->values != 0) {
+    free(matrix->values);
+    matrix->values = 0;
+    matrix->rows = 0;
+    matrix->cols = 0;
+  }
+}
+
+void nnMatrixMove(nnMatrix* in, nnMatrix* out) {
+  assert(in);
+  assert(out);
+
+  out->rows = in->rows;
+  out->cols = in->cols;
+  out->values = in->values;
+
+  in->rows = 0;
+  in->cols = 0;
+  in->values = 0;
+}
+
+void nnMatrixCopy(const nnMatrix* in, nnMatrix* out) {
+  assert(in);
+  assert(out);
+  assert(in->rows == out->rows);
+  assert(in->cols == out->cols);
+
+  const R* in_value = in->values;
+  R* out_value = out->values;
+
+  for (int i = 0; i < in->rows * in->cols; ++i) {
+    *out_value++ = *in_value++;
+  }
+}
+
+void nnMatrixToArray(const nnMatrix* in, R* out) {
+  assert(in);
+  assert(out);
+
+  const R* values = in->values;
+  for (int i = 0; i < in->rows * in->cols; ++i) {
+    *out++ = *values++;
+  }
+}
+
+void nnMatrixRowToArray(const nnMatrix* in, int row, R* out) {
+  assert(in);
+  assert(out);
+
+  const R* values = in->values + row * in->cols;
+  for (int i = 0; i < in->cols; ++i) {
+    *out++ = *values++;
+  }
+}
+
+void nnMatrixCopyCol(const nnMatrix* in, nnMatrix* out, int col_in, int col_out) {
+  assert(in);
+  assert(out);
+  assert(in->rows == out->rows);
+  assert(col_in < in->cols);
+  assert(col_out < out->cols);
+
+  for (int row = 0; row < in->rows; ++row) {
+    nnMatrixSet(out, row, col_out, nnMatrixAt(in, row, col_in));
+  }
+}
+
+nnMatrix nnMatrixBorrow(nnMatrix* in) {
+  assert(in);
+
+  nnMatrix out;
+  out.rows = in->rows;
+  out.cols = in->cols;
+  out.values = in->values;
+  return out;
+}
+
+nnMatrix nnMatrixBorrowRows(nnMatrix* in, int row_start, int num_rows) {
+  assert(in);
+  assert(row_start < in->rows);
+  assert(row_start + num_rows <= in->rows);
+
+  nnMatrix out;
+  out.rows = num_rows;
+  out.cols = in->cols;
+  out.values = nnMatrixRow_mut(in, row_start);
+  return out;
+}
+
+void nnMatrixInit(nnMatrix* matrix, const R* values) {
+  assert(matrix);
+  assert(values);
+  memcpy(matrix->values, values, matrix->rows * matrix->cols * sizeof(R));
+}
+
+void nnMatrixInitConstant(nnMatrix* matrix, R value) {
+  assert(matrix);
+  for (int i = 0; i < matrix->rows * matrix->cols; ++i) {
+    matrix->values[i] = value;
+  }
+}
+
+void nnMatrixMul(const nnMatrix* left, const nnMatrix* right, nnMatrix* out) {
+  assert(left != 0);
+  assert(right != 0);
+  assert(out != 0);
+  assert(out != left);
+  assert(out != right);
+  assert(left->cols == right->rows);
+  assert(out->rows == left->rows);
+  assert(out->cols == right->cols);
+
+  R* out_value = out->values;
+
+  for (int i = 0; i < left->rows; ++i) {
+    const R* left_row = &left->values[i * left->cols];
+
+    for (int j = 0; j < right->cols; ++j) {
+      const R* right_col = &right->values[j];
+      *out_value = 0;
+
+      // Vector dot product.
+      for (int k = 0; k < left->cols; ++k) {
+        *out_value += left_row[k] * right_col[0];
+        right_col += right->cols;  // Next row in the column.
+      }
+
+      out_value++;
+    }
+  }
+}
+
+void nnMatrixMulAdd(const nnMatrix* left, const nnMatrix* right, R scale, nnMatrix* out) {
+  assert(left);
+  assert(right);
+  assert(out);
+  assert(left->rows == right->rows);
+  assert(left->cols == right->cols);
+  assert(left->rows == out->rows);
+  assert(left->cols == out->cols);
+
+  const R* left_value = left->values;
+  const R* right_value = right->values;
+  R* out_value = out->values;
+
+  for (int i = 0; i < left->rows * left->cols; ++i) {
+    *out_value++ = *left_value++ + *right_value++ * scale;
+  }
+}
+
+void nnMatrixMulSub(const nnMatrix* left, const nnMatrix* right, R scale, nnMatrix* out) {
+  assert(left);
+  assert(right);
+  assert(out);
+  assert(left->rows == right->rows);
+  assert(left->cols == right->cols);
+  assert(left->rows == out->rows);
+  assert(left->cols == out->cols);
+
+  const R* left_value = left->values;
+  const R* right_value = right->values;
+  R* out_value = out->values;
+
+  for (int i = 0; i < left->rows * left->cols; ++i) {
+    *out_value++ = *left_value++ - *right_value++ * scale;
+  }
+}
+
+void nnMatrixMulPairs(const nnMatrix* left, const nnMatrix* right, nnMatrix* out) {
+  assert(left != 0);
+  assert(right != 0);
+  assert(out != 0);
+  assert(left->rows == right->rows);
+  assert(left->cols == right->cols);
+  assert(left->rows == out->rows);
+  assert(left->cols == out->cols);
+
+  R* left_value = left->values;
+  R* right_value = right->values;
+  R* out_value = out->values;
+
+  for (int i = 0; i < left->rows * left->cols; ++i) {
+    *out_value++ = *left_value++ * *right_value++;
+  }
+}
+
+void nnMatrixAdd(const nnMatrix* left, const nnMatrix* right, nnMatrix* out) {
+  assert(left);
+  assert(right);
+  assert(out);
+  assert(left->rows == right->rows);
+  assert(left->cols == right->cols);
+  assert(left->rows == out->rows);
+  assert(left->cols == out->cols);
+
+  const R* left_value = left->values;
+  const R* right_value = right->values;
+  R* out_value = out->values;
+
+  for (int i = 0; i < left->rows * left->cols; ++i) {
+    *out_value++ = *left_value++ + *right_value++;
+  }
+}
+
+void nnMatrixSub(const nnMatrix* left, const nnMatrix* right, nnMatrix* out) {
+  assert(left);
+  assert(right);
+  assert(out);
+  assert(left->rows == right->rows);
+  assert(left->cols == right->cols);
+  assert(left->rows == out->rows);
+  assert(left->cols == out->cols);
+
+  const R* left_value = left->values;
+  const R* right_value = right->values;
+  R* out_value = out->values;
+
+  for (int i = 0; i < left->rows * left->cols; ++i) {
+    *out_value++ = *left_value++ - *right_value++;
+  }
+}
+
+void nnMatrixAddRow(const nnMatrix* matrix, const nnMatrix* row, nnMatrix* out) {
+  assert(matrix);
+  assert(row);
+  assert(out);
+  assert(row->rows == 1);
+  assert(matrix->cols == row->cols);
+  assert(matrix->rows == out->rows);
+  assert(matrix->cols == out->cols);
+
+  const R* matrix_value = matrix->values;
+  R* out_value = out->values;
+
+  for (int i = 0; i < matrix->rows; ++i) {
+    const R* row_value = row->values;
+    for (int j = 0; j < row->cols; ++j) {
+      *out_value++ = *matrix_value++ + *row_value++;
+    }
+  }
+}
+
+void nnMatrixScale(nnMatrix* matrix, R scale) {
+  assert(matrix);
+
+  R* value = matrix->values;
+  for (int i = 0; i < matrix->rows * matrix->cols; ++i) {
+    *value++ *= scale;
+  }
+}
+
+void nnMatrixTranspose(const nnMatrix* in, nnMatrix* out) {
+  assert(in);
+  assert(out);
+  assert(in != out);
+  assert(in->rows == out->cols);
+  assert(in->cols == out->rows);
+
+  for (int i = 0; i < in->rows; ++i) {
+    for (int j = 0; j < in->cols; ++j) {
+      nnMatrixSet(out, j, i, nnMatrixAt(in, i, j));
+    }
+  }
+}
+
+void nnMatrixGt(const nnMatrix* in, R threshold, nnMatrix* out) {
+  assert(in);
+  assert(out);
+  assert(in->rows == out->rows);
+  assert(in->cols == out->cols);
+
+  const R* in_value = in->values;
+  R* out_value = out->values;
+
+  for (int i = 0; i < in->rows * in->cols; ++i) {
+    *out_value++ = (*in_value++) > threshold ? 1 : 0;
+  }
+}