ml-matrix 6.8.1 → 6.10.0

package/matrix.js

@@ -2,6 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+var isAnyArray = require('is-any-array');
 var rescale = require('ml-array-rescale');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
@@ -952,46 +953,28 @@ function checkColumnVector(matrix, vector) {
   return vector;
 }
 
-function checkIndices(matrix, rowIndices, columnIndices) {
-  return {
-    row: checkRowIndices(matrix, rowIndices),
-    column: checkColumnIndices(matrix, columnIndices),
-  };
-}
-
 function checkRowIndices(matrix, rowIndices) {
-  if (typeof rowIndices !== 'object') {
-    throw new TypeError('unexpected type for row indices');
+  if (!isAnyArray.isAnyArray(rowIndices)) {
+    throw new TypeError('row indices must be an array');
   }
 
-  let rowOut = rowIndices.some((r) => {
-    return r < 0 || r >= matrix.rows;
-  });
-
-  if (rowOut) {
-    throw new RangeError('row indices are out of range');
+  for (let i = 0; i < rowIndices.length; i++) {
+    if (rowIndices[i] < 0 || rowIndices[i] >= matrix.rows) {
+      throw new RangeError('row indices are out of range');
+    }
   }
-
-  if (!Array.isArray(rowIndices)) rowIndices = Array.from(rowIndices);
-
-  return rowIndices;
 }
 
 function checkColumnIndices(matrix, columnIndices) {
-  if (typeof columnIndices !== 'object') {
-    throw new TypeError('unexpected type for column indices');
+  if (!isAnyArray.isAnyArray(columnIndices)) {
+    throw new TypeError('column indices must be an array');
   }
 
-  let columnOut = columnIndices.some((c) => {
-    return c < 0 || c >= matrix.columns;
-  });
-
-  if (columnOut) {
-    throw new RangeError('column indices are out of range');
+  for (let i = 0; i < columnIndices.length; i++) {
+    if (columnIndices[i] < 0 || columnIndices[i] >= matrix.columns) {
+      throw new RangeError('column indices are out of range');
+    }
   }
-  if (!Array.isArray(columnIndices)) columnIndices = Array.from(columnIndices);
-
-  return columnIndices;
 }
 
 function checkRange(matrix, startRow, endRow, startColumn, endColumn) {
@@ -1777,19 +1760,47 @@ class AbstractMatrix {
     return this;
   }
 
-  max() {
+  max(by) {
     if (this.isEmpty()) {
       return NaN;
     }
-    let v = this.get(0, 0);
-    for (let i = 0; i < this.rows; i++) {
-      for (let j = 0; j < this.columns; j++) {
-        if (this.get(i, j) > v) {
-          v = this.get(i, j);
+    switch (by) {
+      case 'row': {
+        const max = new Array(this.rows).fill(Number.NEGATIVE_INFINITY);
+        for (let row = 0; row < this.rows; row++) {
+          for (let column = 0; column < this.columns; column++) {
+            if (this.get(row, column) > max[row]) {
+              max[row] = this.get(row, column);
+            }
+          }
+        }
+        return max;
+      }
+      case 'column': {
+        const max = new Array(this.columns).fill(Number.NEGATIVE_INFINITY);
+        for (let row = 0; row < this.rows; row++) {
+          for (let column = 0; column < this.columns; column++) {
+            if (this.get(row, column) > max[column]) {
+              max[column] = this.get(row, column);
+            }
+          }
+        }
+        return max;
+      }
+      case undefined: {
+        let max = this.get(0, 0);
+        for (let row = 0; row < this.rows; row++) {
+          for (let column = 0; column < this.columns; column++) {
+            if (this.get(row, column) > max) {
+              max = this.get(row, column);
+            }
+          }
         }
+        return max;
       }
+      default:
+        throw new Error(`invalid option: ${by}`);
     }
-    return v;
   }
 
   maxIndex() {
@@ -1808,19 +1819,48 @@ class AbstractMatrix {
     return idx;
   }
 
-  min() {
+  min(by) {
     if (this.isEmpty()) {
       return NaN;
     }
-    let v = this.get(0, 0);
-    for (let i = 0; i < this.rows; i++) {
-      for (let j = 0; j < this.columns; j++) {
-        if (this.get(i, j) < v) {
-          v = this.get(i, j);
+
+    switch (by) {
+      case 'row': {
+        const min = new Array(this.rows).fill(Number.POSITIVE_INFINITY);
+        for (let row = 0; row < this.rows; row++) {
+          for (let column = 0; column < this.columns; column++) {
+            if (this.get(row, column) < min[row]) {
+              min[row] = this.get(row, column);
+            }
+          }
         }
+        return min;
       }
+      case 'column': {
+        const min = new Array(this.columns).fill(Number.POSITIVE_INFINITY);
+        for (let row = 0; row < this.rows; row++) {
+          for (let column = 0; column < this.columns; column++) {
+            if (this.get(row, column) < min[column]) {
+              min[column] = this.get(row, column);
+            }
+          }
+        }
+        return min;
+      }
+      case undefined: {
+        let min = this.get(0, 0);
+        for (let row = 0; row < this.rows; row++) {
+          for (let column = 0; column < this.columns; column++) {
+            if (this.get(row, column) < min) {
+              min = this.get(row, column);
+            }
+          }
+        }
+        return min;
+      }
+      default:
+        throw new Error(`invalid option: ${by}`);
     }
-    return v;
   }
 
   minIndex() {
@@ -2244,6 +2284,7 @@ class AbstractMatrix {
       resultat = resultat.setSubMatrix(c22, c11.rows, c11.columns);
       return resultat.subMatrix(0, rows - 1, 0, cols - 1);
     }
+
     return blockMult(x, y, r, c);
   }
 
@@ -2453,12 +2494,13 @@ class AbstractMatrix {
   }
 
   selection(rowIndices, columnIndices) {
-    let indices = checkIndices(this, rowIndices, columnIndices);
+    checkRowIndices(this, rowIndices);
+    checkColumnIndices(this, columnIndices);
     let newMatrix = new Matrix(rowIndices.length, columnIndices.length);
-    for (let i = 0; i < indices.row.length; i++) {
-      let rowIndex = indices.row[i];
-      for (let j = 0; j < indices.column.length; j++) {
-        let columnIndex = indices.column[j];
+    for (let i = 0; i < rowIndices.length; i++) {
+      let rowIndex = rowIndices[i];
+      for (let j = 0; j < columnIndices.length; j++) {
+        let columnIndex = columnIndices[j];
         newMatrix.set(i, j, this.get(rowIndex, columnIndex));
       }
     }
@@ -2546,13 +2588,13 @@ class AbstractMatrix {
     }
     switch (by) {
       case 'row': {
-        if (!Array.isArray(mean)) {
+        if (!isAnyArray.isAnyArray(mean)) {
           throw new TypeError('mean must be an array');
         }
         return varianceByRow(this, unbiased, mean);
       }
       case 'column': {
-        if (!Array.isArray(mean)) {
+        if (!isAnyArray.isAnyArray(mean)) {
           throw new TypeError('mean must be an array');
         }
         return varianceByColumn(this, unbiased, mean);
@@ -2595,14 +2637,14 @@ class AbstractMatrix {
     const { center = this.mean(by) } = options;
     switch (by) {
       case 'row': {
-        if (!Array.isArray(center)) {
+        if (!isAnyArray.isAnyArray(center)) {
           throw new TypeError('center must be an array');
         }
         centerByRow(this, center);
         return this;
       }
       case 'column': {
-        if (!Array.isArray(center)) {
+        if (!isAnyArray.isAnyArray(center)) {
           throw new TypeError('center must be an array');
         }
         centerByColumn(this, center);
@@ -2633,7 +2675,7 @@ class AbstractMatrix {
       case 'row': {
         if (scale === undefined) {
           scale = getScaleByRow(this);
-        } else if (!Array.isArray(scale)) {
+        } else if (!isAnyArray.isAnyArray(scale)) {
           throw new TypeError('scale must be an array');
         }
         scaleByRow(this, scale);
@@ -2642,7 +2684,7 @@ class AbstractMatrix {
       case 'column': {
         if (scale === undefined) {
           scale = getScaleByColumn(this);
-        } else if (!Array.isArray(scale)) {
+        } else if (!isAnyArray.isAnyArray(scale)) {
           throw new TypeError('scale must be an array');
         }
         scaleByColumn(this, scale);
@@ -2703,7 +2745,7 @@ class Matrix extends AbstractMatrix {
       } else {
         throw new TypeError('nColumns must be a positive integer');
       }
-    } else if (Array.isArray(nRows)) {
+    } else if (isAnyArray.isAnyArray(nRows)) {
       // Copy the values from the 2D array
       const arrayData = nRows;
       nRows = arrayData.length;
@@ -2827,7 +2869,7 @@ class MatrixColumnView extends BaseView {
 
 class MatrixColumnSelectionView extends BaseView {
   constructor(matrix, columnIndices) {
-    columnIndices = checkColumnIndices(matrix, columnIndices);
+    checkColumnIndices(matrix, columnIndices);
     super(matrix, matrix.rows, columnIndices.length);
     this.columnIndices = columnIndices;
   }
@@ -2891,7 +2933,7 @@ class MatrixRowView extends BaseView {
 
 class MatrixRowSelectionView extends BaseView {
   constructor(matrix, rowIndices) {
-    rowIndices = checkRowIndices(matrix, rowIndices);
+    checkRowIndices(matrix, rowIndices);
     super(matrix, rowIndices.length, matrix.columns);
     this.rowIndices = rowIndices;
   }
@@ -2908,10 +2950,11 @@ class MatrixRowSelectionView extends BaseView {
 
 class MatrixSelectionView extends BaseView {
   constructor(matrix, rowIndices, columnIndices) {
-    let indices = checkIndices(matrix, rowIndices, columnIndices);
-    super(matrix, indices.row.length, indices.column.length);
-    this.rowIndices = indices.row;
-    this.columnIndices = indices.column;
+    checkRowIndices(matrix, rowIndices);
+    checkColumnIndices(matrix, columnIndices);
+    super(matrix, rowIndices.length, columnIndices.length);
+    this.rowIndices = rowIndices;
+    this.columnIndices = columnIndices;
   }
 
   set(rowIndex, columnIndex, value) {
@@ -3019,8 +3062,8 @@ class WrapperMatrix2D extends AbstractMatrix {
 }
 
 function wrap(array, options) {
-  if (Array.isArray(array)) {
-    if (array[0] && Array.isArray(array[0])) {
+  if (isAnyArray.isAnyArray(array)) {
+    if (array[0] && isAnyArray.isAnyArray(array[0])) {
       return new WrapperMatrix2D(array);
     } else {
       return new WrapperMatrix1D(array, options);
@@ -4020,7 +4063,7 @@ function covariance(xMatrix, yMatrix = xMatrix, options = {}) {
   if (
     typeof yMatrix === 'object' &&
     !Matrix.isMatrix(yMatrix) &&
-    !Array.isArray(yMatrix)
+    !isAnyArray.isAnyArray(yMatrix)
   ) {
     options = yMatrix;
     yMatrix = xMatrix;
@@ -4053,7 +4096,7 @@ function correlation(xMatrix, yMatrix = xMatrix, options = {}) {
   if (
     typeof yMatrix === 'object' &&
     !Matrix.isMatrix(yMatrix) &&
-    !Array.isArray(yMatrix)
+    !isAnyArray.isAnyArray(yMatrix)
   ) {
     options = yMatrix;
     yMatrix = xMatrix;
@@ -4989,7 +5032,7 @@ class nipals {
 
     let u;
     if (Y) {
-      if (Array.isArray(Y) && typeof Y[0] === 'number') {
+      if (isAnyArray.isAnyArray(Y) && typeof Y[0] === 'number') {
         Y = Matrix.columnVector(Y);
       } else {
         Y = WrapperMatrix2D.checkMatrix(Y);