@smockle/matrix 4.0.1 → 4.0.3

package/dist/index.js

@@ -1,4 +1,4 @@
-import { fill, padStart, unzip } from "lodash";
+import { fill, padStart, unzip } from "lodash-es";
 import { inv } from "mathjs";
 /**
  * Creates a Matrix

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@smockle/matrix",
-  "version": "4.0.1",
+  "version": "4.0.3",
   "description": "Single and multi dimensional matrices and matrix functions.",
   "type": "module",
   "main": "dist/index.js",
   "scripts": {
     "build": "tsc",
-    "test": "jest"
+    "test": "NODE_OPTIONS='--no-warnings=ExperimentalWarning --experimental-vm-modules' npx jest"
   },
   "repository": {
     "type": "git",
@@ -19,11 +19,11 @@
   },
   "homepage": "https://github.com/smockle/matrix#readme",
   "dependencies": {
-    "lodash": "^4.17.4",
+    "lodash-es": "^4.17.21",
     "mathjs": "^14.0.1"
   },
   "devDependencies": {
-    "@types/lodash": "^4.17.14",
+    "@types/lodash-es": "^4.17.12",
     "jest": "^29.7.0",
     "ts-jest": "^29.1.1",
     "typescript": "^5.2.2"

package/.github/CODEOWNERS

@@ -1 +0,0 @@
-* @smockle

package/.github/workflows/publish.yml

@@ -1,34 +0,0 @@
-name: Publish
-
-on:
-  release:
-    types: [created]
-
-permissions:
-  contents: read
-  id-token: write
-
-jobs:
-  test:
-    name: Test
-    uses: smockle/matrix/.github/workflows/test.yml@main
-    secrets: inherit
-  publish:
-    needs: [test]
-    name: Publish
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 22
-          registry-url: https://registry.npmjs.org/
-          cache: npm
-      - run: npm ci
-      - run: npm run build
-      - run: npm version ${TAG_NAME} --git-tag-version=false
-        env:
-          TAG_NAME: ${{ github.event.release.tag_name }}
-      - run: npm whoami; npm --ignore-scripts publish --provenance --access public
-        env:
-          NODE_AUTH_TOKEN: ${{secrets.NPM_TOKEN}}

package/.github/workflows/test.yml

@@ -1,31 +0,0 @@
-name: Test
-
-on:
-  workflow_call:
-    secrets:
-      CODECOV_TOKEN:
-        required: true
-  pull_request:
-
-permissions:
-  contents: read
-
-jobs:
-  test:
-    name: Test
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 22
-          registry-url: https://registry.npmjs.org/
-          cache: npm
-      - run: npm ci
-      - run: npm run build
-      - run: npm test
-      - if: github.actor != 'dependabot[bot]'
-        name: Upload coverage reports to Codecov
-        uses: codecov/codecov-action@v5
-        with:
-          token: ${{ secrets.CODECOV_TOKEN }}

package/dist/__tests__/index.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/__tests__/index.test.js

@@ -1,355 +0,0 @@
-import { inspect } from "node:util";
-import { describe, test, expect } from "@jest/globals";
-import Matrix from "../index.js";
-describe("Matrix", () => {
-    const error = new TypeError("Matrix must be a number or array of numbers");
-    test("instanceof Matrix", () => {
-        expect(Matrix([])).toBeInstanceOf(Matrix);
-    });
-    test("throws unnecessary nesting", () => {
-        expect(Matrix.bind(Matrix, [[1, 2]])).toThrowError(error);
-    });
-    test("throws uneven rows", () => {
-        expect(Matrix.bind(Matrix, [[1, 2], [3], [4, 5]])).toThrowError(error);
-    });
-    test("does not throw number", () => {
-        expect(Matrix.bind(Matrix, 1)).not.toThrowError(error);
-    });
-    test("does not throw number array", () => {
-        expect(Matrix.bind(Matrix, [1])).not.toThrowError(error);
-    });
-    test("does not throw 2D number array", () => {
-        expect(Matrix.bind(Matrix, [[1], [2]])).not.toThrowError(error);
-    });
-});
-describe("Matrix.addable", () => {
-    test("addable mismatched columns", () => {
-        expect(Matrix.addable(Matrix([
-            [1, 2],
-            [3, 4],
-        ]), Matrix([
-            [1, 2, 3],
-            [4, 5, 6],
-        ]))).toBeFalsy();
-    });
-    test("addable mismatched rows", () => {
-        expect(Matrix.addable(Matrix([
-            [1, 2],
-            [3, 4],
-        ]), Matrix([
-            [1, 2],
-            [4, 5],
-            [7, 8],
-        ]))).toBeFalsy();
-    });
-    test("addable", () => {
-        expect(Matrix.addable(Matrix([
-            [1, 2],
-            [3, 4],
-        ]), Matrix([
-            [5, 6],
-            [7, 8],
-        ]))).toBeTruthy();
-    });
-});
-describe("Matrix#addable", () => {
-    test("addable mismatched columns", () => {
-        expect(Matrix([
-            [1, 2],
-            [3, 4],
-        ]).addable(Matrix([
-            [1, 2, 3],
-            [4, 5, 6],
-        ]))).toBeFalsy();
-    });
-    test("addable mismatched rows", () => {
-        expect(Matrix([
-            [1, 2],
-            [3, 4],
-        ]).addable(Matrix([
-            [1, 2],
-            [4, 5],
-            [7, 8],
-        ]))).toBeFalsy();
-    });
-    test("addable", () => {
-        expect(Matrix([
-            [1, 2],
-            [3, 4],
-        ]).addable(Matrix([
-            [5, 6],
-            [7, 8],
-        ]))).toBeTruthy();
-    });
-});
-describe("Matrix.add", () => {
-    test("add throws typerror", () => {
-        expect(Matrix.add.bind(Matrix, Matrix([
-            [1, 2],
-            [3, 4],
-        ]), Matrix([
-            [1, 2, 3],
-            [4, 5, 6],
-        ]))).toThrowError(new TypeError("Matrices are not addable"));
-    });
-    test("add", () => {
-        expect(Matrix.add(Matrix([
-            [1, 2],
-            [3, 4],
-        ]), Matrix([
-            [5, 6],
-            [7, 8],
-        ]))).toStrictEqual(Matrix([
-            [6, 8],
-            [10, 12],
-        ]));
-    });
-});
-describe("Matrix#add", () => {
-    const addmatrix = Matrix([
-        [1, 2],
-        [3, 4],
-    ]);
-    test("add throws typerror", () => {
-        expect(addmatrix.add.bind(addmatrix, Matrix([
-            [1, 2, 3],
-            [4, 5, 6],
-        ]))).toThrowError(new TypeError("Matrices are not addable"));
-    });
-    test("add", () => {
-        expect(Matrix([
-            [1, 2],
-            [3, 4],
-        ]).add(Matrix([
-            [5, 6],
-            [7, 8],
-        ]))).toStrictEqual(Matrix([
-            [6, 8],
-            [10, 12],
-        ]));
-    });
-});
-describe("Matrix.multipliable", () => {
-    test("multipliable mismatched columns and rows", () => {
-        expect(Matrix.multipliable(Matrix([
-            [1, 2, 3],
-            [4, 5, 6],
-        ]), Matrix([
-            [1, 2],
-            [4, 5],
-        ]))).toBeFalsy();
-    });
-    test("multipliable", () => {
-        expect(Matrix.multipliable(Matrix([
-            [1, 2],
-            [3, 4],
-        ]), Matrix([
-            [5, 6],
-            [7, 8],
-        ]))).toBeTruthy();
-    });
-});
-describe("Matrix#multipliable", () => {
-    test("multipliable mismatched columns and rows", () => {
-        expect(Matrix([
-            [1, 2, 3],
-            [4, 5, 6],
-        ]).multipliable(Matrix([
-            [1, 2],
-            [4, 5],
-        ]))).toBeFalsy();
-    });
-    test("multipliable", () => {
-        expect(Matrix([
-            [1, 2],
-            [3, 4],
-        ]).multipliable(Matrix([
-            [5, 6],
-            [7, 8],
-        ]))).toBeTruthy();
-    });
-});
-describe("Matrix.multiply", () => {
-    const multiplymatrix = Matrix([1, 2, 3]);
-    test("multiply throws typerror", () => {
-        expect(multiplymatrix.multiply.bind(multiplymatrix, Matrix([
-            [1, 2],
-            [3, 4],
-        ]))).toThrowError(new TypeError("Matrices are not multipliable"));
-    });
-    test("multiply number", () => {
-        expect(Matrix(3).multiply(Matrix(6))).toStrictEqual(Matrix(18));
-    });
-    test("multiply A (1x2) and B (2x1)", () => {
-        expect(Matrix([1, 2]).multiply(Matrix([[3], [4]]))).toStrictEqual(Matrix([11]));
-    });
-    test("multiply A (2x2) and B (2x2)", () => {
-        expect(Matrix([
-            [1, 2],
-            [3, 4],
-        ]).multiply(Matrix([
-            [5, 6],
-            [7, 8],
-        ]))).toStrictEqual(Matrix([
-            [19, 22],
-            [43, 50],
-        ]));
-    });
-    test("multiply A (2x3) and B (3x2)", () => {
-        expect(Matrix([
-            [1, 9, 7],
-            [8, 1, 2],
-        ]).multiply(Matrix([
-            [3, 2, 1, 5],
-            [5, 4, 7, 3],
-            [6, 9, 6, 8],
-        ]))).toStrictEqual(Matrix([
-            [90, 101, 106, 88],
-            [41, 38, 27, 59],
-        ]));
-    });
-});
-describe("Matrix#multiply", () => {
-    test("multiply throws typerror", () => {
-        expect(Matrix.multiply.bind(Matrix, Matrix([1, 2, 3]), Matrix([
-            [1, 2],
-            [3, 4],
-        ]))).toThrowError(new TypeError("Matrices are not multipliable"));
-    });
-    test("multiply number", () => {
-        expect(Matrix.multiply(Matrix(3), Matrix(6))).toStrictEqual(Matrix(18));
-    });
-    test("multiply A (1x2) and B (2x1)", () => {
-        expect(Matrix.multiply(Matrix([1, 2]), Matrix([[3], [4]]))).toStrictEqual(Matrix([11]));
-    });
-    test("multiply A (2x2) and B (2x2)", () => {
-        expect(Matrix.multiply(Matrix([
-            [1, 2],
-            [3, 4],
-        ]), Matrix([
-            [5, 6],
-            [7, 8],
-        ]))).toStrictEqual(Matrix([
-            [19, 22],
-            [43, 50],
-        ]));
-    });
-    test("multiply A (2x3) and B (3x2)", () => {
-        expect(Matrix.multiply(Matrix([
-            [1, 9, 7],
-            [8, 1, 2],
-        ]), Matrix([
-            [3, 2, 1, 5],
-            [5, 4, 7, 3],
-            [6, 9, 6, 8],
-        ]))).toStrictEqual(Matrix([
-            [90, 101, 106, 88],
-            [41, 38, 27, 59],
-        ]));
-    });
-});
-describe("Matrix#valueOf", () => {
-    const array = [3];
-    test("valueOf Matrix", () => {
-        expect(Matrix(array).valueOf()).toBe(array);
-    });
-});
-describe("Matrix#countRows", () => {
-    test("countRows number", () => {
-        expect(Matrix(1).countRows()).toBe(0);
-    });
-    test("countRows number array", () => {
-        expect(Matrix([1]).countRows()).toBe(1);
-    });
-    test("countRows 2D number array", () => {
-        expect(Matrix([
-            [1, 2],
-            [3, 4],
-            [5, 6],
-        ]).countRows()).toBe(3);
-    });
-});
-describe("Matrix#countColumns", () => {
-    test("countColumns number", () => {
-        expect(Matrix(1).countColumns()).toBe(0);
-    });
-    test("countColumns number array", () => {
-        expect(Matrix([1]).countColumns()).toBe(1);
-    });
-    test("countColumns 2D number array", () => {
-        expect(Matrix([[1], [2]]).countColumns()).toBe(1);
-    });
-    test("countColumns many 2D number array", () => {
-        expect(Matrix([
-            [1, 2],
-            [3, 4],
-            [5, 6],
-        ]).countColumns()).toBe(2);
-    });
-});
-describe("Matrix#transpose", () => {
-    test("transpose number", () => {
-        expect(Matrix(1).transpose()).toStrictEqual(Matrix(1));
-    });
-    test("transpose number array", () => {
-        expect(Matrix([1, 2]).transpose()).toStrictEqual(Matrix([[1], [2]]));
-    });
-    test("transpose 2D number array", () => {
-        expect(Matrix([
-            [1, 2, 3],
-            [4, 5, 6],
-        ]).transpose()).toStrictEqual(Matrix([
-            [1, 4],
-            [2, 5],
-            [3, 6],
-        ]));
-    });
-});
-describe("Matrix#invert", () => {
-    test("invert 2D number array", () => {
-        expect(Matrix([
-            [1, 2],
-            [3, 4],
-        ]).invert()).toStrictEqual(Matrix([
-            [-2, 1],
-            [1.5, -0.5],
-        ]));
-    });
-});
-describe("Matrix#map", () => {
-    const matrix = Matrix([1, 2, 3]);
-    test("map returns a matrix", () => {
-        expect(matrix.map((x) => x + 1)).toBeInstanceOf(Matrix);
-    });
-    test("map identity", () => {
-        expect(matrix.map((x) => x)).toStrictEqual(matrix);
-    });
-    test("map increment", () => {
-        expect(matrix.map((x) => x + 1)).toStrictEqual(Matrix([2, 3, 4]));
-    });
-    test("map non-mutable", () => {
-        expect(matrix).toStrictEqual(Matrix([1, 2, 3]));
-    });
-});
-describe("Matrix#inspect", () => {
-    test("inspect number", () => {
-        expect(inspect(Matrix(3))).toBe("3");
-    });
-    test("inspect number array", () => {
-        expect(inspect(Matrix([1, 2, 3]))).toBe("[ 1 2 3 ]");
-    });
-    test("inspect 2D number array", () => {
-        expect(inspect(Matrix([
-            [1, 2, 3],
-            [4, 5, 6],
-            [7, 8, 9],
-        ]))).toBe("[ 1 2 3 ]\n[ 4 5 6 ]\n[ 7 8 9 ]");
-    });
-    test("inspect padded 2D number array", () => {
-        expect(inspect(Matrix([
-            [1, 2, 3],
-            [-10, 11, -12],
-            [100, 0, 0],
-        ]))).toBe("[   1  2   3 ]\n[ -10 11 -12 ]\n[ 100  0   0 ]");
-    });
-});

package/src/__tests__/index.test.ts

@@ -1,540 +0,0 @@
-import { inspect } from "node:util";
-import { describe, test, expect } from "@jest/globals";
-import Matrix from "../index.js";
-
-describe("Matrix", () => {
-  const error = new TypeError("Matrix must be a number or array of numbers");
-
-  test("instanceof Matrix", () => {
-    expect(Matrix([])).toBeInstanceOf(Matrix);
-  });
-
-  test("throws unnecessary nesting", () => {
-    expect(Matrix.bind(Matrix, [[1, 2]])).toThrowError(error);
-  });
-
-  test("throws uneven rows", () => {
-    expect(Matrix.bind(Matrix, [[1, 2], [3], [4, 5]])).toThrowError(error);
-  });
-
-  test("does not throw number", () => {
-    expect(Matrix.bind(Matrix, 1)).not.toThrowError(error);
-  });
-
-  test("does not throw number array", () => {
-    expect(Matrix.bind(Matrix, [1])).not.toThrowError(error);
-  });
-
-  test("does not throw 2D number array", () => {
-    expect(Matrix.bind(Matrix, [[1], [2]])).not.toThrowError(error);
-  });
-});
-
-describe("Matrix.addable", () => {
-  test("addable mismatched columns", () => {
-    expect(
-      Matrix.addable(
-        Matrix([
-          [1, 2],
-          [3, 4],
-        ]),
-        Matrix([
-          [1, 2, 3],
-          [4, 5, 6],
-        ])
-      )
-    ).toBeFalsy();
-  });
-
-  test("addable mismatched rows", () => {
-    expect(
-      Matrix.addable(
-        Matrix([
-          [1, 2],
-          [3, 4],
-        ]),
-        Matrix([
-          [1, 2],
-          [4, 5],
-          [7, 8],
-        ])
-      )
-    ).toBeFalsy();
-  });
-
-  test("addable", () => {
-    expect(
-      Matrix.addable(
-        Matrix([
-          [1, 2],
-          [3, 4],
-        ]),
-        Matrix([
-          [5, 6],
-          [7, 8],
-        ])
-      )
-    ).toBeTruthy();
-  });
-});
-
-describe("Matrix#addable", () => {
-  test("addable mismatched columns", () => {
-    expect(
-      Matrix([
-        [1, 2],
-        [3, 4],
-      ]).addable(
-        Matrix([
-          [1, 2, 3],
-          [4, 5, 6],
-        ])
-      )
-    ).toBeFalsy();
-  });
-
-  test("addable mismatched rows", () => {
-    expect(
-      Matrix([
-        [1, 2],
-        [3, 4],
-      ]).addable(
-        Matrix([
-          [1, 2],
-          [4, 5],
-          [7, 8],
-        ])
-      )
-    ).toBeFalsy();
-  });
-
-  test("addable", () => {
-    expect(
-      Matrix([
-        [1, 2],
-        [3, 4],
-      ]).addable(
-        Matrix([
-          [5, 6],
-          [7, 8],
-        ])
-      )
-    ).toBeTruthy();
-  });
-});
-
-describe("Matrix.add", () => {
-  test("add throws typerror", () => {
-    expect(
-      Matrix.add.bind(
-        Matrix,
-        Matrix([
-          [1, 2],
-          [3, 4],
-        ]),
-        Matrix([
-          [1, 2, 3],
-          [4, 5, 6],
-        ])
-      )
-    ).toThrowError(new TypeError("Matrices are not addable"));
-  });
-
-  test("add", () => {
-    expect(
-      Matrix.add(
-        Matrix([
-          [1, 2],
-          [3, 4],
-        ]),
-        Matrix([
-          [5, 6],
-          [7, 8],
-        ])
-      )
-    ).toStrictEqual(
-      Matrix([
-        [6, 8],
-        [10, 12],
-      ])
-    );
-  });
-});
-
-describe("Matrix#add", () => {
-  const addmatrix = Matrix([
-    [1, 2],
-    [3, 4],
-  ]);
-
-  test("add throws typerror", () => {
-    expect(
-      addmatrix.add.bind(
-        addmatrix,
-        Matrix([
-          [1, 2, 3],
-          [4, 5, 6],
-        ])
-      )
-    ).toThrowError(new TypeError("Matrices are not addable"));
-  });
-
-  test("add", () => {
-    expect(
-      Matrix([
-        [1, 2],
-        [3, 4],
-      ]).add(
-        Matrix([
-          [5, 6],
-          [7, 8],
-        ])
-      )
-    ).toStrictEqual(
-      Matrix([
-        [6, 8],
-        [10, 12],
-      ])
-    );
-  });
-});
-
-describe("Matrix.multipliable", () => {
-  test("multipliable mismatched columns and rows", () => {
-    expect(
-      Matrix.multipliable(
-        Matrix([
-          [1, 2, 3],
-          [4, 5, 6],
-        ]),
-        Matrix([
-          [1, 2],
-          [4, 5],
-        ])
-      )
-    ).toBeFalsy();
-  });
-
-  test("multipliable", () => {
-    expect(
-      Matrix.multipliable(
-        Matrix([
-          [1, 2],
-          [3, 4],
-        ]),
-        Matrix([
-          [5, 6],
-          [7, 8],
-        ])
-      )
-    ).toBeTruthy();
-  });
-});
-
-describe("Matrix#multipliable", () => {
-  test("multipliable mismatched columns and rows", () => {
-    expect(
-      Matrix([
-        [1, 2, 3],
-        [4, 5, 6],
-      ]).multipliable(
-        Matrix([
-          [1, 2],
-          [4, 5],
-        ])
-      )
-    ).toBeFalsy();
-  });
-
-  test("multipliable", () => {
-    expect(
-      Matrix([
-        [1, 2],
-        [3, 4],
-      ]).multipliable(
-        Matrix([
-          [5, 6],
-          [7, 8],
-        ])
-      )
-    ).toBeTruthy();
-  });
-});
-
-describe("Matrix.multiply", () => {
-  const multiplymatrix = Matrix([1, 2, 3]);
-
-  test("multiply throws typerror", () => {
-    expect(
-      multiplymatrix.multiply.bind(
-        multiplymatrix,
-        Matrix([
-          [1, 2],
-          [3, 4],
-        ])
-      )
-    ).toThrowError(new TypeError("Matrices are not multipliable"));
-  });
-
-  test("multiply number", () => {
-    expect(Matrix(3).multiply(Matrix(6))).toStrictEqual(Matrix(18));
-  });
-
-  test("multiply A (1x2) and B (2x1)", () => {
-    expect(Matrix([1, 2]).multiply(Matrix([[3], [4]]))).toStrictEqual(
-      Matrix([11])
-    );
-  });
-
-  test("multiply A (2x2) and B (2x2)", () => {
-    expect(
-      Matrix([
-        [1, 2],
-        [3, 4],
-      ]).multiply(
-        Matrix([
-          [5, 6],
-          [7, 8],
-        ])
-      )
-    ).toStrictEqual(
-      Matrix([
-        [19, 22],
-        [43, 50],
-      ])
-    );
-  });
-
-  test("multiply A (2x3) and B (3x2)", () => {
-    expect(
-      Matrix([
-        [1, 9, 7],
-        [8, 1, 2],
-      ]).multiply(
-        Matrix([
-          [3, 2, 1, 5],
-          [5, 4, 7, 3],
-          [6, 9, 6, 8],
-        ])
-      )
-    ).toStrictEqual(
-      Matrix([
-        [90, 101, 106, 88],
-        [41, 38, 27, 59],
-      ])
-    );
-  });
-});
-
-describe("Matrix#multiply", () => {
-  test("multiply throws typerror", () => {
-    expect(
-      Matrix.multiply.bind(
-        Matrix,
-        Matrix([1, 2, 3]),
-        Matrix([
-          [1, 2],
-          [3, 4],
-        ])
-      )
-    ).toThrowError(new TypeError("Matrices are not multipliable"));
-  });
-
-  test("multiply number", () => {
-    expect(Matrix.multiply(Matrix(3), Matrix(6))).toStrictEqual(Matrix(18));
-  });
-
-  test("multiply A (1x2) and B (2x1)", () => {
-    expect(Matrix.multiply(Matrix([1, 2]), Matrix([[3], [4]]))).toStrictEqual(
-      Matrix([11])
-    );
-  });
-
-  test("multiply A (2x2) and B (2x2)", () => {
-    expect(
-      Matrix.multiply(
-        Matrix([
-          [1, 2],
-          [3, 4],
-        ]),
-        Matrix([
-          [5, 6],
-          [7, 8],
-        ])
-      )
-    ).toStrictEqual(
-      Matrix([
-        [19, 22],
-        [43, 50],
-      ])
-    );
-  });
-
-  test("multiply A (2x3) and B (3x2)", () => {
-    expect(
-      Matrix.multiply(
-        Matrix([
-          [1, 9, 7],
-          [8, 1, 2],
-        ]),
-        Matrix([
-          [3, 2, 1, 5],
-          [5, 4, 7, 3],
-          [6, 9, 6, 8],
-        ])
-      )
-    ).toStrictEqual(
-      Matrix([
-        [90, 101, 106, 88],
-        [41, 38, 27, 59],
-      ])
-    );
-  });
-});
-
-describe("Matrix#valueOf", () => {
-  const array = [3];
-
-  test("valueOf Matrix", () => {
-    expect(Matrix(array).valueOf()).toBe(array);
-  });
-});
-
-describe("Matrix#countRows", () => {
-  test("countRows number", () => {
-    expect(Matrix(1).countRows()).toBe(0);
-  });
-
-  test("countRows number array", () => {
-    expect(Matrix([1]).countRows()).toBe(1);
-  });
-
-  test("countRows 2D number array", () => {
-    expect(
-      Matrix([
-        [1, 2],
-        [3, 4],
-        [5, 6],
-      ]).countRows()
-    ).toBe(3);
-  });
-});
-
-describe("Matrix#countColumns", () => {
-  test("countColumns number", () => {
-    expect(Matrix(1).countColumns()).toBe(0);
-  });
-
-  test("countColumns number array", () => {
-    expect(Matrix([1]).countColumns()).toBe(1);
-  });
-
-  test("countColumns 2D number array", () => {
-    expect(Matrix([[1], [2]]).countColumns()).toBe(1);
-  });
-
-  test("countColumns many 2D number array", () => {
-    expect(
-      Matrix([
-        [1, 2],
-        [3, 4],
-        [5, 6],
-      ]).countColumns()
-    ).toBe(2);
-  });
-});
-
-describe("Matrix#transpose", () => {
-  test("transpose number", () => {
-    expect(Matrix(1).transpose()).toStrictEqual(Matrix(1));
-  });
-
-  test("transpose number array", () => {
-    expect(Matrix([1, 2]).transpose()).toStrictEqual(Matrix([[1], [2]]));
-  });
-
-  test("transpose 2D number array", () => {
-    expect(
-      Matrix([
-        [1, 2, 3],
-        [4, 5, 6],
-      ]).transpose()
-    ).toStrictEqual(
-      Matrix([
-        [1, 4],
-        [2, 5],
-        [3, 6],
-      ])
-    );
-  });
-});
-
-describe("Matrix#invert", () => {
-  test("invert 2D number array", () => {
-    expect(
-      Matrix([
-        [1, 2],
-        [3, 4],
-      ]).invert()
-    ).toStrictEqual(
-      Matrix([
-        [-2, 1],
-        [1.5, -0.5],
-      ])
-    );
-  });
-});
-
-describe("Matrix#map", () => {
-  const matrix = Matrix([1, 2, 3]);
-
-  test("map returns a matrix", () => {
-    expect(matrix.map((x: number) => x + 1)).toBeInstanceOf(Matrix);
-  });
-
-  test("map identity", () => {
-    expect(matrix.map((x: number) => x)).toStrictEqual(matrix);
-  });
-
-  test("map increment", () => {
-    expect(matrix.map((x: number) => x + 1)).toStrictEqual(Matrix([2, 3, 4]));
-  });
-
-  test("map non-mutable", () => {
-    expect(matrix).toStrictEqual(Matrix([1, 2, 3]));
-  });
-});
-
-describe("Matrix#inspect", () => {
-  test("inspect number", () => {
-    expect(inspect(Matrix(3))).toBe("3");
-  });
-
-  test("inspect number array", () => {
-    expect(inspect(Matrix([1, 2, 3]))).toBe("[ 1 2 3 ]");
-  });
-
-  test("inspect 2D number array", () => {
-    expect(
-      inspect(
-        Matrix([
-          [1, 2, 3],
-          [4, 5, 6],
-          [7, 8, 9],
-        ])
-      )
-    ).toBe("[ 1 2 3 ]\n[ 4 5 6 ]\n[ 7 8 9 ]");
-  });
-
-  test("inspect padded 2D number array", () => {
-    expect(
-      inspect(
-        Matrix([
-          [1, 2, 3],
-          [-10, 11, -12],
-          [100, 0, 0],
-        ])
-      )
-    ).toBe("[   1  2   3 ]\n[ -10 11 -12 ]\n[ 100  0   0 ]");
-  });
-});

package/src/index.ts

@@ -1,290 +0,0 @@
-import { fill, padStart, unzip } from "lodash";
-import { inv } from "mathjs";
-
-type Matrix = {
-  __value: number | (number | number[])[];
-  countRows: () => number;
-  countColumns: () => number;
-  addable: (y: Matrix) => boolean;
-  add: (y: Matrix) => Matrix;
-  multipliable: (y: Matrix) => boolean;
-  multiply: (y: Matrix) => Matrix;
-  transpose: () => Matrix;
-  invert: () => Matrix;
-  map: (x: any) => Matrix;
-  valueOf: () => number | (number | number[])[];
-};
-
-/**
- * Creates a Matrix
- * @constructor
- * @alias module:matrix
- * @param {number|(number | number[])[]} x - Values to store in matrix
- * @throws {TypeError} Argument x must be a number or number array
- * @return {Matrix} Single or multi dimensional matrix
- */
-function Matrix(x: number | (number | number[])[]): Matrix {
-  // extra nesting
-  if (Array.isArray(x) && Array.isArray(x[0]) && x.length === 1) {
-    throw new TypeError("Matrix must be a number or array of numbers");
-  }
-
-  // uneven rows
-  if (
-    Array.isArray(x) &&
-    Array.isArray(x[0]) &&
-    x.some(
-      (row) => Array.isArray(row) && row.length !== (x[0] as number[]).length
-    )
-  ) {
-    throw new TypeError("Matrix must be a number or array of numbers");
-  }
-
-  /* Single or multi dimensional matrix */
-  const matrix = Object.create(Matrix.prototype);
-  matrix.__value = x;
-  return matrix;
-}
-
-/**
- * Determines whether two matrices can be summed
- * @alias module:matrix.addable
- * @param  {Matrix} x - Matrix to check
- * @param  {Matrix} y - Matrix to check
- * @return {boolean} Whether two matrices can be summed (using matrix addition)
- */
-Matrix.addable = function (x: Matrix, y: Matrix): boolean {
-  return (
-    x.countRows() === y.countRows() && x.countColumns() === y.countColumns()
-  );
-};
-
-/**
- * Adds two matrices using matrix addition
- * @alias module:matrix.add
- * @param {Matrix} x - Matrix to add
- * @param {Matrix} y - Matrix to add
- * @throws {TypeError} Matrices are not addable
- * @return {Matrix} New matrix with the summation
- */
-Matrix.add = function (x: Matrix, y: Matrix): Matrix {
-  if (!Matrix.addable(x, y)) throw new TypeError("Matrices are not addable");
-  return x.map((row: number[], i: number): number[] =>
-    row.map(
-      (column: number, j: number): number =>
-        column + (y.__value as number[][])[i][j]
-    )
-  );
-};
-
-/**
- * Determines whether two matrices can be multiplied
- * @alias module:matrix.multipliable
- * @param  {Matrix} x - Matrix to check
- * @param  {Matrix} y - Matrix to check
- * @return {boolean} Whether two matrices can be summed (using matrix multiplication)
- */
-Matrix.multipliable = function (x: Matrix, y: Matrix): boolean {
-  return x.countColumns() === y.countRows();
-};
-
-/**
- * Calculates the inner product of two matrices
- * @param  {Matrix} x - Matrix to multiply
- * @param  {Matrix} y - Matrix to multiply
- * @param  {number} i - Column in matrix y to multiply
- * @return {number} Inner product of matrices
- */
-function innerproduct(x: Matrix, y: Matrix, i: number): number {
-  const _x: number[] = x.__value as number[];
-  const _y: number[] =
-    Array.isArray(unzip<number>(y.__value as number[][])) &&
-    unzip<number>(y.__value as number[][]).length === 0
-      ? unzip([y.__value as number[]])[i]
-      : unzip(y.__value as number[][])[i];
-  return ([] as number[])
-    .concat(_x)
-    .reduce((z: number, _z: number, j: number): number => z + _z * _y[j], 0);
-}
-
-/**
- * Calculates the dot product of two matrices
- * @alias module:matrix.multiply
- * @param  {Matrix} x - Matrix to multiply
- * @param  {Matrix} y - Matrix to multiply
- * @return {Matrix} New matrix with the dot product
- */
-Matrix.multiply = function (x: Matrix, y: Matrix): Matrix {
-  if (!Matrix.multipliable(x, y)) {
-    throw new TypeError("Matrices are not multipliable");
-  }
-
-  if (x.countColumns() === 0 && y.countRows() === 0) {
-    return Matrix((x.__value as number) * (y.__value as number));
-  }
-
-  /* New matrix with the dot product */
-  const z: Matrix = Matrix(
-    fill(
-      Array(x.countRows()),
-      x.countRows() !== 1 ? fill(Array(y.countColumns()), 0) : 0
-    )
-  );
-  return z.map((_z: number | number[], i: number): number | number[] => {
-    if (typeof _z === "number") return innerproduct(x, y, i);
-    return _z.map((_, j) =>
-      innerproduct(Matrix((x.__value as number[])[i]), y, j)
-    );
-  });
-};
-
-/**
- * Inverts a matrix
- * @alias module:matrix.invert
- * @param  {x} Matrix to invert
- * @return {Matrix} Matrix inverse
- */
-Matrix.invert = function (x: Matrix): Matrix {
-  return Matrix(inv<any>(x instanceof Matrix ? x.__value : x));
-};
-
-/**
- * Counts rows in this matrix
- * @alias module:matrix#countRows
- * @return {number} Number of rows
- */
-Matrix.prototype.countRows = function (this: Matrix): number {
-  if (typeof this.__value === "number") return 0;
-  if (typeof this.__value[0] === "number") return 1;
-  return this.__value.length;
-};
-
-/**
- * Counts columns in this matrix
- * @alias module:matrix#countColumns
- * @return {number} Number of columns
- */
-Matrix.prototype.countColumns = function (this: Matrix): number {
-  if (typeof this.__value === "number") return 0;
-  if (typeof this.__value[0] === "number") return this.__value.length;
-  return this.__value[0].length;
-};
-
-/**
- * Determines whether this matrix can be summed
- * @alias module:matrix#addable
- * @param  {Matrix} y - Matrix to check
- * @return {boolean} Whether this matrix can be summed (using matrix addition)
- */
-Matrix.prototype.addable = function (this: Matrix, y: Matrix): boolean {
-  return Matrix.addable(this, y);
-};
-
-/**
- * Adds this matrix using matrix addition
- * @alias module:matrix#add
- * @param {Matrix} y - Matrix to add
- * @return {Matrix} New matrix with the summation
- */
-Matrix.prototype.add = function (this: Matrix, y: Matrix): Matrix {
-  return Matrix.add(this, y);
-};
-
-/**
- * Determines whether this matrix can be multiplied
- * @alias module:matrix#multipliable
- * @param  {Matrix} y - Matrix to check
- * @return {boolean} Whether two matrices can be summed (using matrix multiplication)
- */
-Matrix.prototype.multipliable = function (this: Matrix, y: Matrix): boolean {
-  return Matrix.multipliable(this, y);
-};
-
-/**
- * Calculates the dot product of this matrix
- * @alias module:matrix#multiply
- * @param  {Matrix} y - Matrix to multiply
- * @return {Matrix} New matrix with the dot product
- */
-Matrix.prototype.multiply = function (this: Matrix, y: Matrix): Matrix {
-  return Matrix.multiply(this, y);
-};
-
-/**
- * Calculates the transpose of this matrix
- * @alias module:matrix#transpose
- * @return {Matrix} New matrix with the transpose
- */
-Matrix.prototype.transpose = function (this: Matrix): Matrix {
-  switch (this.countRows()) {
-    case 0:
-      return Matrix(this.__value as number);
-    case 1:
-      return Matrix(unzip([this.__value as number[]]));
-    default:
-      return Matrix(unzip(this.__value as number[][]));
-  }
-};
-
-/**
- * Inverts this matrix
- * @alias module:matrix#invert
- * @return {Matrix} Matrix inverse
- */
-Matrix.prototype.invert = function (this: Matrix): Matrix {
-  return Matrix.invert(this);
-};
-
-/**
- * Maps over this matrix
- * @alias module:matrix#map
- * @return {Matrix} Matrix inverse
- */
-Matrix.prototype.map = function (this: Matrix, x: any): Matrix {
-  if (typeof this.__value === "number") return Matrix(x(this.__value));
-  return Matrix(this.__value.map(x));
-};
-
-/**
- * Returns the number or number array value
- * @alias module:matrix#valueOf
- * @return {number|number[]} Number of number array value
- */
-Matrix.prototype.valueOf = function (
-  this: Matrix
-): number | (number | number[])[] {
-  return this.__value;
-};
-
-/**
- * Formats and prints the matrix value
- * @alias module:matrix#inspect
- * @return {string} Formatted matrix value
- */
-Matrix.prototype[Symbol.for("nodejs.util.inspect.custom")] = function (
-  this: Matrix
-): string {
-  switch (this.countRows()) {
-    case 0:
-      return `${this.__value}`;
-    case 1:
-      return `[ ${(this.__value as number[]).join(" ")} ]`;
-    default:
-      /* Output array filled with zeroes */
-      const padding: number[] = unzip(this.__value as number[][]).map(
-        (column: number[]) =>
-          column.reduce((length, x) => Math.max(`${x}`.length, length), 0)
-      );
-      return (this.__value as number[][])
-        .reduce(
-          (output, row) =>
-            `${output}[ ${row
-              .map((x, i) => padStart(`${x}`, padding[i]))
-              .join(" ")} ]`,
-          ""
-        )
-        .replace(/]\[/g, "]\n[");
-  }
-};
-
-export default Matrix;

package/tsconfig.json

@@ -1,17 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "esnext",
-    "module": "nodenext",
-    "moduleResolution": "nodenext",
-    "esModuleInterop": true,
-    "strict": true,
-    "rootDir": "src",
-    "outDir": "dist",
-    "composite": true,
-    "incremental": true
-  },
-  "include": ["src/**/*.ts"],
-  "ts-node": {
-    "esm": true
-  }
-}