ml-matrix 6.8.2 → 6.9.0

package/README.md

@@ -12,9 +12,9 @@ Matrix manipulation and computation library.
     Maintained by <a href="https://www.zakodium.com">Zakodium</a>
   </p>
 
-  [![NPM version][npm-image]][npm-url]
-  [![build status][ci-image]][ci-url]
-  [![npm download][download-image]][download-url]
+[![NPM version][npm-image]][npm-url]
+[![build status][ci-image]][ci-url]
+[![npm download][download-image]][download-url]
 
 </h3>
 
@@ -40,7 +40,7 @@ const { Matrix } = require('ml-matrix');
 const matrix = Matrix.ones(5, 5);
 ```
 
-## [API Documentation](https://mljs.github.io/matrix/globals.html)
+## [API Documentation](https://mljs.github.io/matrix/)
 
 ## Examples
 
@@ -49,9 +49,18 @@ const matrix = Matrix.ones(5, 5);
 ```js
 const { Matrix } = require('ml-matrix');
 
-var A = new Matrix([[1, 1], [2, 2]]);
-var B = new Matrix([[3, 3], [1, 1]]);
-var C = new Matrix([[3, 3], [1, 1]]);
+var A = new Matrix([
+  [1, 1],
+  [2, 2],
+]);
+var B = new Matrix([
+  [3, 3],
+  [1, 1],
+]);
+var C = new Matrix([
+  [3, 3],
+  [1, 1],
+]);
 
 // ============================
 // Operations with the matrix :
@@ -75,7 +84,10 @@ C.div(10); // => C = Cinit
 C.mod(2); // => C = Cinit % 2
 
 // Standard Math operations : (abs, cos, round, etc.)
-var A = new Matrix([[1, 1], [-1, -1]]);
+var A = new Matrix([
+  [1, 1],
+  [-1, -1],
+]);
 var exponential = Matrix.exp(A); // exponential = Matrix [[Math.exp(1), Math.exp(1)], [Math.exp(-1), Math.exp(-1)], rows: 2, columns: 2].
 var cosinus = Matrix.cos(A); // cosinus = Matrix [[Math.cos(1), Math.cos(1)], [Math.cos(-1), Math.cos(-1)], rows: 2, columns: 2].
 var absolute = Matrix.abs(A); // expon = absolute [[1, 1], [1, 1], rows: 2, columns: 2].
@@ -122,24 +134,36 @@ const {
   QrDecomposition,
   LuDecomposition,
   CholeskyDecomposition,
-  EigenvalueDecomposition
+  EigenvalueDecomposition,
 } = require('ml-matrix');
 
 //===========================
 // inverse and pseudo-inverse
 //===========================
 
-var A = new Matrix([[2, 3, 5], [4, 1, 6], [1, 3, 0]]);
+var A = new Matrix([
+  [2, 3, 5],
+  [4, 1, 6],
+  [1, 3, 0],
+]);
 var inverseA = inverse(A);
 var B = A.mmul(inverseA); // B = A * inverse(A), so B ~= Identity
 
 // if A is singular, you can use SVD :
-var A = new Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]); // A is singular, so the standard computation of inverse won't work (you can test if you don't trust me^^)
+var A = new Matrix([
+  [1, 2, 3],
+  [4, 5, 6],
+  [7, 8, 9],
+]); // A is singular, so the standard computation of inverse won't work (you can test if you don't trust me^^)
 var inverseA = inverse(A, (useSVD = true)); // inverseA is only an approximation of the inverse, by using the Singular Values Decomposition
 var B = A.mmul(inverseA); // B = A * inverse(A), but inverse(A) is only an approximation, so B doesn't really be identity.
 
 // if you want the pseudo-inverse of a matrix :
-var A = new Matrix([[1, 2], [3, 4], [5, 6]]);
+var A = new Matrix([
+  [1, 2],
+  [3, 4],
+  [5, 6],
+]);
 var pseudoInverseA = A.pseudoInverse();
 var B = A.mmul(pseudoInverseA).mmul(A); // with pseudo inverse, A*pseudo-inverse(A)*A ~= A. It's the case here
 
