mathjs 11.9.1 → 11.10.1

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

@@ -9,9 +9,10 @@ var _object = require("../../utils/object.js");
 var _number = require("../../utils/number.js");
 var _factory = require("../../utils/factory.js");
 var name = 'Index';
-var dependencies = ['ImmutableDenseMatrix'];
+var dependencies = ['ImmutableDenseMatrix', 'getMatrixDataType'];
 var createIndexClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var ImmutableDenseMatrix = _ref.ImmutableDenseMatrix;
+  var ImmutableDenseMatrix = _ref.ImmutableDenseMatrix,
+    getMatrixDataType = _ref.getMatrixDataType;
   /**
    * Create an index. An Index can store ranges and sets for multiple dimensions.
    * Matrix.get, Matrix.set, and math.subset accept an Index as input.
@@ -24,7 +25,9 @@ var createIndexClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies,
    *     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.
    *
@@ -37,20 +40,31 @@ var createIndexClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies,
       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 = (0, _is.isArray)(arg);
+      var argIsMatrix = (0, _is.isMatrix)(arg);
+      var sourceSize = null;
       if ((0, _is.isRange)(arg)) {
         this._dimensions.push(arg);
         this._isScalar = false;
-      } else if (Array.isArray(arg) || (0, _is.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') {
@@ -61,6 +75,7 @@ var createIndexClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies,
       } else {
         throw new TypeError('Dimension must be an Array, Matrix, number, string, or Range');
       }
+      this._sourceSize.push(sourceSize);
       // TODO: implement support for wildcard '*'
     }
   }
@@ -90,6 +105,7 @@ var createIndexClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies,
     var index = new Index();
     index._dimensions = (0, _object.clone)(this._dimensions);
     index._isScalar = this._isScalar;
+    index._sourceSize = this._sourceSize;
     return index;
   };
 
@@ -268,4 +284,20 @@ var createIndexClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies,
 }, {
   isClass: true
 });
-exports.createIndexClass = createIndexClass;
+
+/**
+ * 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
+ */
+exports.createIndexClass = createIndexClass;
+function _booleansArrayToNumbersForIndex(booleanArrayIndex) {
+  // gets an array of booleans and returns an array of numbers
+  var indexOfNumbers = [];
+  booleanArrayIndex.forEach(function (bool, idx) {
+    if (bool) {
+      indexOfNumbers.push(idx);
+    }
+  });
+  return indexOfNumbers;
+}

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

@@ -4,8 +4,8 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createIndex = void 0;
-var _factory = require("../../../utils/factory.js");
 var _is = require("../../../utils/is.js");
+var _factory = require("../../../utils/factory.js");
 var name = 'index';
 var dependencies = ['typed', 'Index'];
 var createIndex = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
@@ -25,17 +25,19 @@ var createIndex = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
    * - 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:
    *
