@smockle/matrix 5.0.0 → 5.0.2

package/dist/index.d.ts

@@ -2,22 +2,25 @@ 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;
 }
-interface Matrix1D extends IMatrix {
+export interface Matrix1D extends IMatrix {
     __value: number[];
+    add: (y: Matrix1D) => Matrix1D;
+    invert: () => Matrix1D;
     valueOf: () => number[];
 }
-interface Matrix2D extends IMatrix {
+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
@@ -26,12 +29,40 @@ type Matrix = Matrix1D | Matrix2D;
  * @throws {TypeError} Argument x must be a number or number array
  * @return {Matrix} Single or multi dimensional matrix
  */
-declare function Matrix(x: 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 multiply: typeof Multiply;
+    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;
+/**
+ * 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
+ */
+declare function Multiply(x: Matrix1D, y: Matrix): Matrix1D;
+declare function Multiply(x: Matrix2D, y: Matrix): 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,16 +1,8 @@
 import { fill, padStart, unzip } from "lodash-es";
 import { inv } from "mathjs";
-function isMatrix1D(matrix) {
+export function isMatrix1D(matrix) {
     return matrix.countRows() === 1;
 }
-/**
- * Creates a Matrix
- * @constructor
- * @alias module: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[0]) && x.length === 1) {
@@ -37,21 +29,14 @@ 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) => {
         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
@@ -80,14 +65,7 @@ function innerproduct(x, y, i) {
     }
     return [..._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) {
+function Multiply(x, y) {
     if (!Matrix.multipliable(x, y)) {
         throw new TypeError("Matrices are not multipliable");
     }
@@ -103,16 +81,12 @@ Matrix.multiply = function (x, y) {
             }
         });
     }
-};
-/**
- * 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));
-};
+}
+Matrix.multiply = Multiply;
+function Invert(x) {
+    return Matrix(inv(x.__value));
+}
+Matrix.invert = Invert;
 /**
  * Counts rows in this matrix
  * @alias module:matrix#countRows
@@ -142,15 +116,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
@@ -160,15 +129,10 @@ Matrix.prototype.add = function (y) {
 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) {
+function multiply(y) {
     return Matrix.multiply(this, y);
-};
+}
+Matrix.prototype.multiply = multiply;
 /**
  * Calculates the transpose of this matrix
  * @alias module:matrix#transpose
@@ -182,14 +146,10 @@ Matrix.prototype.transpose = function () {
         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

package/package.json

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