mathjs 11.9.1 → 11.10.0

package/lib/esm/function/matrix/concat.js

@@ -1,6 +1,6 @@
 import { isBigNumber, isMatrix, isNumber } from '../../utils/is.js';
 import { clone } from '../../utils/object.js';
-import { arraySize } from '../../utils/array.js';
+import { arraySize, concat as _concat } from '../../utils/array.js';
 import { IndexError } from '../../error/IndexError.js';
 import { DimensionError } from '../../error/DimensionError.js';
 import { factory } from '../../utils/factory.js';
@@ -93,7 +93,7 @@ export var createConcat = /* #__PURE__ */factory(name, dependencies, _ref => {
       }
       var res = matrices.shift();
       while (matrices.length) {
-        res = _concat(res, matrices.shift(), dim, 0);
+        res = _concat(res, matrices.shift(), dim);
       }
       return asMatrix ? matrix(res) : res;
     },
@@ -101,31 +101,4 @@ export var createConcat = /* #__PURE__ */factory(name, dependencies, _ref => {
       return args.join('');
     }
   });
-});
-
-/**
- * Recursively concatenate two matrices.
- * The contents of the matrices is not cloned.
- * @param {Array} a             Multi dimensional array
- * @param {Array} b             Multi dimensional array
- * @param {number} concatDim    The dimension on which to concatenate (zero-based)
- * @param {number} dim          The current dim (zero-based)
- * @return {Array} c            The concatenated matrix
- * @private
- */
-function _concat(a, b, concatDim, dim) {
-  if (dim < concatDim) {
-    // recurse into next dimension
-    if (a.length !== b.length) {
-      throw new DimensionError(a.length, b.length);
-    }
-    var c = [];
-    for (var i = 0; i < a.length; i++) {
-      c[i] = _concat(a[i], b[i], concatDim, dim + 1);
-    }
-    return c;
-  } else {
-    // concatenate this dimension
-    return a.concat(b);
-  }
-}
+});

package/lib/esm/function/matrix/subset.js

@@ -1,15 +1,17 @@
 import { isIndex } from '../../utils/is.js';
 import { clone } from '../../utils/object.js';
-import { validateIndex } from '../../utils/array.js';
+import { isEmptyIndex, validateIndex, validateIndexSourceSize } from '../../utils/array.js';
 import { getSafeProperty, setSafeProperty } from '../../utils/customs.js';
 import { DimensionError } from '../../error/DimensionError.js';
 import { factory } from '../../utils/factory.js';
 var name = 'subset';
-var dependencies = ['typed', 'matrix'];
+var dependencies = ['typed', 'matrix', 'zeros', 'add'];
 export var createSubset = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
