@smockle/matrix 4.0.3 → 5.0.1

package/README.md

@@ -15,7 +15,7 @@ Run `npm install --save @smockle/matrix` to add `matrix` to your project.
 import Matrix from '@smockle/matrix'
 
 // 1x1 Matrix
-const m11 = Matrix(3)
+const m11 = Matrix([3])
 
 // 1x3 Matrix
 const m13 = Matrix([1, 2, 3])

package/dist/index.d.ts

@@ -1,30 +1,59 @@
-type Matrix = {
-    __value: number | (number | number[])[];
+interface IMatrix {
     countRows: () => number;
     countColumns: () => number;
     addable: (y: Matrix) => boolean;
-    add: (y: Matrix) => Matrix;
     multipliable: (y: Matrix) => boolean;
     multiply: (y: Matrix) => Matrix;
-    transpose: () => Matrix;
-    invert: () => Matrix;
+    transpose: () => Matrix2D;
     map: (x: any) => Matrix;
-    valueOf: () => number | (number | number[])[];
-};
+}
+export interface Matrix1D extends IMatrix {
+    __value: number[];
+    add: (y: Matrix1D) => Matrix1D;
+    invert: () => Matrix1D;
+    valueOf: () => number[];
+}
+export interface Matrix2D extends IMatrix {
+    __value: number[][];
+    add: (y: Matrix2D) => Matrix2D;
+    invert: () => Matrix2D;
+    valueOf: () => number[][];
+}
+type Matrix = Matrix1D | Matrix2D;
+export declare function isMatrix1D(matrix: Matrix): matrix is Matrix1D;
 /**
  * Creates a Matrix
  * @constructor
  * @alias module:matrix
- * @param {number|(number | number[])[]} x - Values to store in matrix
+ * @param {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 function Matrix(x: number[]): Matrix1D;
+declare function Matrix(x: number[][]): Matrix2D;
 declare namespace Matrix {
     var addable: (x: Matrix, y: Matrix) => boolean;
-    var add: (x: Matrix, y: Matrix) => Matrix;
+    var add: typeof Add;
     var multipliable: (x: Matrix, y: Matrix) => boolean;
     var multiply: (x: Matrix, y: Matrix) => Matrix;
-    var invert: (x: Matrix) => Matrix;
+    var invert: typeof Invert;
 }
+/**
+ * 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
+ */
+declare function Add(x: Matrix1D, y: Matrix1D): Matrix1D;
+declare function Add(x: Matrix2D, y: Matrix2D): Matrix2D;
+/**
+ * Inverts a matrix. Matrix must be a square (e.g. 1x1 or 2x2)
+ * @alias module:matrix.invert
+ * @param  {x} Matrix to invert
+ * @return {Matrix} Matrix inverse
+ */
+declare function Invert(x: Matrix1D): Matrix1D;
+declare function Invert(x: Matrix2D): Matrix2D;
 export default Matrix;

package/dist/index.js

@@ -1,22 +1,17 @@
 import { fill, padStart, unzip } from "lodash-es";
 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
- */
+export function isMatrix1D(matrix) {
+    return matrix.countRows() === 1;
+}
 function Matrix(x) {
     // extra nesting
-    if (Array.isArray(x) && Array.isArray(x[0]) && x.length === 1) {
+    if (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)) {
+    const firstRowLength = Array.isArray(x[0]) ? x[0].length : 0;
+    if (firstRowLength > 0 &&
+        x.some((row) => Array.isArray(row) && row.length !== firstRowLength)) {
         throw new TypeError("Matrix must be a number or array of numbers");
     }
     /* Single or multi dimensional matrix */
@@ -34,25 +29,20 @@ function Matrix(x) {
 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) {
+function Add(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]));
-};
+    return x.map((row, i) => row.map((column, j) => {
+        return column + (Array.isArray(y.__value[i]) ? y.__value[i][j] : 0);
+    }));
+}
+Matrix.add = Add;
 /**
  * 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)
+ * @return {boolean} Whether two matrices can be multiplied (using matrix multiplication)
  */
 Matrix.multipliable = function (x, y) {
     return x.countColumns() === y.countRows();
@@ -66,13 +56,14 @@ Matrix.multipliable = function (x, y) {
  */
 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);
+    let _y;
+    if (isMatrix1D(y)) {
+        _y = unzip([y.__value])[i];
+    }
+    else {
+        _y = unzip(y.__value)[i];
+    }
+    return [..._x].reduce((z, _z, j) => z + _z * _y[j], 0);
 }
 /**
  * Calculates the dot product of two matrices
@@ -85,34 +76,29 @@ 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));
+    if (isMatrix1D(x)) {
+        return Matrix([0]).map((_z, i) => innerproduct(x, y, i));
+    }
+    else {
+        return Matrix(fill(Array(x.countRows()), fill(Array(y.countColumns()), 0))).map((_z, i) => {
+            const _x = Matrix(x.__value[i]);
+            if (isMatrix1D(_x)) {
+                return _z.map((_, j) => innerproduct(_x, y, j));
+            }
+        });
+    }
 };
+function Invert(x) {
+    return Matrix(inv(x.__value));
+}
+Matrix.invert = Invert;
 /**
  * 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;
@@ -123,8 +109,6 @@ Matrix.prototype.countRows = function () {
  * @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;
@@ -138,15 +122,10 @@ Matrix.prototype.countColumns = function () {
 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) {
+function add(y) {
     return Matrix.add(this, y);
-};
+}
+Matrix.prototype.add = add;
 /**
  * Determines whether this matrix can be multiplied
  * @alias module:matrix#multipliable
@@ -171,37 +150,34 @@ Matrix.prototype.multiply = function (y) {
  * @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));
+    if (isMatrix1D(this)) {
+        return Matrix(unzip([this.__value]));
+    }
+    else {
+        return Matrix(unzip(this.__value));
     }
 };
-/**
- * Inverts this matrix
- * @alias module:matrix#invert
- * @return {Matrix} Matrix inverse
- */
-Matrix.prototype.invert = function () {
+function invert() {
     return Matrix.invert(this);
-};
+}
+Matrix.prototype.invert = invert;
 /**
  * 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));
+    if (isMatrix1D(this)) {
+        return Matrix(this.__value.map((x)));
+    }
+    else {
+        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
+ * @return {number[]|number[][]} Number of number array value
  */
 Matrix.prototype.valueOf = function () {
     return this.__value;
@@ -212,19 +188,17 @@ Matrix.prototype.valueOf = function () {
  * @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[");
+    if (isMatrix1D(this)) {
+        return `[ ${this.__value.join(" ")} ]`;
+    }
+    else {
+        /* 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.3",
+  "version": "5.0.1",
   "description": "Single and multi dimensional matrices and matrix functions.",
   "type": "module",
   "main": "dist/index.js",