@smockle/matrix 4.0.0 → 4.0.1

package/.github/workflows/publish.yml

@@ -25,6 +25,7 @@ jobs:
           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 }}

package/.github/workflows/test.yml

@@ -22,6 +22,7 @@ jobs:
           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

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

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

package/dist/__tests__/index.test.js

@@ -0,0 +1,355 @@
+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/dist/index.d.ts

@@ -0,0 +1,30 @@
+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
+ */
+declare function Matrix(x: number | (number | number[])[]): Matrix;
+declare namespace Matrix {
+    var addable: (x: Matrix, y: Matrix) => boolean;
+    var add: (x: Matrix, y: Matrix) => Matrix;
+    var multipliable: (x: Matrix, y: Matrix) => boolean;
+    var multiply: (x: Matrix, y: Matrix) => Matrix;
+    var invert: (x: Matrix) => Matrix;
+}
+export default Matrix;

package/dist/index.js

@@ -0,0 +1,230 @@
+import { fill, padStart, unzip } from "lodash";
+import { inv } from "mathjs";
+/**
+ * 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) {
+    // 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].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, y) {
+    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, y) {
+    if (!Matrix.addable(x, y))
+        throw new TypeError("Matrices are not addable");
+    return x.map((row, i) => row.map((column, j) => column + y.__value[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, y) {
+    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, y, i) {
+    const _x = x.__value;
+    const _y = Array.isArray(unzip(y.__value)) &&
+        unzip(y.__value).length === 0
+        ? unzip([y.__value])[i]
+        : unzip(y.__value)[i];
+    return []
+        .concat(_x)
+        .reduce((z, _z, j) => 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, y) {
+    if (!Matrix.multipliable(x, y)) {
+        throw new TypeError("Matrices are not multipliable");
+    }
+    if (x.countColumns() === 0 && y.countRows() === 0) {
+        return Matrix(x.__value * y.__value);
+    }
+    /* New matrix with the dot product */
+    const z = Matrix(fill(Array(x.countRows()), x.countRows() !== 1 ? fill(Array(y.countColumns()), 0) : 0));
+    return z.map((_z, i) => {
+        if (typeof _z === "number")
+            return innerproduct(x, y, i);
+        return _z.map((_, j) => innerproduct(Matrix(x.__value[i]), y, j));
+    });
+};
+/**
+ * Inverts a matrix
+ * @alias module:matrix.invert
+ * @param  {x} Matrix to invert
+ * @return {Matrix} Matrix inverse
+ */
+Matrix.invert = function (x) {
+    return Matrix(inv(x instanceof Matrix ? x.__value : x));
+};
+/**
+ * Counts rows in this matrix
+ * @alias module:matrix#countRows
+ * @return {number} Number of rows
+ */
+Matrix.prototype.countRows = function () {
+    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 () {
+    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 (y) {
+    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 (y) {
+    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 (y) {
+    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 (y) {
+    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 () {
+    switch (this.countRows()) {
+        case 0:
+            return Matrix(this.__value);
+        case 1:
+            return Matrix(unzip([this.__value]));
+        default:
+            return Matrix(unzip(this.__value));
+    }
+};
+/**
+ * Inverts this matrix
+ * @alias module:matrix#invert
+ * @return {Matrix} Matrix inverse
+ */
+Matrix.prototype.invert = function () {
+    return Matrix.invert(this);
+};
+/**
+ * Maps over this matrix
+ * @alias module:matrix#map
+ * @return {Matrix} Matrix inverse
+ */
+Matrix.prototype.map = function (x) {
+    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 () {
+    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 () {
+    switch (this.countRows()) {
+        case 0:
+            return `${this.__value}`;
+        case 1:
+            return `[ ${this.__value.join(" ")} ]`;
+        default:
+            /* Output array filled with zeroes */
+            const padding = unzip(this.__value).map((column) => column.reduce((length, x) => Math.max(`${x}`.length, length), 0));
+            return this.__value
+                .reduce((output, row) => `${output}[ ${row
+                .map((x, i) => padStart(`${x}`, padding[i]))
+                .join(" ")} ]`, "")
+                .replace(/]\[/g, "]\n[");
+    }
+};
+export default Matrix;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smockle/matrix",
-  "version": "4.0.0",
+  "version": "4.0.1",
   "description": "Single and multi dimensional matrices and matrix functions.",
   "type": "module",
   "main": "dist/index.js",

package/src/index.ts

@@ -1,4 +1,4 @@
-import { fill, flattenDeep, invert, padStart, unzip } from "lodash";
+import { fill, padStart, unzip } from "lodash";
 import { inv } from "mathjs";
 
 type Matrix = {