ml-matrix 6.8.2 → 6.10.1

package/src/matrix.js

@@ -1,3 +1,4 @@
+import { isAnyArray } from 'is-any-array';
 import rescale from 'ml-array-rescale';
 
 import { inspectMatrix, inspectMatrixWithOptions } from './inspect';
@@ -28,8 +29,9 @@ import {
   checkColumnIndex,
   checkColumnVector,
   checkRange,
-  checkIndices,
   checkNonEmpty,
+  checkRowIndices,
+  checkColumnIndices,
 } from './util';
 
 export class AbstractMatrix {
@@ -560,19 +562,47 @@ export 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() {
@@ -591,19 +621,48 @@ export 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() {
@@ -1237,12 +1296,13 @@ export 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));
       }
     }
@@ -1330,13 +1390,13 @@ export class AbstractMatrix {
     }
     switch (by) {
       case 'row': {
-        if (!Array.isArray(mean)) {
+        if (!isAnyArray(mean)) {
           throw new TypeError('mean must be an array');
         }
         return varianceByRow(this, unbiased, mean);
       }
       case 'column': {
-        if (!Array.isArray(mean)) {
+        if (!isAnyArray(mean)) {
           throw new TypeError('mean must be an array');
         }
         return varianceByColumn(this, unbiased, mean);
@@ -1379,14 +1439,14 @@ export class AbstractMatrix {
     const { center = this.mean(by) } = options;
     switch (by) {
       case 'row': {
-        if (!Array.isArray(center)) {
+        if (!isAnyArray(center)) {
           throw new TypeError('center must be an array');
         }
         centerByRow(this, center);
         return this;
       }
       case 'column': {
-        if (!Array.isArray(center)) {
+        if (!isAnyArray(center)) {
           throw new TypeError('center must be an array');
         }
         centerByColumn(this, center);
@@ -1417,7 +1477,7 @@ export class AbstractMatrix {
       case 'row': {
         if (scale === undefined) {
           scale = getScaleByRow(this);
-        } else if (!Array.isArray(scale)) {
+        } else if (!isAnyArray(scale)) {
           throw new TypeError('scale must be an array');
         }
         scaleByRow(this, scale);
@@ -1426,7 +1486,7 @@ export class AbstractMatrix {
       case 'column': {
         if (scale === undefined) {
           scale = getScaleByColumn(this);
-        } else if (!Array.isArray(scale)) {
+        } else if (!isAnyArray(scale)) {
           throw new TypeError('scale must be an array');
         }
         scaleByColumn(this, scale);
@@ -1461,6 +1521,12 @@ function compareNumbers(a, b) {
   return a - b;
 }
 
+function isArrayOfNumbers(array) {
+  return array.every((element) => {
+    return typeof element === 'number';
+  });
+}
+
 // Synonyms
 AbstractMatrix.random = AbstractMatrix.rand;
 AbstractMatrix.randomInt = AbstractMatrix.randInt;
@@ -1487,7 +1553,7 @@ export default class Matrix extends AbstractMatrix {
       } else {
         throw new TypeError('nColumns must be a positive integer');
       }
-    } else if (Array.isArray(nRows)) {
+    } else if (isAnyArray(nRows)) {
       // Copy the values from the 2D array
       const arrayData = nRows;
       nRows = arrayData.length;
@@ -1502,6 +1568,9 @@ export default class Matrix extends AbstractMatrix {
         if (arrayData[i].length !== nColumns) {
           throw new RangeError('Inconsistent array dimensions');
         }
+        if (!isArrayOfNumbers(arrayData[i])) {
+          throw new TypeError('Input data contains non-numeric values');
+        }
         this.data.push(Float64Array.from(arrayData[i]));
       }
     } else {

package/src/util.js

@@ -1,3 +1,5 @@
+import { isAnyArray } from 'is-any-array';
+
 /**
  * @private
  * Check that a row index is not out of bounds
@@ -64,46 +66,28 @@ export function checkColumnVector(matrix, vector) {
   return vector;
 }
 
-export function checkIndices(matrix, rowIndices, columnIndices) {
-  return {
-    row: checkRowIndices(matrix, rowIndices),
-    column: checkColumnIndices(matrix, columnIndices),
-  };
-}
-
 export function checkRowIndices(matrix, rowIndices) {
-  if (typeof rowIndices !== 'object') {
-    throw new TypeError('unexpected type for row indices');
+  if (!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;
 }
 
 export function checkColumnIndices(matrix, columnIndices) {
-  if (typeof columnIndices !== 'object') {
-    throw new TypeError('unexpected type for column indices');
+  if (!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;
 }
 
 export function checkRange(matrix, startRow, endRow, startColumn, endColumn) {

package/src/views/columnSelection.js

@@ -4,7 +4,7 @@ import BaseView from './base';
 
 export default class MatrixColumnSelectionView extends BaseView {
   constructor(matrix, columnIndices) {
-    columnIndices = checkColumnIndices(matrix, columnIndices);
+    checkColumnIndices(matrix, columnIndices);
     super(matrix, matrix.rows, columnIndices.length);
     this.columnIndices = columnIndices;
   }

package/src/views/rowSelection.js

@@ -4,7 +4,7 @@ import BaseView from './base';
 
 export default class MatrixRowSelectionView extends BaseView {
   constructor(matrix, rowIndices) {
-    rowIndices = checkRowIndices(matrix, rowIndices);
+    checkRowIndices(matrix, rowIndices);
     super(matrix, rowIndices.length, matrix.columns);
     this.rowIndices = rowIndices;
   }

package/src/views/selection.js

@@ -1,13 +1,14 @@
-import { checkIndices } from '../util';
+import { checkRowIndices, checkColumnIndices } from '../util';
 
 import BaseView from './base';
 
 export default 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) {

package/src/wrap/wrap.js

@@ -1,9 +1,11 @@
+import { isAnyArray } from 'is-any-array';
+
 import WrapperMatrix1D from './WrapperMatrix1D';
 import WrapperMatrix2D from './WrapperMatrix2D';
 
 export function wrap(array, options) {
-  if (Array.isArray(array)) {
-    if (array[0] && Array.isArray(array[0])) {
+  if (isAnyArray(array)) {
+    if (array[0] && isAnyArray(array[0])) {
       return new WrapperMatrix2D(array);
     } else {
       return new WrapperMatrix1D(array, options);