ml-matrix 6.12.1 → 6.12.2

package/matrix.js

@@ -2,8 +2,114 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var isAnyArray = require('is-any-array');
-var rescale = require('ml-array-rescale');
+// eslint-disable-next-line @typescript-eslint/unbound-method
+const toString = Object.prototype.toString;
+/**
+ * Checks if an object is an instance of an Array (array or typed array, except those that contain bigint values).
+ * @param value - Object to check.
+ * @returns True if the object is an array or a typed array.
+ */
+function isAnyArray(value) {
+    const tag = toString.call(value);
+    return tag.endsWith('Array]') && !tag.includes('Big');
+}
+
+/**
+ * Computes the maximum of the given values.
+ *
+ * @param input
+ * @param options
+ */
+function max(input, options = {}) {
+    if (!isAnyArray(input)) {
+        throw new TypeError('input must be an array');
+    }
+    if (input.length === 0) {
+        throw new TypeError('input must not be empty');
+    }
+    const { fromIndex = 0, toIndex = input.length } = options;
+    if (fromIndex < 0 ||
+        fromIndex >= input.length ||
+        !Number.isInteger(fromIndex)) {
+        throw new Error('fromIndex must be a positive integer smaller than length');
+    }
+    if (toIndex <= fromIndex ||
+        toIndex > input.length ||
+        !Number.isInteger(toIndex)) {
+        throw new Error('toIndex must be an integer greater than fromIndex and at most equal to length');
+    }
+    let maxValue = input[fromIndex];
+    for (let i = fromIndex + 1; i < toIndex; i++) {
+        if (input[i] > maxValue)
+            maxValue = input[i];
+    }
+    return maxValue;
+}
+
+/**
+ * Computes the minimum of the given values.
+ */
+function min(input, options = {}) {
+    if (!isAnyArray(input)) {
+        throw new TypeError('input must be an array');
+    }
+    if (input.length === 0) {
+        throw new TypeError('input must not be empty');
+    }
+    const { fromIndex = 0, toIndex = input.length } = options;
+    if (fromIndex < 0 ||
+        fromIndex >= input.length ||
+        !Number.isInteger(fromIndex)) {
+        throw new Error('fromIndex must be a positive integer smaller than length');
+    }
+    if (toIndex <= fromIndex ||
+        toIndex > input.length ||
+        !Number.isInteger(toIndex)) {
+        throw new Error('toIndex must be an integer greater than fromIndex and at most equal to length');
+    }
+    let minValue = input[fromIndex];
+    for (let i = fromIndex + 1; i < toIndex; i++) {
+        if (input[i] < minValue)
+            minValue = input[i];
+    }
+    return minValue;
+}
+
+/**
+ * Rescale an array into a range.
+ */
+function rescale(input, options = {}) {
+    if (!isAnyArray(input)) {
+        throw new TypeError('input must be an array');
+    }
+    else if (input.length === 0) {
+        throw new TypeError('input must not be empty');
+    }
+    let output;
+    if (options.output !== undefined) {
+        if (!isAnyArray(options.output)) {
+            throw new TypeError('output option must be an array if specified');
+        }
+        output = options.output;
+    }
+    else {
+        output = new Array(input.length);
+    }
+    const currentMin = min(input);
+    const currentMax = max(input);
+    if (currentMin === currentMax) {
+        throw new RangeError('minimum and maximum input values are equal. Cannot rescale a constant array');
+    }
+    const { min: minValue = options.autoMinMax ? currentMin : 0, max: maxValue = options.autoMinMax ? currentMax : 1, } = options;
+    if (minValue >= maxValue) {
+        throw new RangeError('min option must be smaller than max option');
+    }
+    const factor = (maxValue - minValue) / (currentMax - currentMin);
+    for (let i = 0; i < input.length; i++) {
+        output[i] = (input[i] - currentMin) * factor + minValue;
+    }
+    return output;
+}
 
 const indent = ' '.repeat(2);
 const indentData = ' '.repeat(4);