@@ -49,7 +51,7 @@ var createIndex = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
       var ranges = args.map(function (arg) {
         if ((0, _is.isBigNumber)(arg)) {
           return arg.toNumber(); // convert BigNumber to Number
-        } else if (Array.isArray(arg) || (0, _is.isMatrix)(arg)) {
+        } else if ((0, _is.isArray)(arg) || (0, _is.isMatrix)(arg)) {
           return arg.map(function (elem) {
             // convert BigNumber to Number
             return (0, _is.isBigNumber)(elem) ? elem.toNumber() : elem;

package/lib/cjs/type/matrix/utils/broadcast.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.createBroadcast = void 0;
 var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _array = require("../../../utils/array.js");
 var _factory = require("../../../utils/factory.js");
 var name = 'broadcast';
 var dependancies = ['concat'];
@@ -40,10 +41,8 @@ var createBroadcast = /* #__PURE__ */(0, _factory.factory)(name, dependancies, f
     }
 
     // check if the broadcasting rules applyes for both matrices
-    for (var _dim = 0; _dim < N; _dim++) {
-      _checkRules(sizeA, sizeMax, _dim);
-      _checkRules(sizeB, sizeMax, _dim);
-    }
+    (0, _array.checkBroadcastingRules)(sizeA, sizeMax);
+    (0, _array.checkBroadcastingRules)(sizeB, sizeMax);
 
     // reshape A or B if needed to make them ready for concat
     var AA = A.clone();
@@ -55,12 +54,12 @@ var createBroadcast = /* #__PURE__ */(0, _factory.factory)(name, dependancies, f
     }
 
     // stretches the matrices on each dimension to make them the same size
-    for (var _dim2 = 0; _dim2 < N; _dim2++) {
-      if (AA._size[_dim2] < sizeMax[_dim2]) {
-        AA = _stretch(AA, sizeMax[_dim2], _dim2);
+    for (var _dim = 0; _dim < N; _dim++) {
+      if (AA._size[_dim] < sizeMax[_dim]) {
+        AA = _stretch(AA, sizeMax[_dim], _dim);
       }
-      if (BB._size[_dim2] < sizeMax[_dim2]) {
-        BB = _stretch(BB, sizeMax[_dim2], _dim2);
+      if (BB._size[_dim] < sizeMax[_dim]) {
+        BB = _stretch(BB, sizeMax[_dim], _dim);
       }
     }
 
@@ -75,10 +74,5 @@ var createBroadcast = /* #__PURE__ */(0, _factory.factory)(name, dependancies, f
     // stretches a matrix up to a certain size in a certain dimension
     return concat.apply(void 0, (0, _toConsumableArray2["default"])(Array(sizeToStretch).fill(arrayToStretch)).concat([dimToStretch]));
   }
-  function _checkRules(shape, sizeMax, dim) {
-    if (shape[dim] < sizeMax[dim] & shape[dim] > 1) {
-      throw new Error("shape missmatch: missmatch is found in arg with shape (".concat(shape, ") not possible to broadcast dimension ").concat(dim, " with size ").concat(shape[dim], " to size ").concat(sizeMax[dim]));
-    }
-  }
 });
 exports.createBroadcast = createBroadcast;

package/lib/cjs/type/unit/Unit.js

@@ -2908,14 +2908,15 @@ var createUnitClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
     joule: {
       name: 'joule',
       base: BASE_UNITS.ENERGY,
-      prefixes: PREFIXES.SHORT,
+      prefixes: PREFIXES.LONG,
       value: 1,
       offset: 0
     },
     erg: {
       name: 'erg',
       base: BASE_UNITS.ENERGY,
-      prefixes: PREFIXES.NONE,
+      prefixes: PREFIXES.SHORTLONG,
+      // Both kiloerg and kerg are acceptable
       value: 1e-7,
       offset: 0
     },

package/lib/cjs/utils/array.js

@@ -1,9 +1,16 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.arraySize = arraySize;
+exports.broadcastArrays = broadcastArrays;
+exports.broadcastSizes = broadcastSizes;
+exports.broadcastTo = broadcastTo;
+exports.checkBroadcastingRules = checkBroadcastingRules;
+exports.clone = clone;
+exports.concat = concat;
 exports.contains = contains;
 exports.filter = filter;
 exports.filterRegExp = filterRegExp;
@@ -13,6 +20,7 @@ exports.generalize = generalize;
 exports.getArrayDataType = getArrayDataType;
 exports.identify = identify;
 exports.initial = initial;
+exports.isEmptyIndex = isEmptyIndex;
 exports.join = join;
 exports.last = last;
 exports.map = map;
@@ -20,14 +28,19 @@ exports.processSizesWildcard = processSizesWildcard;
 exports.reshape = reshape;
 exports.resize = resize;
 exports.squeeze = squeeze;
+exports.stretch = stretch;
 exports.unsqueeze = unsqueeze;
 exports.validate = validate;
 exports.validateIndex = validateIndex;
+exports.validateIndexSourceSize = validateIndexSourceSize;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 var _number = require("./number.js");
 var _is = require("./is.js");
 var _string = require("./string.js");
 var _DimensionError = require("../error/DimensionError.js");
 var _IndexError = require("../error/IndexError.js");
+var _object = require("./object.js");
 /**
  * Calculate the size of a multi dimensional array.
  * This function checks the size of the first entry, it does not validate
@@ -99,6 +112,23 @@ function validate(array, size) {
   }
 }
 
+/**
+ * Validate whether the source of the index matches the size of the Array
+ * @param {Array | Matrix} array    Array to be validated
+ * @param {Index} index  Index with the source information to validate
+ * @throws DimensionError
+ */
+function validateIndexSourceSize(value, index) {
+  var valueSize = value.isMatrix ? value._size : arraySize(value);
+  var sourceSize = index._sourceSize;
+  // checks if the source size is not null and matches the valueSize
+  sourceSize.forEach(function (sourceDim, i) {
+    if (sourceDim !== null && sourceDim !== valueSize[i]) {
+      throw new _DimensionError.DimensionError(sourceDim, valueSize[i]);
+    }
+  });
+}
+
 /**
  * Test whether index is an integer number with index >= 0 and index < length
  * when length is provided
@@ -106,18 +136,44 @@ function validate(array, size) {
  * @param {number} [length] Length of the array
  */
 function validateIndex(index, length) {
-  if (!(0, _is.isNumber)(index) || !(0, _number.isInteger)(index)) {
-    throw new TypeError('Index must be an integer (value: ' + index + ')');
+  if (index !== undefined) {
+    if (!(0, _is.isNumber)(index) || !(0, _number.isInteger)(index)) {
+      throw new TypeError('Index must be an integer (value: ' + index + ')');
+    }
+    if (index < 0 || typeof length === 'number' && index >= length) {
+      throw new _IndexError.IndexError(index, length);
+    }
   }
-  if (index < 0 || typeof length === 'number' && index >= length) {
-    throw new _IndexError.IndexError(index, length);
+}
+
+/**
+ * Test if and index has empty values
+ * @param {number} index    Zero-based index
+ */
+function isEmptyIndex(index) {
+  for (var i = 0; i < index._dimensions.length; ++i) {
+    var dimension = index._dimensions[i];
+    if (dimension._data && (0, _is.isArray)(dimension._data)) {
+      if (dimension._size[0] === 0) {
+        return true;
+      }
+    } else if (dimension.isRange) {
+      if (dimension.start === dimension.end) {
+        return true;
+      }
+    } else if ((0, _is.isString)(dimension)) {
+      if (dimension.length === 0) {
+        return true;
+      }
+    }
   }
+  return false;
 }
 
 /**
  * Resize a multi dimensional array. The resized array is returned.
- * @param {Array} array         Array to be resized
- * @param {Array.<number>} size Array with the size of each dimension
+ * @param {Array | number} array         Array to be resized
+ * @param {number[]} size Array with the size of each dimension
  * @param {*} [defaultValue=0]  Value to be filled in in new entries,
  *                              zero by default. Specify for example `null`,
  *                              to clearly see entries that are not explicitly
@@ -125,10 +181,8 @@ function validateIndex(index, length) {
  * @return {Array} array         The resized array
  */
 function resize(array, size, defaultValue) {
-  // TODO: add support for scalars, having size=[] ?
-
   // check the type of the arguments
-  if (!Array.isArray(array) || !Array.isArray(size)) {
+  if (!Array.isArray(size)) {
     throw new TypeError('Array expected');
   }
   if (size.length === 0) {
@@ -142,6 +196,11 @@ function resize(array, size, defaultValue) {
     }
   });
 
+  // convert number to an array
+  if ((0, _is.isNumber)(array) || (0, _is.isBigNumber)(array)) {
+    array = [array];
+  }
+
   // recursively resize the array
   var _defaultValue = defaultValue !== undefined ? defaultValue : 0;
   _resize(array, size, 0, _defaultValue);
@@ -210,7 +269,7 @@ function _resize(array, size, dim, defaultValue) {
 /**
  * Re-shape a multi dimensional array to fit the specified dimensions
  * @param {Array} array           Array to be reshaped
- * @param {Array.<number>} sizes  List of sizes for each dimension
+ * @param {number[]} sizes        List of sizes for each dimension
  * @returns {Array}               Array whose data has been formatted to fit the
  *                                specified dimensions
  *
@@ -243,10 +302,10 @@ function reshape(array, sizes) {
 
 /**
  * Replaces the wildcard -1 in the sizes array.
- * @param {Array.<number>} sizes  List of sizes for each dimension. At most on wildcard.
+ * @param {number[]} sizes  List of sizes for each dimension. At most on wildcard.
  * @param {number} currentLength  Number of elements in the array.
  * @throws {Error}                If more than one wildcard or unable to replace it.
- * @returns {Array.<number>}      The sizes array with wildcard replaced.
+ * @returns {number[]}      The sizes array with wildcard replaced.
  */
 function processSizesWildcard(sizes, currentLength) {
   var newLength = product(sizes);
@@ -271,7 +330,7 @@ function processSizesWildcard(sizes, currentLength) {
 
 /**
  * Computes the product of all array elements.
- * @param {Array<number>} array Array of factors
+ * @param {number[]} array Array of factors
  * @returns {number}            Product of all elements
  */
 function product(array) {
@@ -283,7 +342,7 @@ function product(array) {
 /**
  * Iteratively re-shape a multi dimensional array to fit the specified dimensions
  * @param {Array} array           Array to be reshaped
- * @param {Array.<number>} sizes  List of sizes for each dimension
+ * @param {number[]} sizes  List of sizes for each dimension
  * @returns {Array}               Array whose data has been formatted to fit the
  *                                specified dimensions
  */
@@ -556,18 +615,18 @@ function getArrayDataType(array, typeOf) {
 
   for (var i = 0; i < array.length; i++) {
     var item = array[i];
-    var isArray = Array.isArray(item);
+    var _isArray = Array.isArray(item);
 
     // Saving the target matrix row size
-    if (i === 0 && isArray) {
+    if (i === 0 && _isArray) {
       length = item.length;
     }
 
     // If the current item is an array but the length does not equal the targetVectorSize
-    if (isArray && item.length !== length) {
+    if (_isArray && item.length !== length) {
       return undefined;
     }
-    var itemType = isArray ? getArrayDataType(item, typeOf) // recurse into a nested array
+    var itemType = _isArray ? getArrayDataType(item, typeOf) // recurse into a nested array
     : typeOf(item);
     if (type === undefined) {
       type = itemType; // first item
@@ -582,7 +641,7 @@ function getArrayDataType(array, typeOf) {
 
 /**
  * Return the last item from an array
- * @param array
+ * @param {array}
  * @returns {*}
  */
 function last(array) {
@@ -591,6 +650,8 @@ function last(array) {
 
 /**
  * Get all but the last element of array.
+ * @param {array}
+ * @returns {*}
  */
 function initial(array) {
   return array.slice(0, array.length - 1);
@@ -604,4 +665,177 @@ function initial(array) {
  */
 function contains(array, item) {
   return array.indexOf(item) !== -1;
+}
+
+/**
+ * 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 concatRecursive(a, b, concatDim, dim) {
+  if (dim < concatDim) {
+    // recurse into next dimension
+    if (a.length !== b.length) {
+      throw new _DimensionError.DimensionError(a.length, b.length);
+    }
+    var c = [];
+    for (var i = 0; i < a.length; i++) {
+      c[i] = concatRecursive(a[i], b[i], concatDim, dim + 1);
+    }
+    return c;
+  } else {
+    // concatenate this dimension
+    return a.concat(b);
+  }
+}
+
+/**
+ * Concatenates many arrays in the specified direction
+ * @param {...Array} arrays All the arrays to concatenate
+ * @param {number} concatDim The dimension on which to concatenate (zero-based)
+ * @returns
+*/
+function concat() {
+  var arrays = Array.prototype.slice.call(arguments, 0, -1);
+  var concatDim = Array.prototype.slice.call(arguments, -1);
+  if (arrays.length === 1) {
+    return arrays[0];
+  }
+  if (arrays.length > 1) {
+    return arrays.slice(1).reduce(function (A, B) {
+      return concatRecursive(A, B, concatDim, 0);
+    }, arrays[0]);
+  } else {
+    throw new Error('Wrong number of arguments in function concat');
+  }
+}
+
+/**
+ * Receives two or more sizes and get's the broadcasted size for both.
+ * @param  {...number[]} sizes Sizes to broadcast together
+ * @returns
+ */
+function broadcastSizes() {
+  for (var _len = arguments.length, sizes = new Array(_len), _key = 0; _key < _len; _key++) {
+    sizes[_key] = arguments[_key];
+  }
+  var dimensions = sizes.map(function (s) {
+    return s.length;
+  });
+  var N = Math.max.apply(Math, (0, _toConsumableArray2["default"])(dimensions));
+  var sizeMax = new Array(N).fill(null);
+  // check for every size
+  for (var i = 0; i < sizes.length; i++) {
+    var size = sizes[i];
+    var dim = dimensions[i];
+    for (var j = 0; j < dim; j++) {
+      var n = N - dim + j;
+      if (size[j] > sizeMax[n]) {
+        sizeMax[n] = size[j];
+      }
+    }
+  }
+  for (var _i = 0; _i < sizes.length; _i++) {
+    checkBroadcastingRules(sizes[_i], sizeMax);
+  }
+  return sizeMax;
+}
+
+/**
+ * Checks if it's possible to broadcast a size to another size
+ * @param {number[]} size The size of the array to check
+ * @param {number[]} toSize The size of the array to validate if it can be broadcasted to
+ */
+function checkBroadcastingRules(size, toSize) {
+  var N = toSize.length;
+  var dim = size.length;
+  for (var j = 0; j < dim; j++) {
+    var n = N - dim + j;
+    if (size[j] < toSize[n] && size[j] > 1 || size[j] > toSize[n]) {
+      throw new Error("shape missmatch: missmatch is found in arg with shape (".concat(size, ") not possible to broadcast dimension ").concat(dim, " with size ").concat(size[j], " to size ").concat(toSize[n]));
+    }
+  }
+}
+
+/**
+ * Broadcasts a single array to a certain size
+ * @param {array} array Array to be broadcasted
+ * @param {number[]} toSize Size to broadcast the array
+ * @returns The broadcasted array
+ */
+function broadcastTo(array, toSize) {
+  var Asize = arraySize(array);
+  if ((0, _object.deepStrictEqual)(Asize, toSize)) {
+    return array;
+  }
+  checkBroadcastingRules(Asize, toSize);
+  var broadcastedSize = broadcastSizes(Asize, toSize);
+  var N = broadcastedSize.length;
+  var paddedSize = [].concat((0, _toConsumableArray2["default"])(Array(N - Asize.length).fill(1)), (0, _toConsumableArray2["default"])(Asize));
+  var A = clone(array);
+  // reshape A if needed to make it ready for concat
+  if (Asize.length < N) {
+    A = reshape(A, paddedSize);
+    Asize = arraySize(A);
+  }
+
+  // stretches the array on each dimension to make it the same size as index
+  for (var dim = 0; dim < N; dim++) {
+    if (Asize[dim] < broadcastedSize[dim]) {
+      A = stretch(A, broadcastedSize[dim], dim);
+      Asize = arraySize(A);
+    }
+  }
+  return A;
+}
+
+/**
+ * Broadcasts arrays and returns the broadcasted arrays in an array
+ * @param  {...Array | any} arrays
+ * @returns
+ */
+function broadcastArrays() {
+  for (var _len2 = arguments.length, arrays = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+    arrays[_key2] = arguments[_key2];
+  }
+  if (arrays.length === 0) {
+    throw new Error('Insuficient number of argumnets in function broadcastArrays');
+  }
+  if (arrays.length === 1) {
+    return arrays[0];
+  }
+  var sizes = arrays.map(function (array) {
+    return arraySize(array);
+  });
+  var broadcastedSize = broadcastSizes.apply(void 0, (0, _toConsumableArray2["default"])(sizes));
+  var broadcastedArrays = [];
+  arrays.forEach(function (array) {
+    broadcastedArrays.push(broadcastTo(array, broadcastedSize));
+  });
+  return broadcastedArrays;
+}
+
+/**
+ * stretches a matrix up to a certain size in a certain dimension
+ * @param {Array} arrayToStretch
+ * @param {number[]} sizeToStretch
+ * @param {number} dimToStretch
+ * @returns
+ */
+function stretch(arrayToStretch, sizeToStretch, dimToStretch) {
+  return concat.apply(void 0, (0, _toConsumableArray2["default"])(Array(sizeToStretch).fill(arrayToStretch)).concat([dimToStretch]));
+}
+
+/**
+ * Deep clones a multidimensional array
+ * @param {Array} array
+ * @returns cloned array
+ */
+function clone(array) {
+  return (0, _extends2["default"])([], array);
 }

package/lib/cjs/utils/lruQueue.js

@@ -25,7 +25,7 @@ function lruQueue(limit) {
       base = 1;
       return;
     }
-    while (!hasOwnProperty.call(queue, ++base)) continue;
+    while (!Object.prototype.hasOwnProperty.call(queue, ++base)) {/* empty */}
   };
   limit = Math.abs(limit);
   return {
@@ -43,7 +43,7 @@ function lruQueue(limit) {
       }
       delete queue[oldIndex];
       if (base !== oldIndex) return undefined;
-      while (!hasOwnProperty.call(queue, ++base)) continue;
+      while (!Object.prototype.hasOwnProperty.call(queue, ++base)) {/* empty */}
       return undefined;
     },
     "delete": del,

package/lib/cjs/version.js

@@ -4,7 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.version = void 0;
-var version = '11.9.1';
+var version = '11.10.1';
 // Note: This file is automatically generated when building math.js.
 // Changes made in this file will be overwritten.
 exports.version = version;

package/lib/esm/entry/dependenciesAny/dependenciesIndexClass.generated.js

@@ -3,8 +3,10 @@
  * DON'T MAKE CHANGES HERE
  */
 import { ImmutableDenseMatrixDependencies } from './dependenciesImmutableDenseMatrixClass.generated.js';
+import { getMatrixDataTypeDependencies } from './dependenciesGetMatrixDataType.generated.js';
 import { createIndexClass } from '../../factoriesAny.js';
 export var IndexDependencies = {
   ImmutableDenseMatrixDependencies,
+  getMatrixDataTypeDependencies,
   createIndexClass
 };

package/lib/esm/entry/dependenciesAny/dependenciesIndexTransform.generated.js

@@ -3,8 +3,10 @@
  * DON'T MAKE CHANGES HERE
  */
 import { IndexDependencies } from './dependenciesIndexClass.generated.js';
+import { getMatrixDataTypeDependencies } from './dependenciesGetMatrixDataType.generated.js';
 import { createIndexTransform } from '../../factoriesAny.js';
 export var indexTransformDependencies = {
   IndexDependencies,
+  getMatrixDataTypeDependencies,
   createIndexTransform
 };

package/lib/esm/entry/dependenciesAny/dependenciesQuantileSeq.generated.js

@@ -4,6 +4,7 @@
  */
 import { addDependencies } from './dependenciesAdd.generated.js';
 import { compareDependencies } from './dependenciesCompare.generated.js';
+import { isIntegerDependencies } from './dependenciesIsInteger.generated.js';
 import { multiplyDependencies } from './dependenciesMultiply.generated.js';
 import { partitionSelectDependencies } from './dependenciesPartitionSelect.generated.js';
 import { typedDependencies } from './dependenciesTyped.generated.js';
@@ -11,6 +12,7 @@ import { createQuantileSeq } from '../../factoriesAny.js';
 export var quantileSeqDependencies = {
   addDependencies,
   compareDependencies,
+  isIntegerDependencies,
   multiplyDependencies,
   partitionSelectDependencies,
   typedDependencies,