@smockle/matrix 4.0.3 → 5.0.0

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,5 +1,4 @@
-type Matrix = {
-    __value: number | (number | number[])[];
+interface IMatrix {
     countRows: () => number;
     countColumns: () => number;
     addable: (y: Matrix) => boolean;
@@ -9,17 +8,25 @@ type Matrix = {
     transpose: () => Matrix;
     invert: () => Matrix;
     map: (x: any) => Matrix;
-    valueOf: () => number | (number | number[])[];
-};
+}
+interface Matrix1D extends IMatrix {
+    __value: number[];
+    valueOf: () => number[];
+}
+interface Matrix2D extends IMatrix {
+    __value: number[][];
+    valueOf: () => number[][];
+}
+type Matrix = Matrix1D | Matrix2D;
 /**
  * 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[] | number[][]): Matrix;
 declare namespace Matrix {
     var addable: (x: Matrix, y: Matrix) => boolean;
     var add: (x: Matrix, y: Matrix) => Matrix;

package/dist/index.js

@@ -1,22 +1,25 @@
 import { fill, padStart, unzip } from "lodash-es";
 import { inv } from "mathjs";
+function isMatrix1D(matrix) {
+    return matrix.countRows() === 1;
+}
 /**
  * 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
  */
 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 */
@@ -45,14 +48,16 @@ Matrix.addable = function (x, y) {
 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]));
+    return x.map((row, i) => row.map((column, j) => {
+        return column + (Array.isArray(y.__value[i]) ? y.__value[i][j] : 0);
+    }));
 };
 /**
  * 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 +71,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,16 +91,18 @@ 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));
-    });
+    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));
+            }
+        });
+    }
 };
 /**
  * Inverts a matrix
@@ -111,8 +119,6 @@ Matrix.invert = function (x) {
  * @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 +129,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;
@@ -171,13 +175,11 @@ 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));
     }
 };
 /**
@@ -194,14 +196,17 @@ Matrix.prototype.invert = function () {
  * @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 +217,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.0",
   "description": "Single and multi dimensional matrices and matrix functions.",
   "type": "module",
   "main": "dist/index.js",