@@ -992,7 +1098,7 @@ function checkColumnVector(matrix, vector) {
 }
 
 function checkRowIndices(matrix, rowIndices) {
-  if (!isAnyArray.isAnyArray(rowIndices)) {
+  if (!isAnyArray(rowIndices)) {
     throw new TypeError('row indices must be an array');
   }
 
@@ -1004,7 +1110,7 @@ function checkRowIndices(matrix, rowIndices) {
 }
 
 function checkColumnIndices(matrix, columnIndices) {
-  if (!isAnyArray.isAnyArray(columnIndices)) {
+  if (!isAnyArray(columnIndices)) {
     throw new TypeError('column indices must be an array');
   }
 
@@ -2659,13 +2765,13 @@ class AbstractMatrix {
     }
     switch (by) {
       case 'row': {
-        if (!isAnyArray.isAnyArray(mean)) {
+        if (!isAnyArray(mean)) {
           throw new TypeError('mean must be an array');
         }
         return varianceByRow(this, unbiased, mean);
       }
       case 'column': {
-        if (!isAnyArray.isAnyArray(mean)) {
+        if (!isAnyArray(mean)) {
           throw new TypeError('mean must be an array');
         }
         return varianceByColumn(this, unbiased, mean);
@@ -2708,14 +2814,14 @@ class AbstractMatrix {
     const { center = this.mean(by) } = options;
     switch (by) {
       case 'row': {
-        if (!isAnyArray.isAnyArray(center)) {
+        if (!isAnyArray(center)) {
           throw new TypeError('center must be an array');
         }
         centerByRow(this, center);
         return this;
       }
       case 'column': {
-        if (!isAnyArray.isAnyArray(center)) {
+        if (!isAnyArray(center)) {
           throw new TypeError('center must be an array');
         }
         centerByColumn(this, center);
@@ -2746,7 +2852,7 @@ class AbstractMatrix {
       case 'row': {
         if (scale === undefined) {
           scale = getScaleByRow(this);
-        } else if (!isAnyArray.isAnyArray(scale)) {
+        } else if (!isAnyArray(scale)) {
           throw new TypeError('scale must be an array');
         }
         scaleByRow(this, scale);
@@ -2755,7 +2861,7 @@ class AbstractMatrix {
       case 'column': {
         if (scale === undefined) {
           scale = getScaleByColumn(this);
-        } else if (!isAnyArray.isAnyArray(scale)) {
+        } else if (!isAnyArray(scale)) {
           throw new TypeError('scale must be an array');
         }
         scaleByColumn(this, scale);
@@ -2869,7 +2975,7 @@ class Matrix extends AbstractMatrix {
       Matrix.copy(nRows, this);
     } else if (Number.isInteger(nRows) && nRows >= 0) {
       this.#initData(nRows, nColumns);
-    } else if (isAnyArray.isAnyArray(nRows)) {
+    } else if (isAnyArray(nRows)) {
       // Copy the values from the 2D array
       const arrayData = nRows;
       nRows = arrayData.length;
@@ -3565,8 +3671,8 @@ class WrapperMatrix2D extends AbstractMatrix {
 }
 
 function wrap(array, options) {
-  if (isAnyArray.isAnyArray(array)) {
-    if (array[0] && isAnyArray.isAnyArray(array[0])) {
+  if (isAnyArray(array)) {
+    if (array[0] && isAnyArray(array[0])) {
       return new WrapperMatrix2D(array);
     } else {
       return new WrapperMatrix1D(array, options);
@@ -4566,7 +4672,7 @@ function covariance(xMatrix, yMatrix = xMatrix, options = {}) {
   if (
     typeof yMatrix === 'object' &&
     !Matrix.isMatrix(yMatrix) &&
-    !isAnyArray.isAnyArray(yMatrix)
+    !isAnyArray(yMatrix)
   ) {
     options = yMatrix;
     yMatrix = xMatrix;
@@ -4599,7 +4705,7 @@ function correlation(xMatrix, yMatrix = xMatrix, options = {}) {
   if (
     typeof yMatrix === 'object' &&
     !Matrix.isMatrix(yMatrix) &&
-    !isAnyArray.isAnyArray(yMatrix)
+    !isAnyArray(yMatrix)
   ) {
     options = yMatrix;
     yMatrix = xMatrix;
@@ -5537,7 +5643,7 @@ class nipals {
 
     let u;
     if (Y) {
-      if (isAnyArray.isAnyArray(Y) && typeof Y[0] === 'number') {
+      if (isAnyArray(Y) && typeof Y[0] === 'number') {
         Y = Matrix.columnVector(Y);
       } else {
         Y = WrapperMatrix2D.checkMatrix(Y);
@@ -5645,3 +5751,4 @@ exports.linearDependencies = linearDependencies;
 exports.pseudoInverse = pseudoInverse;
 exports.solve = solve;
 exports.wrap = wrap;
+//# sourceMappingURL=matrix.js.map