Add vector matrix

lib/matrix.spec.ts → lib/math.spec.ts

@@ -1,4 +1,4 @@
-import * as matrx from "./matrix";
+import * as matrx from "./math";
 
 test("Dot", () => {
   const a = [[1, 1, 1, 1]];

lib/math.ts

@@ -0,0 +1,88 @@
+export function expM2(matrix: number[][]): number[][] {
+  return matrix.map(m1 => m1.map(m2 => Math.exp(m2)));
+}
+
+export function MultiplyM1M1(matrix1: number[], matrix2: number[]): number[] {
+  if (matrix1.length === matrix2.length) {
+    return matrix1.map((m, i) => matrix1[i] * matrix2[i]);
+  } else {
+    if (matrix1.length < matrix2.length) {
+      return matrix2.map((m, i) => matrix1[0] * matrix2[i]);
+    } else {
+      return matrix1.map((m, i) => matrix1[i] * matrix2[0]);
+    }
+  }
+}
+
+export function MultiplyM2M1(matrix1: number[][], matrix2: number[]): number[][] {
+  const res = [];
+  matrix1.forEach((m, i) => {
+    m.forEach((m2, k) => res.push(matrix2.map(m2 => m2 * matrix1[i][k])));
+  });
+  return res;
+}
+
+export function MultiplyScalarM1(scalar: number, matrix2: number[]): number[] {
+  return matrix2.map(m => m * scalar);
+}
+
+export function SumScalarM2(scalar: number, matrix2: number[][]): number[][] {
+  return matrix2.map(m2 => m2.map((m3, i) => m3 + scalar));
+}
+
+export function SumM1(matrix: number[]): number {
+  return matrix.reduce((p, c) => p + c);
+}
+
+export function SumM2(matrix: number[][]): number {
+  return matrix.map(m => m.reduce((p, c) => p + c)).reduce((p, c) => p + c);
+}
+
+export function SumAxis0M2(matrix: number[][]): number[] {
+  return matrix.map(m => m.reduce((p, c) => p + c));
+}
+
+export function DotDivideM2Scalar(matrix2: number[], scalar: number): number[] {
+  return matrix2.map(m2 => m2 / scalar);
+}
+
+export function DotDivideScalarM1(scalar: number, matrix: number[]): number[] {
+  return matrix.map(m => scalar / m);
+}
+
+export function SquareM1(matrix: number[]): number[] {
+  return matrix.map((m, i) => matrix[i] * matrix[i]);
+}
+
+export function SubtractM2Scalar(matrix1: number[][], scalar: number): number[][] {
+  return matrix1.map(m1 => m1.map((m2, i) => m2 - scalar));
+}
+
+export function SubtractM1Scalar(matrix1: number[], scalar: number): number[] {
+  return matrix1.map(m => m - scalar);
+}
+
+export function SubtracScalarM1(scalar: number, matrix1: number[]): number[] {
+  return matrix1.map(m => scalar - m);
+}
+
+export function SubtractM1M1(matrix1: number[], matrix2: number[]): number[] {
+  if (matrix1.length === matrix2.length) {
+    return matrix1.map((m, i) => matrix1[i] - matrix2[i]);
+  } else {
+    if (matrix1.length < matrix2.length) {
+      return matrix2.map((m, i) => matrix1[0] - matrix2[i]);
+    } else {
+      return matrix1.map((m, i) => matrix1[i] - matrix2[0]);
+    }
+  }
+}
+
+export function DotscalarM2(scalar: number, matrix2: number[][]): number[][] {
+  return matrix2.map(m2 => m2.map((m3, i) => m3 * scalar));
+}
+
+export function DotM2M1(matrix1: number[][], matrix2: number[]): number[] {
+  const res = matrix1.map(m1 => m1.map((m2, i) => m2 * matrix2[i]));
+  return res.map(m1 => m1.reduce((p, c) => p + c));
+}

lib/matrix.ts

@@ -1,88 +1,115 @@
-export function expM2(matrix: number[][]): number[][] {
-  return matrix.map(m1 => m1.map(m2 => Math.exp(m2)));
-}
+import * as Models from "../models";
+import * as Vector from "./vactor";
 
-export function MultiplyM1M1(matrix1: number[], matrix2: number[]): number[] {
-  if (matrix1.length === matrix2.length) {
-    return matrix1.map((m, i) => matrix1[i] * matrix2[i]);
-  } else {
-    if (matrix1.length < matrix2.length) {
-      return matrix2.map((m, i) => matrix1[0] * matrix2[i]);
-    } else {
-      return matrix1.map((m, i) => matrix1[i] * matrix2[0]);
-    }
+export function CreateMatrix(v: number[][]): Models.Matrix {
+  let matrixsInstance: number[][];
+  matrixsInstance = v;
+
+  function val(): number[][] {
+    return matrixsInstance;
   }
-}
 
-export function MultiplyM2M1(matrix1: number[][], matrix2: number[]): number[][] {
-  const res = [];
-  matrix1.forEach((m, i) => {
-    m.forEach((m2, k) => res.push(matrix2.map(m2 => m2 * matrix1[i][k])));
-  });
-  return res;
-}
+  function row(i: number): Models.Vector {
+    if (i < 0 || i >= matrixsInstance.length) {
+      return Vector.CreateVector([0]);
+    }
+    return Vector.CreateVector(matrixsInstance[i]);
+  }
 
-export function MultiplyScalarM1(scalar: number, matrix2: number[]): number[] {
-  return matrix2.map(m => m * scalar);
-}
+  function column(j: number): Models.Vector {
+    if (j < 0 || j >= matrixsInstance[0].length) {
+      return Vector.CreateVector([0]);
+    }
+    const result = [];
+    for (let i = 0; i < matrixsInstance.length; i += 1) {
+      result.push(matrixsInstance[i][j]);
+    }
+    return Vector.CreateVector(result);
+  }
 
-export function SumScalarM2(scalar: number, matrix2: number[][]): number[][] {
-  return matrix2.map(m2 => m2.map((m3, i) => m3 + scalar));
-}
+  function log(): Models.Matrix {
+    const res = matrixsInstance.map((x, i) => x.map((y, k) => Math.log(y)));
+    return CreateMatrix(res);
+  }
 
-export function SumM1(matrix: number[]): number {
-  return matrix.reduce((p, c) => p + c);
-}
+  function add(matrix: number | Models.Matrix): Models.Matrix {
+    if (typeof matrix === "number") {
+      const res = matrixsInstance.map((x: number[]) => x.map(y => (y + matrix) as number));
+      return CreateMatrix(res);
+    }
 
-export function SumM2(matrix: number[][]): number {
-  return matrix.map(m => m.reduce((p, c) => p + c)).reduce((p, c) => p + c);
-}
+    if (!isSameSize(matrix)) {
+      throw new Error("Cannot operate two matrix with different dimensions.");
+    }
 
-export function SumAxis0M2(matrix: number[][]): number[] {
-  return matrix.map(m => m.reduce((p, c) => p + c));
-}
+    const val: number[][] = matrix.val();
+    const res = matrixsInstance.map((x, i) => x.map((y, k) => y + val[i][k]));
+    return CreateMatrix(res);
+  }
 
-export function DotDivideM2Scalar(matrix2: number[], scalar: number): number[] {
-  return matrix2.map(m2 => m2 / scalar);
-}
+  function subtract(matrix: number | Models.Matrix): Models.Matrix {
+    if (typeof matrix === "number") {
+      const res = matrixsInstance.map((x: number[]) => x.map(y => (y - matrix) as number));
+      return CreateMatrix(res);
+    }
 
-export function DotDivideScalarM1(scalar: number, matrix: number[]): number[] {
-  return matrix.map(m => scalar / m);
-}
+    if (!isSameSize(matrix)) {
+      throw new Error("Cannot operate two matrix with different dimensions.");
+    }
 
-export function SquareM1(matrix: number[]): number[] {
-  return matrix.map((m, i) => matrix[i] * matrix[i]);
-}
+    const val: number[][] = matrix.val();
+    const res = matrixsInstance.map((x, i) => x.map((y, k) => y - val[i][k]));
+    return CreateMatrix(res);
+  }
 
-export function SubtractM2Scalar(matrix1: number[][], scalar: number): number[][] {
-  return matrix1.map(m1 => m1.map((m2, i) => m2 - scalar));
-}
+  function isSameSize(matrix: Models.Matrix): boolean {
+    const val: number[][] = matrix.val();
+    return matrixsInstance.length === val.length && matrixsInstance[0].length === val[0].length;
+  }
 
-export function SubtractM1Scalar(matrix1: number[], scalar: number): number[] {
-  return matrix1.map(m => m - scalar);
-}
+  function multiply(matrix: number | Models.Matrix): Models.Matrix {
+    if (typeof matrix === "number") {
+      const result = CreateMatrix(matrixsInstance).val();
+      for (let i = 0, li = result.length; i < li; i += 1) {
+        for (let j = 0, lj = result[0].length; j < lj; j += 1) {
+          result[i][j] *= matrix as number;
+        }
+      }
+      return CreateMatrix(matrixsInstance);
+    }
 
-export function SubtracScalarM1(scalar: number, matrix1: number[]): number[] {
-  return matrix1.map(m => scalar - m);
-}
+    let inputElements: number[][] = matrix.val();
+    if (matrixsInstance[0].length !== inputElements.length) {
+      throw new Error("Number of rows of A should match number of cols of B.");
+    }
 
-export function SubtractM1M1(matrix1: number[], matrix2: number[]): number[] {
-  if (matrix1.length === matrix2.length) {
-    return matrix1.map((m, i) => matrix1[i] - matrix2[i]);
-  } else {
-    if (matrix1.length < matrix2.length) {
-      return matrix2.map((m, i) => matrix1[0] - matrix2[i]);
-    } else {
-      return matrix1.map((m, i) => matrix1[i] - matrix2[0]);
+    const li = matrixsInstance.length;
+    const lj = inputElements[0].length;
+    const lk = matrixsInstance[0].length - 1;
+    const result = [];
+    for (let i = 0; i < li; i += 1) {
+      const currentRow = [];
+      for (let j = 0; j < lj; j += 1) {
+        let sum = 0;
+        for (let k = lk; k >= 0; k -= 1) {
+          sum += matrixsInstance[i][k] * inputElements[k][j];
+        }
+        currentRow[j] = sum;
+      }
+      result[i] = currentRow;
     }
-  }
-}
 
-export function DotscalarM2(scalar: number, matrix2: number[][]): number[][] {
-  return matrix2.map(m2 => m2.map((m3, i) => m3 * scalar));
-}
+    return CreateMatrix(result);
+  }
 
-export function DotM2M1(matrix1: number[][], matrix2: number[]): number[] {
-  const res = matrix1.map(m1 => m1.map((m2, i) => m2 * matrix2[i]));
-  return res.map(m1 => m1.reduce((p, c) => p + c));
+  return {
+    val,
+    multiply,
+    isSameSize,
+    subtract,
+    row,
+    column,
+    log,
+    add,
+  };
 }

lib/neural-network.spec.ts

@@ -42,7 +42,7 @@ test("Loss", () => {
 
 test("Accuracy", () => {
   const x = [[1, 1, 1, 1]];
-  const y = [[1, 1, 1, 1]];
+  const y = [1, 1, 1, 1];
   const w = [0.1, 0.1, 0.1, 0.1];
   const b = 0.1;
   const res = nn.Accuracy(x, y, w, b);

lib/neural-network.ts

@@ -1,4 +1,4 @@
-import * as matrx from "./matrix";
+import * as matrx from "./math";
 
 export interface UpdateResult {
   w: number[];

lib/vactor.ts

@@ -0,0 +1,92 @@
+import * as Models from "../models";
+import * as Matrix from "./matrix";
+
+export function CreateArray(num: number, v: number): number[] {
+  const result = [];
+  for (let i = 0; i < num; i += 1) {
+    result.push(v);
+  }
+  return result;
+}
+
+export function Zero(num: number): Models.Vector {
+  return CreateVector(CreateArray(num, 0));
+}
+
+export function CreateVector(v: number[]): Models.Vector {
+  let vectorInstance: number[];
+  vectorInstance = v;
+
+  function val(): number[] {
+    return vectorInstance;
+  }
+
+  function size(): number {
+    return vectorInstance.length;
+  }
+
+  function log(): number[] {
+    return vectorInstance.map(v => Math.log(v));
+  }
+
+  function subtract(value: number | Models.Vector): Models.Vector {
+    const vector = [];
+    if (typeof value === "number") {
+      for (let i = 0, li = vectorInstance.length; i < li; i += 1) {
+        vector.push(vectorInstance[i] - value);
+      }
+    } else {
+      const values: number[] = value.val();
+      if (vectorInstance.length !== values.length) {
+        throw new Error("Cannot operate two vectors with different dimensions.");
+      }
+      for (let i = 0, li = vectorInstance.length; i < li; i += 1) {
+        vector.push(vectorInstance[i] - values[i]);
+      }
+    }
+    return CreateVector(vector);
+  }
+
+  function sum(): number {
+    return vectorInstance.reduce((p, c) => p + c);
+  }
+
+  function multiply(values: number[]): Models.Vector {
+    const vector = [];
+    for (let i = 0, li = vectorInstance.length; i < li; i += 1) {
+      vector.push(vectorInstance[i] * values[i]);
+    }
+    return CreateVector(vector);
+  }
+
+  function dot(values: number[]): number {
+    if (vectorInstance.length !== values.length) {
+      throw new Error("Cannot operate two vectors with different dimensions.");
+    }
+    let product = 0;
+    for (let i = 0; i < values.length; i += 1) {
+      product += vectorInstance[i] * values[i];
+    }
+    return product;
+  }
+
+  function map(fn: (v: number) => number): Models.Vector {
+    return CreateVector(vectorInstance.map(x => fn(x)));
+  }
+
+  function matrix(): Models.Matrix {
+    return Matrix.CreateMatrix([vectorInstance]);
+  }
+
+  return {
+    val,
+    size,
+    log,
+    subtract,
+    sum,
+    multiply,
+    dot,
+    map,
+    matrix,
+  };
+}