-    matrix
+    matrix,
+    zeros,
+    add
   } = _ref;
   /**
    * Get or set a subset of a matrix or string.
@@ -22,13 +24,15 @@ export var createSubset = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    *     // get a subset
    *     const d = [[1, 2], [3, 4]]
-   *     math.subset(d, math.index(1, 0))        // returns 3
-   *     math.subset(d, math.index([0, 1], 1))   // returns [[2], [4]]
+   *     math.subset(d, math.index(1, 0))             // returns 3
+   *     math.subset(d, math.index([0, 1], 1))        // returns [[2], [4]]
+   *     math.subset(d, math.index([false, true], 0)) // returns [[3]]
    *
    *     // replace a subset
    *     const e = []
-   *     const f = math.subset(e, math.index(0, [0, 2]), [5, 6])  // f = [[5, 6]]
-   *     const g = math.subset(f, math.index(1, 1), 7, 0)         // g = [[5, 6], [0, 7]]
+   *     const f = math.subset(e, math.index(0, [0, 2]), [5, 6])  // f = [[5, 0, 6]]
+   *     const g = math.subset(f, math.index(1, 1), 7, 0)         // g = [[5, 0, 6], [0, 7, 0]]
+   *     math.subset(g, math.index([false, true], 1), 8)          // returns [[5, 0, 6], [0, 8, 0]]
    *
    *     // get submatrix using ranges
    *     const M = [
@@ -36,7 +40,7 @@ export var createSubset = /* #__PURE__ */factory(name, dependencies, _ref => {
    *       [4,5,6],
    *       [7,8,9]
    *     ]
-   *     math.subset(M, math.index(math.range(0,2), math.range(0,3))) // [[1,2,3],[4,5,6]]
+   *     math.subset(M, math.index(math.range(0,2), math.range(0,3))) // [[1, 2, 3], [4, 5, 6]]
    *
    * See also:
    *
@@ -55,36 +59,78 @@ export var createSubset = /* #__PURE__ */factory(name, dependencies, _ref => {
    *                                          math.matrix elements will be left undefined.
    * @return {Array | Matrix | string} Either the retrieved subset or the updated matrix.
    */
+
   return typed(name, {
     // get subset
-    'Array, Index': function ArrayIndex(value, index) {
-      var m = matrix(value);
-      var subset = m.subset(index); // returns a Matrix
-      return index.isScalar() ? subset : subset.valueOf(); // return an Array (like the input)
-    },
-
     'Matrix, Index': function MatrixIndex(value, index) {
+      if (isEmptyIndex(index)) {
+        return matrix();
+      }
+      validateIndexSourceSize(value, index);
       return value.subset(index);
     },
+    'Array, Index': typed.referTo('Matrix, Index', function (subsetRef) {
+      return function (value, index) {
+        var subsetResult = subsetRef(matrix(value), index);
+        return index.isScalar() ? subsetResult : subsetResult.valueOf();
+      };
+    }),
     'Object, Index': _getObjectProperty,
     'string, Index': _getSubstring,
     // set subset
-    'Array, Index, any': function ArrayIndexAny(value, index, replacement) {
-      return matrix(clone(value)).subset(index, replacement, undefined).valueOf();
-    },
-    'Array, Index, any, any': function ArrayIndexAnyAny(value, index, replacement, defaultValue) {
-      return matrix(clone(value)).subset(index, replacement, defaultValue).valueOf();
-    },
-    'Matrix, Index, any': function MatrixIndexAny(value, index, replacement) {
-      return value.clone().subset(index, replacement);
-    },
     'Matrix, Index, any, any': function MatrixIndexAnyAny(value, index, replacement, defaultValue) {
-      return value.clone().subset(index, replacement, defaultValue);
+      if (isEmptyIndex(index)) {
+        return value;
+      }
+      validateIndexSourceSize(value, index);
+      return value.clone().subset(index, _broadcastReplacement(replacement, index), defaultValue);
     },
+    'Array, Index, any, any': typed.referTo('Matrix, Index, any, any', function (subsetRef) {
+      return function (value, index, replacement, defaultValue) {
+        var subsetResult = subsetRef(matrix(value), index, replacement, defaultValue);
+        return subsetResult.isMatrix ? subsetResult.valueOf() : subsetResult;
+      };
+    }),
+    'Array, Index, any': typed.referTo('Matrix, Index, any, any', function (subsetRef) {
+      return function (value, index, replacement) {
+        return subsetRef(matrix(value), index, replacement, undefined).valueOf();
+      };
+    }),
+    'Matrix, Index, any': typed.referTo('Matrix, Index, any, any', function (subsetRef) {
+      return function (value, index, replacement) {
+        return subsetRef(value, index, replacement, undefined);
+      };
+    }),
     'string, Index, string': _setSubstring,
     'string, Index, string, string': _setSubstring,
     'Object, Index, any': _setObjectProperty
   });
+
+  /**
+   * Broadcasts a replacment value to be the same size as index
+   * @param {number | BigNumber | Array | Matrix} replacement Replacement value to try to broadcast
+   * @param {*} index Index value
+   * @returns broadcasted replacement that matches the size of index
+   */
+
+  function _broadcastReplacement(replacement, index) {
+    if (typeof replacement === 'string') {
+      throw new Error('can\'t boradcast a string');
+    }
+    if (index._isScalar) {
+      return replacement;
+    }
+    var indexSize = index.size();
+    if (indexSize.every(d => d > 0)) {
+      try {
+        return add(replacement, zeros(indexSize));
+      } catch (error) {
+        return replacement;
+      }
+    } else {
+      return replacement;
+    }
+  }
 });
 
 /**
@@ -99,6 +145,10 @@ function _getSubstring(str, index) {
     // TODO: better error message
     throw new TypeError('Index expected');
   }
+  if (isEmptyIndex(index)) {
+    return '';
+  }
+  validateIndexSourceSize(Array.from(str), index);
   if (index.size().length !== 1) {
     throw new DimensionError(index.size().length, 1);
   }
@@ -120,7 +170,7 @@ function _getSubstring(str, index) {
  * @param {string} str            string to be replaced
  * @param {Index} index           An index or list of indices (character positions)
  * @param {string} replacement    Replacement string
- * @param {string} [defaultValue] Default value to be uses when resizing
+ * @param {string} [defaultValue] Default value to be used when resizing
  *                                the string. is ' ' by default
  * @returns {string} result
  * @private
@@ -130,6 +180,10 @@ function _setSubstring(str, index, replacement, defaultValue) {
     // TODO: better error message
     throw new TypeError('Index expected');
   }
+  if (isEmptyIndex(index)) {
+    return str;
+  }
+  validateIndexSourceSize(Array.from(str), index);
   if (index.size().length !== 1) {
     throw new DimensionError(index.size().length, 1);
   }
@@ -179,6 +233,9 @@ function _setSubstring(str, index, replacement, defaultValue) {
  * @private
  */
 function _getObjectProperty(object, index) {
+  if (isEmptyIndex(index)) {
+    return undefined;
+  }
   if (index.size().length !== 1) {
     throw new DimensionError(index.size(), 1);
   }
@@ -198,6 +255,9 @@ function _getObjectProperty(object, index) {
  * @private
  */
 function _setObjectProperty(object, index, replacement) {
+  if (isEmptyIndex(index)) {
+    return object;
+  }
   if (index.size().length !== 1) {
     throw new DimensionError(index.size(), 1);
   }

package/lib/esm/function/special/zeta.js

@@ -0,0 +1,146 @@
+import { factory } from '../../utils/factory.js';
+var name = 'zeta';
+var dependencies = ['typed', 'config', 'multiply', 'pow', 'divide', 'factorial', 'equal', 'smallerEq', 'isNegative', 'gamma', 'sin', 'subtract', 'add', '?Complex', '?BigNumber', 'pi'];
+export var createZeta = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    config,
+    multiply,
+    pow,
+    divide,
+    factorial,
+    equal,
+    smallerEq,
+    isNegative,
+    gamma,
+    sin,
+    subtract,
+    add,
+    Complex,
+    BigNumber: _BigNumber,
+    pi
+  } = _ref;
+  /**
+   * Compute the Riemann Zeta function of a value using an infinite series for
+   * all of the complex plane using Riemann's Functional equation.
+   *
+   * Based off the paper by Xavier Gourdon and Pascal Sebah
+   * ( http://numbers.computation.free.fr/Constants/Miscellaneous/zetaevaluations.pdf )
+   *
+   * Implementation and slight modification by Anik Patel
+   *
+   * Note: the implementation is accurate up to about 6 digits.
+   *
+   * Syntax:
+   *
+   *    math.zeta(n)
+   *
+   * Examples:
+   *
+   *    math.zeta(5)       // returns 1.0369277551433895
+   *    math.zeta(-0.5)    // returns -0.2078862249773449
+   *    math.zeta(math.i)  // returns 0.0033002236853253153 - 0.4181554491413212i
+   *
+   *
+   * @param {number | Complex | BigNumber} s   A Real, Complex or BigNumber parameter to the Riemann Zeta Function
+   * @return {number | Complex | BigNumber}    The Riemann Zeta of `s`
+   */
+  return typed(name, {
+    number: s => zetaNumeric(s, value => value, () => 20),
+    BigNumber: s => zetaNumeric(s, value => new _BigNumber(value), () => {
+      // epsilon is for example 1e-12. Extract the positive exponent 12 from that
+      return Math.abs(Math.log10(config.epsilon));
+    }),
+    Complex: zetaComplex
+  });
+
+  /**
+   * @param {number | BigNumber} s
+   * @param {(value: number) => number | BigNumber} createValue
+   * @param {(value: number | BigNumber | Complex) => number} determineDigits
+   * @returns {number | BigNumber}
+   */
+  function zetaNumeric(s, createValue, determineDigits) {
+    if (equal(s, 0)) {
+      return createValue(-0.5);
+    }
+    if (equal(s, 1)) {
+      return createValue(NaN);
+    }
+    if (!isFinite(s)) {
+      return isNegative(s) ? createValue(NaN) : createValue(1);
+    }
+    return zeta(s, createValue, determineDigits, s => s);
+  }
+
+  /**
+   * @param {Complex} s
+   * @returns {Complex}
+   */
+  function zetaComplex(s) {
+    if (s.re === 0 && s.im === 0) {
+      return new Complex(-0.5);
+    }
+    if (s.re === 1) {
+      return new Complex(NaN, NaN);
+    }
+    if (s.re === Infinity && s.im === 0) {
+      return new Complex(1);
+    }
+    if (s.im === Infinity || s.re === -Infinity) {
+      return new Complex(NaN, NaN);
+    }
+    return zeta(s, value => value, s => Math.round(1.3 * 15 + 0.9 * Math.abs(s.im)), s => s.re);
+  }
+
+  /**
+   * @param {number | BigNumber | Complex} s
+   * @param {(value: number) => number | BigNumber | Complex} createValue
+   * @param {(value: number | BigNumber | Complex) => number} determineDigits
+   * @param {(value: number | BigNumber | Complex) => number} getRe
+   * @returns {*|number}
+   */
+  function zeta(s, createValue, determineDigits, getRe) {
+    var n = determineDigits(s);
+    if (getRe(s) > -(n - 1) / 2) {
+      return f(s, createValue(n), createValue);
+    } else {
+      // Function Equation for reflection to x < 1
+      var c = multiply(pow(2, s), pow(createValue(pi), subtract(s, 1)));
+      c = multiply(c, sin(multiply(divide(createValue(pi), 2), s)));
+      c = multiply(c, gamma(subtract(1, s)));
+      return multiply(c, zeta(subtract(1, s), createValue, determineDigits, getRe));
+    }
+  }
+
+  /**
+   * Calculate a portion of the sum
+   * @param {number | BigNumber} k   a positive integer
+   * @param {number | BigNumber} n   a positive integer
+   * @return {number}    the portion of the sum
+   **/
+  function d(k, n) {
+    var S = k;
+    for (var j = k; smallerEq(j, n); j = add(j, 1)) {
+      var factor = divide(multiply(factorial(add(n, subtract(j, 1))), pow(4, j)), multiply(factorial(subtract(n, j)), factorial(multiply(2, j))));
+      S = add(S, factor);
+    }
+    return multiply(n, S);
+  }
+
+  /**
+   * Calculate the positive Riemann Zeta function
+   * @param {number} s   a real or complex number with s.re > 1
+   * @param {number} n   a positive integer
+   * @param {(number) => number | BigNumber | Complex} createValue
+   * @return {number}    Riemann Zeta of s
+   **/
+  function f(s, n, createValue) {
+    var c = divide(1, multiply(d(createValue(0), n), subtract(1, pow(2, subtract(1, s)))));
+    var S = createValue(0);
+    for (var k = createValue(1); smallerEq(k, n); k = add(k, 1)) {
+      S = add(S, divide(multiply((-1) ** (k - 1), d(k, n)), pow(k, s)));
+    }
+    return multiply(c, S);
+  }
+});

package/lib/esm/function/statistics/quantileSeq.js

@@ -1,16 +1,17 @@
 import { isBigNumber, isCollection, isNumber } from '../../utils/is.js';
-import { isInteger } from '../../utils/number.js';
 import { flatten } from '../../utils/array.js';
 import { factory } from '../../utils/factory.js';
+import { createApply } from '../matrix/apply.js';
 var name = 'quantileSeq';
-var dependencies = ['typed', 'add', 'multiply', 'partitionSelect', 'compare'];
+var dependencies = ['typed', 'add', 'multiply', 'partitionSelect', 'compare', 'isInteger'];
 export var createQuantileSeq = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     add,
     multiply,
     partitionSelect,
-    compare
+    compare,
+    isInteger
   } = _ref;
   /**
    * Compute the prob order quantile of a matrix or a list with values.
@@ -46,6 +47,32 @@ export var createQuantileSeq = /* #__PURE__ */factory(name, dependencies, _ref =
    * @param {Boolean} sorted=false              is data sorted in ascending order
    * @return {Number, BigNumber, Unit, Array}   Quantile(s)
    */
+
+  var apply = createApply({
+    typed,
+    isInteger
+  });
+  /**
+   * Check if array value types are valid, throw error otherwise.
+   * @param {number | BigNumber | Unit} x
+   * @param {number | BigNumber | Unit} x
+   * @private
+   */
+  var validate = typed({
+    'number | BigNumber | Unit': function numberBigNumberUnit(x) {
+      return x;
+    }
+  });
+  return typed(name, {
+    'Array|Matrix, number|BigNumber|Array': (data, prob) => quantileSeq(data, prob, false),
+    'Array|Matrix, number|BigNumber|Array, boolean': quantileSeq,
+    'Array|Matrix, number|BigNumber|Array, number': (data, prob, dim) => _quantileSeqDim(data, prob, false, dim),
+    'Array|Matrix, number|BigNumber|Array, boolean, number': (data, prob, sorted, dim) => _quantileSeqDim(data, prob, sorted, dim)
+  });
+  function _quantileSeqDim(data, prob, sorted, dim) {
+    // return [1.3, 1.2]
+    return apply(data, dim, x => quantileSeq(x, prob, sorted));
+  }
   function quantileSeq(data, probOrN, sorted) {
     var probArr, dataArr, one;
     if (arguments.length < 2 || arguments.length > 3) {
@@ -219,17 +246,4 @@ export var createQuantileSeq = /* #__PURE__ */factory(name, dependencies, _ref =
     var one = new fracPart.constructor(1);
     return add(multiply(left, one.minus(fracPart)), multiply(right, fracPart));
   }
-
-  /**
-   * Check if array value types are valid, throw error otherwise.
-   * @param {number | BigNumber | Unit} x
-   * @param {number | BigNumber | Unit} x
-   * @private
-   */
-  var validate = typed({
-    'number | BigNumber | Unit': function numberBigNumberUnit(x) {
-      return x;
-    }
-  });
-  return quantileSeq;
 });

package/lib/esm/type/matrix/DenseMatrix.js

@@ -1,5 +1,5 @@
 import { isArray, isBigNumber, isCollection, isIndex, isMatrix, isNumber, isString, typeOf } from '../../utils/is.js';
-import { arraySize, getArrayDataType, processSizesWildcard, reshape, resize, unsqueeze, validate, validateIndex } from '../../utils/array.js';
+import { arraySize, getArrayDataType, processSizesWildcard, reshape, resize, unsqueeze, validate, validateIndex, broadcastTo } from '../../utils/array.js';
 import { format } from '../../utils/string.js';
 import { isInteger } from '../../utils/number.js';
 import { clone, deepStrictEqual } from '../../utils/object.js';
@@ -330,6 +330,18 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, _
     } else {
       // set a submatrix
 
+      // broadcast submatrix
+      if (!deepStrictEqual(sSize, iSize)) {
+        try {
+          if (sSize.length === 0) {
+            submatrix = broadcastTo([submatrix], iSize);
+          } else {
+            submatrix = broadcastTo(submatrix, iSize);
+          }
+          sSize = arraySize(submatrix);
+        } catch (_unused) {}
+      }
+
       // validate dimensions
       if (iSize.length < matrix._size.length) {
         throw new DimensionError(iSize.length, matrix._size.length, '<');
@@ -921,19 +933,17 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, _
 
   /**
    * Preprocess data, which can be an Array or DenseMatrix with nested Arrays and
-   * Matrices. Replaces all nested Matrices with Arrays
+   * Matrices. Clones all (nested) Arrays, and replaces all nested Matrices with Arrays
    * @memberof DenseMatrix
-   * @param {Array} data
+   * @param {Array | Matrix} data
    * @return {Array} data
    */
   function preprocess(data) {
-    for (var i = 0, ii = data.length; i < ii; i++) {
-      var elem = data[i];
-      if (isArray(elem)) {
-        data[i] = preprocess(elem);
-      } else if (elem && elem.isMatrix === true) {
-        data[i] = preprocess(elem.valueOf());
-      }
+    if (isMatrix(data)) {
+      return preprocess(data.valueOf());
+    }
+    if (isArray(data)) {
+      return data.map(preprocess);
     }
     return data;
   }

package/lib/esm/type/matrix/MatrixIndex.js

@@ -1,12 +1,13 @@
-import { isMatrix, isRange } from '../../utils/is.js';
+import { isArray, isMatrix, isRange } from '../../utils/is.js';
 import { clone } from '../../utils/object.js';
 import { isInteger } from '../../utils/number.js';
 import { factory } from '../../utils/factory.js';
 var name = 'Index';
-var dependencies = ['ImmutableDenseMatrix'];
+var dependencies = ['ImmutableDenseMatrix', 'getMatrixDataType'];
 export var createIndexClass = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
-    ImmutableDenseMatrix
+    ImmutableDenseMatrix,
+    getMatrixDataType
   } = _ref;
   /**
    * Create an index. An Index can store ranges and sets for multiple dimensions.
@@ -20,7 +21,9 @@ export var createIndexClass = /* #__PURE__ */factory(name, dependencies, _ref =>
    *     A string (containing a name of an object property)
    *     An instance of Range
    *     An Array with the Set values
+   *     An Array with Booleans
    *     A Matrix with the Set values
+   *     A Matrix with Booleans
    *
    * The parameters start, end, and step must be integer numbers.
    *
@@ -33,20 +36,31 @@ export var createIndexClass = /* #__PURE__ */factory(name, dependencies, _ref =>
       throw new SyntaxError('Constructor must be called with the new operator');
     }
     this._dimensions = [];
+    this._sourceSize = [];
     this._isScalar = true;
     for (var i = 0, ii = arguments.length; i < ii; i++) {
       var arg = arguments[i];
+      var argIsArray = isArray(arg);
+      var argIsMatrix = isMatrix(arg);
+      var sourceSize = null;
       if (isRange(arg)) {
         this._dimensions.push(arg);
         this._isScalar = false;
-      } else if (Array.isArray(arg) || isMatrix(arg)) {
+      } else if (argIsArray || argIsMatrix) {
         // create matrix
-        var m = _createImmutableMatrix(arg.valueOf());
+        var m = void 0;
+        if (getMatrixDataType(arg) === 'boolean') {
+          if (argIsArray) m = _createImmutableMatrix(_booleansArrayToNumbersForIndex(arg).valueOf());
+          if (argIsMatrix) m = _createImmutableMatrix(_booleansArrayToNumbersForIndex(arg._data).valueOf());
+          sourceSize = arg.valueOf().length;
+        } else {
+          m = _createImmutableMatrix(arg.valueOf());
+        }
         this._dimensions.push(m);
         // size
         var size = m.size();
         // scalar
-        if (size.length !== 1 || size[0] !== 1) {
+        if (size.length !== 1 || size[0] !== 1 || sourceSize !== null) {
           this._isScalar = false;
         }
       } else if (typeof arg === 'number') {
@@ -57,6 +71,7 @@ export var createIndexClass = /* #__PURE__ */factory(name, dependencies, _ref =>
       } else {
         throw new TypeError('Dimension must be an Array, Matrix, number, string, or Range');
       }
+      this._sourceSize.push(sourceSize);
       // TODO: implement support for wildcard '*'
     }
   }
@@ -86,6 +101,7 @@ export var createIndexClass = /* #__PURE__ */factory(name, dependencies, _ref =>
     var index = new Index();
     index._dimensions = clone(this._dimensions);
     index._isScalar = this._isScalar;
+    index._sourceSize = this._sourceSize;
     return index;
   };
 
@@ -263,4 +279,20 @@ export var createIndexClass = /* #__PURE__ */factory(name, dependencies, _ref =>
   return Index;
 }, {
   isClass: true
-});
+});
+
+/**
+ * Receives an array of booleans and returns an array of Numbers for Index
+ * @param {Array} booleanArrayIndex An array of booleans
+ * @return {Array} A set of numbers ready for index
+ */
+function _booleansArrayToNumbersForIndex(booleanArrayIndex) {
+  // gets an array of booleans and returns an array of numbers
+  var indexOfNumbers = [];
+  booleanArrayIndex.forEach((bool, idx) => {
+    if (bool) {
+      indexOfNumbers.push(idx);
+    }
+  });
+  return indexOfNumbers;
+}

package/lib/esm/type/matrix/function/index.js

@@ -1,5 +1,5 @@
+import { isBigNumber, isMatrix, isArray } from '../../../utils/is.js';
 import { factory } from '../../../utils/factory.js';
-import { isBigNumber, isMatrix } from '../../../utils/is.js';
 var name = 'index';
 var dependencies = ['typed', 'Index'];
 export var createIndex = /* #__PURE__ */factory(name, dependencies, _ref => {
@@ -21,17 +21,19 @@ export var createIndex = /* #__PURE__ */factory(name, dependencies, _ref => {
    * - A number
    * - A string for getting/setting an object property
    * - An instance of `Range`
-   * - A one-dimensional Array or a Matrix with numbers
+   * - A one-dimensional Array or a Matrix with numbers or booleans
    *
    * Indexes must be zero-based, integer numbers.
    *
    * Examples:
    *
    *    const b = [1, 2, 3, 4, 5]
-   *    math.subset(b, math.index([1, 2, 3]))     // returns [2, 3, 4]
+   *    math.subset(b, math.index([1, 2, 3]))                         // returns [2, 3, 4]
+   *    math.subset(b, math.index([false, true, true, true, false]))  // returns [2, 3, 4]
    *
    *    const a = math.matrix([[1, 2], [3, 4]])
    *    a.subset(math.index(0, 1))             // returns 2
+   *    a.subset(math.index(0, [false, true])) // returns 2
    *
    * See also:
    *
@@ -45,7 +47,7 @@ export var createIndex = /* #__PURE__ */factory(name, dependencies, _ref => {
       var ranges = args.map(function (arg) {
         if (isBigNumber(arg)) {
           return arg.toNumber(); // convert BigNumber to Number
-        } else if (Array.isArray(arg) || isMatrix(arg)) {
+        } else if (isArray(arg) || isMatrix(arg)) {
           return arg.map(function (elem) {
             // convert BigNumber to Number
             return isBigNumber(elem) ? elem.toNumber() : elem;