@@ -151,13 +175,22 @@ var B = A.mmul(pseudoInverseA).mmul(A); // with pseudo inverse, A*pseudo-inverse
 // Below, how to solve least square with our function
 
 // If A is non singular :
-var A = new Matrix([[3, 1], [4.25, 1], [5.5, 1], [8, 1]]);
+var A = new Matrix([
+  [3, 1],
+  [4.25, 1],
+  [5.5, 1],
+  [8, 1],
+]);
 var b = Matrix.columnVector([4.5, 4.25, 5.5, 5.5]);
 var x = solve(A, b);
 var error = Matrix.sub(b, A.mmul(x)); // The error enables to evaluate the solution x found.
 
 // If A is non singular :
-var A = new Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]);
+var A = new Matrix([
+  [1, 2, 3],
+  [4, 5, 6],
+  [7, 8, 9],
+]);
 var b = Matrix.columnVector([8, 20, 32]);
 var x = solve(A, b, (useSVD = true)); // there are many solutions. x can be [1, 2, 1].transpose(), or [1.33, 1.33, 1.33].transpose(), etc.
 var error = Matrix.sub(b, A.mmul(x)); // The error enables to evaluate the solution x found.
@@ -168,7 +201,11 @@ var error = Matrix.sub(b, A.mmul(x)); // The error enables to evaluate the solut
 
 // QR Decomposition
 
-var A = new Matrix([[2, 3, 5], [4, 1, 6], [1, 3, 0]]);
+var A = new Matrix([
+  [2, 3, 5],
+  [4, 1, 6],
+  [1, 3, 0],
+]);
 var QR = new QrDecomposition(A);
 var Q = QR.orthogonalMatrix;
 var R = QR.upperTriangularMatrix;
@@ -176,7 +213,11 @@ var R = QR.upperTriangularMatrix;
 
 // LU Decomposition
 
-var A = new Matrix([[2, 3, 5], [4, 1, 6], [1, 3, 0]]);
+var A = new Matrix([
+  [2, 3, 5],
+  [4, 1, 6],
+  [1, 3, 0],
+]);
 var LU = new LuDecomposition(A);
 var L = LU.lowerTriangularMatrix;
 var U = LU.upperTriangularMatrix;
@@ -185,13 +226,21 @@ var P = LU.pivotPermutationVector;
 
 // Cholesky Decomposition
 
-var A = new Matrix([[2, 3, 5], [4, 1, 6], [1, 3, 0]]);
+var A = new Matrix([
+  [2, 3, 5],
+  [4, 1, 6],
+  [1, 3, 0],
+]);
 var cholesky = new CholeskyDecomposition(A);
 var L = cholesky.lowerTriangularMatrix;
 
 // Eigenvalues & eigenvectors
 
-var A = new Matrix([[2, 3, 5], [4, 1, 6], [1, 3, 0]]);
+var A = new Matrix([
+  [2, 3, 5],
+  [4, 1, 6],
+  [1, 3, 0],
+]);
 var e = new EigenvalueDecomposition(A);
 var real = e.realEigenvalues;
 var imaginary = e.imaginaryEigenvalues;
@@ -218,7 +267,7 @@ var dependencies = linearDependencies(A); // dependencies is a matrix with the d
 
 [npm-image]: https://img.shields.io/npm/v/ml-matrix.svg
 [npm-url]: https://npmjs.org/package/ml-matrix
-[ci-image]: https://github.com/mljs/matrix/workflows/Node.js%20CI/badge.svg?branch=master
+[ci-image]: https://github.com/mljs/matrix/workflows/Node.js%20CI/badge.svg?branch=main
 [ci-url]: https://github.com/mljs/matrix/actions?query=workflow%3A%22Node.js+CI%22
 [download-image]: https://img.shields.io/npm/dm/ml-matrix.svg
 [download-url]: https://npmjs.org/package/ml-matrix

package/matrix.d.ts

@@ -1,4 +1,4 @@
-type MaybeMatrix = AbstractMatrix | number[][];
+type MaybeMatrix = AbstractMatrix | ArrayLike<ArrayLike<number>>;
 type ScalarOrMatrix = number | MaybeMatrix;
 type MatrixDimension = 'row' | 'column';
 
@@ -59,21 +59,21 @@ export interface IVarianceOptions {
 }
 export interface IVarianceByOptions {
   unbiased?: boolean;
-  mean?: number[];
+  mean?: ArrayLike<number>;
 }
 
 export interface ICenterOptions {
   center?: number;
 }
 export interface ICenterByOptions {
-  center?: number[];
+  center?: ArrayLike<number>;
 }
 
 export interface IScaleOptions {
   scale?: number;
 }
 export interface IScaleByOptions {
-  scale?: number[];
+  scale?: ArrayLike<number>;
 }
 
 export interface ICovarianceOptions {
@@ -138,7 +138,7 @@ export abstract class AbstractMatrix {
   static from1DArray(
     newRows: number,
     newColumns: number,
-    newData: number[],
+    newData: ArrayLike<number>,
   ): Matrix;
 
   /**
@@ -146,14 +146,14 @@ export abstract class AbstractMatrix {
    * @param newData - A 1D array containing data for the vector.
    * @returns The new matrix.
    */
-  static rowVector(newData: number[]): Matrix;
+  static rowVector(newData: ArrayLike<number>): Matrix;
 
   /**
    * Creates a column vector, a matrix with only one column.
    * @param newData - A 1D array containing data for the vector.
    * @returns The new matrix.
    */
-  static columnVector(newData: number[]): Matrix;
+  static columnVector(newData: ArrayLike<number>): Matrix;
 
   /**
    * Creates a matrix with the given dimensions. Values will be set to zero.
@@ -219,12 +219,16 @@ export abstract class AbstractMatrix {
    * @param columns - Number of columns. Default: `rows`.
    * @returns - The new diagonal matrix.
    */
-  static diag(data: number[], rows?: number, columns?: number): Matrix;
+  static diag(data: ArrayLike<number>, rows?: number, columns?: number): Matrix;
 
   /**
    * Alias for {@link AbstractMatrix.diag}.
    */
-  static diagonal(data: number[], rows?: number, columns?: number): Matrix;
+  static diagonal(
+    data: ArrayLike<number>,
+    rows?: number,
+    columns?: number,
+  ): Matrix;
 
   /**
    * Returns a matrix whose elements are the minimum between `matrix1` and `matrix2`.
@@ -379,7 +383,7 @@ export abstract class AbstractMatrix {
    * @param index - Row index.
    * @param array - Array or vector to set.
    */
-  setRow(index: number, array: number[] | AbstractMatrix): this;
+  setRow(index: number, array: ArrayLike<number> | AbstractMatrix): this;
 
   /**
    * Swap two rows.
@@ -405,7 +409,7 @@ export abstract class AbstractMatrix {
    * @param index - Column index.
    * @param array - Array or vector to set.
    */
-  setColumn(index: number, array: number[] | AbstractMatrix): this;
+  setColumn(index: number, array: ArrayLike<number> | AbstractMatrix): this;
 
   /**
    * Swap two columns.
@@ -418,49 +422,49 @@ export abstract class AbstractMatrix {
    * Adds the values of a vector to each row.
    * @param vector - Array or vector.
    */
-  addRowVector(vector: number[] | AbstractMatrix): this;
+  addRowVector(vector: ArrayLike<number> | AbstractMatrix): this;
 
   /**
    * Subtracts the values of a vector from each row.
    * @param vector - Array or vector.
    */
-  subRowVector(vector: number[] | AbstractMatrix): this;
+  subRowVector(vector: ArrayLike<number> | AbstractMatrix): this;
 
   /**
    * Multiplies the values of a vector with each row.
    * @param vector - Array or vector.
    */
-  mulRowVector(vector: number[] | AbstractMatrix): this;
+  mulRowVector(vector: ArrayLike<number> | AbstractMatrix): this;
 
   /**
    * Divides the values of each row by those of a vector.
    * @param vector - Array or vector.
    */
-  divRowVector(vector: number[] | AbstractMatrix): this;
+  divRowVector(vector: ArrayLike<number> | AbstractMatrix): this;
 
   /**
    * Adds the values of a vector to each column.
    * @param vector - Array or vector.
    */
-  addColumnVector(vector: number[] | AbstractMatrix): this;
+  addColumnVector(vector: ArrayLike<number> | AbstractMatrix): this;
 
   /**
    * Subtracts the values of a vector from each column.
    * @param vector - Array or vector.
    */
-  subColumnVector(vector: number[] | AbstractMatrix): this;
+  subColumnVector(vector: ArrayLike<number> | AbstractMatrix): this;
 
   /**
    * Multiplies the values of a vector with each column.
    * @param vector - Array or vector.
    */
-  mulColumnVector(vector: number[] | AbstractMatrix): this;
+  mulColumnVector(vector: ArrayLike<number> | AbstractMatrix): this;
 
   /**
    * Divides the values of each column by those of a vector.
    * @param vector - Array or vector.
    */
-  divColumnVector(vector: number[] | AbstractMatrix): this;
+  divColumnVector(vector: ArrayLike<number> | AbstractMatrix): this;
 
   /**
    * Multiplies the values of a row with a scalar.
@@ -608,7 +612,7 @@ export abstract class AbstractMatrix {
    * @param other - Other matrix.
    */
   kroneckerProduct(other: MaybeMatrix): Matrix;
-  
+
   /**
    * Returns the Kronecker sum between `this` and `other`.
    * @link https://en.wikipedia.org/wiki/Kronecker_product#Kronecker_sum
@@ -659,7 +663,7 @@ export abstract class AbstractMatrix {
    * @param endColumn - Last column index. Default: `this.columns - 1`.
    */
   subMatrixRow(
-    indices: number[],
+    indices: ArrayLike<number>,
     startColumn?: number,
     endColumn?: number,
   ): Matrix;
@@ -671,7 +675,7 @@ export abstract class AbstractMatrix {
    * @param endRow - Last row index. Default: `this.rows - 1`.
    */
   subMatrixColumn(
-    indices: number[],
+    indices: ArrayLike<number>,
     startRow?: number,
     endRow?: number,
   ): Matrix;
@@ -683,7 +687,7 @@ export abstract class AbstractMatrix {
    * @param startColumn - The index of the first column to set.
    */
   setSubMatrix(
-    matrix: MaybeMatrix | number[],
+    matrix: MaybeMatrix,
     startRow: number,
     startColumn: number,
   ): this;
@@ -694,7 +698,10 @@ export abstract class AbstractMatrix {
    * @param rowIndices - The row indices to select.
    * @param columnIndices - The column indices to select.
    */
-  selection(rowIndices: number[], columnIndices: number[]): Matrix;
+  selection(
+    rowIndices: ArrayLike<number>,
+    columnIndices: ArrayLike<number>,
+  ): Matrix;
 
   /**
    * Returns the trace of the matrix (sum of the diagonal elements).
@@ -912,7 +919,7 @@ export abstract class AbstractMatrix {
 
 export class Matrix extends AbstractMatrix {
   constructor(nRows: number, nColumns: number);
-  constructor(data: number[][]);
+  constructor(data: ArrayLike<ArrayLike<number>>);
   constructor(otherMatrix: AbstractMatrix);
 
   /**
@@ -932,14 +939,14 @@ export class Matrix extends AbstractMatrix {
    * @param index - Column index. Default: `this.columns`.
    * @param array - Column to add.
    */
-  addColumn(index: number, array: number[] | AbstractMatrix): this;
+  addColumn(index: number, array: ArrayLike<number> | AbstractMatrix): this;
 
   /**
    * Adds a new row to the matrix (in place).
    * @param index - Row index. Default: `this.rows`.
    * @param array - Row to add.
    */
-  addRow(index: number, array: number[] | AbstractMatrix): this;
+  addRow(index: number, array: ArrayLike<number> | AbstractMatrix): this;
 }
 
 export default Matrix;
@@ -949,7 +956,7 @@ export class MatrixColumnView extends AbstractMatrix {
 }
 
 export class MatrixColumnSelectionView extends AbstractMatrix {
-  constructor(matrix: AbstractMatrix, columnIndices: number[]);
+  constructor(matrix: AbstractMatrix, columnIndices: ArrayLike<number>);
 }
 
 export class MatrixFlipColumnView extends AbstractMatrix {
@@ -965,14 +972,14 @@ export class MatrixRowView extends AbstractMatrix {
 }
 
 export class MatrixRowSelectionView extends AbstractMatrix {
-  constructor(matrix: AbstractMatrix, rowIndices: number[]);
+  constructor(matrix: AbstractMatrix, rowIndices: ArrayLike<number>);
 }
 
 export class MatrixSelectionView extends AbstractMatrix {
   constructor(
     matrix: AbstractMatrix,
-    rowIndices: number[],
-    columnIndices: number[],
+    rowIndices: ArrayLike<number>,
+    columnIndices: ArrayLike<number>,
   );
 }
 
@@ -998,18 +1005,18 @@ export interface IWrap1DOptions {
 }
 
 export function wrap(
-  array: number[],
+  array: ArrayLike<number>,
   options?: IWrap1DOptions,
 ): WrapperMatrix1D;
 
-export function wrap(twoDAray: number[][]): WrapperMatrix2D;
+export function wrap(twoDAray: ArrayLike<ArrayLike<number>>): WrapperMatrix2D;
 
 export class WrapperMatrix1D extends AbstractMatrix {
-  constructor(data: number[], options?: IWrap1DOptions);
+  constructor(data: ArrayLike<number>, options?: IWrap1DOptions);
 }
 
 export class WrapperMatrix2D extends AbstractMatrix {
-  constructor(data: number[][]);
+  constructor(data: ArrayLike<ArrayLike<number>>);
 }
 
 /**
@@ -1133,7 +1140,7 @@ export class SingularValueDecomposition {
    * @returns - The vector x.
    */
   solve(value: Matrix): Matrix;
-  solveForDiagonal(value: number[]): Matrix;
+  solveForDiagonal(value: ArrayLike<number>): Matrix;
   readonly norm2: number;
   readonly threshold: number;
   readonly leftSingularVectors: Matrix;
@@ -1223,7 +1230,7 @@ export interface INipalsOptions {
   /**
    * A column vector of length `X.rows` that contains known labels for supervised PLS.
    */
-  Y?: MaybeMatrix | number[];
+  Y?: MaybeMatrix | ArrayLike<number>;
   /**
    * The maximum number of allowed iterations before beraking the loop if convergence is not achieved.
    * @default 1000

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) {
@@ -2454,12 +2437,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));
       }
     }
@@ -2547,13 +2531,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);
@@ -2596,14 +2580,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);
@@ -2634,7 +2618,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);
@@ -2643,7 +2627,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);
@@ -2704,7 +2688,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;
@@ -2828,7 +2812,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;
   }
@@ -2892,7 +2876,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;
   }
@@ -2909,10 +2893,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) {
@@ -3020,8 +3005,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);
@@ -4021,7 +4006,7 @@ function covariance(xMatrix, yMatrix = xMatrix, options = {}) {
   if (
     typeof yMatrix === 'object' &&
     !Matrix.isMatrix(yMatrix) &&
-    !Array.isArray(yMatrix)
+    !isAnyArray.isAnyArray(yMatrix)
   ) {
     options = yMatrix;
     yMatrix = xMatrix;
@@ -4054,7 +4039,7 @@ function correlation(xMatrix, yMatrix = xMatrix, options = {}) {
   if (
     typeof yMatrix === 'object' &&
     !Matrix.isMatrix(yMatrix) &&
-    !Array.isArray(yMatrix)
+    !isAnyArray.isAnyArray(yMatrix)
   ) {
     options = yMatrix;
     yMatrix = xMatrix;
@@ -4990,7 +4975,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);