mathjs 14.9.1 → 15.1.0

package/lib/cjs/plain/number/probability.js

@@ -16,7 +16,7 @@ function gammaNumber(n) {
   let x;
   if ((0, _number.isInteger)(n)) {
     if (n <= 0) {
-      return isFinite(n) ? Infinity : NaN;
+      return Number.isFinite(n) ? Infinity : NaN;
     }
     if (n > 171) {
       return Infinity; // Will overflow
@@ -63,7 +63,7 @@ const lgammaSeries = exports.lgammaSeries = [1.000000000190015, 76.1800917294714
 function lgammaNumber(n) {
   if (n < 0) return NaN;
   if (n === 0) return Infinity;
-  if (!isFinite(n)) return n;
+  if (!Number.isFinite(n)) return n;
   if (n < 0.5) {
     // Use Euler's reflection formula:
     // gamma(z) = PI / (sin(PI * z) * gamma(1 - z))

package/lib/cjs/plain/number/trigonometry.js

@@ -44,7 +44,7 @@ function acotNumber(x) {
 }
 acotNumber.signature = n1;
 function acothNumber(x) {
-  return isFinite(x) ? (Math.log((x + 1) / x) + Math.log(x / (x - 1))) / 2 : 0;
+  return Number.isFinite(x) ? (Math.log((x + 1) / x) + Math.log(x / (x - 1))) / 2 : 0;
 }
 acothNumber.signature = n1;
 function acscNumber(x) {

package/lib/cjs/type/fraction/function/fraction.js

@@ -52,7 +52,7 @@ const createFraction = exports.createFraction = /* #__PURE__ */(0, _factory.fact
    */
   return typed('fraction', {
     number: function (x) {
-      if (!isFinite(x) || isNaN(x)) {
+      if (!Number.isFinite(x) || isNaN(x)) {
         throw new Error(x + ' cannot be represented as a fraction');
       }
       return new Fraction(x);

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

@@ -15,10 +15,11 @@ var _optimizeCallback = require("../../utils/optimizeCallback.js");
 // deno-lint-ignore-file no-this-alias
 
 const name = 'DenseMatrix';
-const dependencies = ['Matrix'];
+const dependencies = ['Matrix', 'config'];
 const createDenseMatrixClass = exports.createDenseMatrixClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
   let {
-    Matrix
+    Matrix,
+    config
   } = _ref;
   /**
    * Dense Matrix implementation. A regular, dense matrix, supporting multi-dimensional matrices. This is the default matrix type.
@@ -228,7 +229,7 @@ const createDenseMatrixClass = exports.createDenseMatrixClass = /* #__PURE__ */(
     if (!(0, _is.isIndex)(index)) {
       throw new TypeError('Invalid index');
     }
-    const isScalar = index.isScalar();
+    const isScalar = config.legacySubset ? index.size().every(idx => idx === 1) : index.isScalar();
     if (isScalar) {
       // return a scalar
       return matrix.get(index.min());
@@ -248,12 +249,12 @@ const createDenseMatrixClass = exports.createDenseMatrixClass = /* #__PURE__ */(
       }
 
       // retrieve submatrix
-      const returnMatrix = new DenseMatrix([]);
+      const returnMatrix = new DenseMatrix();
       const submatrix = _getSubmatrix(matrix._data, index);
       returnMatrix._size = submatrix.size;
       returnMatrix._datatype = matrix._datatype;
       returnMatrix._data = submatrix.data;
-      return returnMatrix;
+      return config.legacySubset ? returnMatrix.reshape(index.size()) : returnMatrix;
     }
   }
 
@@ -271,22 +272,30 @@ const createDenseMatrixClass = exports.createDenseMatrixClass = /* #__PURE__ */(
     const size = Array(maxDepth);
     return {
       data: getSubmatrixRecursive(data),
-      size
+      size: size.filter(x => x !== null)
     };
     function getSubmatrixRecursive(data) {
       let depth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-      const ranges = index.dimension(depth);
-      size[depth] = ranges.size()[0];
+      const dims = index.dimension(depth);
+      function _mapIndex(dim, callback) {
+        // applies a callback for when the index is a Number or a Matrix
+        if ((0, _is.isNumber)(dim)) return callback(dim);else return dim.map(callback).valueOf();
+      }
+      if ((0, _is.isNumber)(dims)) {
+        size[depth] = null;
+      } else {
+        size[depth] = dims.size()[0];
+      }
       if (depth < maxDepth) {
-        return ranges.map(rangeIndex => {
-          (0, _array.validateIndex)(rangeIndex, data.length);
-          return getSubmatrixRecursive(data[rangeIndex], depth + 1);
-        }).valueOf();
+        return _mapIndex(dims, dimIndex => {
+          (0, _array.validateIndex)(dimIndex, data.length);
+          return getSubmatrixRecursive(data[dimIndex], depth + 1);
+        });
       } else {
-        return ranges.map(rangeIndex => {
-          (0, _array.validateIndex)(rangeIndex, data.length);
-          return data[rangeIndex];
-        }).valueOf();
+        return _mapIndex(dims, dimIndex => {
+          (0, _array.validateIndex)(dimIndex, data.length);
+          return data[dimIndex];
+        });
       }
     }
   }
@@ -313,18 +322,18 @@ const createDenseMatrixClass = exports.createDenseMatrixClass = /* #__PURE__ */(
     const isScalar = index.isScalar();
 
     // calculate the size of the submatrix, and convert it into an Array if needed
-    let sSize;
+    let submatrixSize;
     if ((0, _is.isMatrix)(submatrix)) {
-      sSize = submatrix.size();
+      submatrixSize = submatrix.size();
       submatrix = submatrix.valueOf();
     } else {
-      sSize = (0, _array.arraySize)(submatrix);
+      submatrixSize = (0, _array.arraySize)(submatrix);
     }
     if (isScalar) {
       // set a scalar
 
       // check whether submatrix is a scalar
-      if (sSize.length !== 0) {
+      if (submatrixSize.length !== 0) {
         throw new TypeError('Scalar expected');
       }
       matrix.set(index.min(), submatrix, defaultValue);
@@ -332,26 +341,26 @@ const createDenseMatrixClass = exports.createDenseMatrixClass = /* #__PURE__ */(
       // set a submatrix
 
       // broadcast submatrix
-      if (!(0, _object.deepStrictEqual)(sSize, iSize)) {
-        try {
-          if (sSize.length === 0) {
-            submatrix = (0, _array.broadcastTo)([submatrix], iSize);
-          } else {
+      if (!(0, _object.deepStrictEqual)(submatrixSize, iSize)) {
+        if (submatrixSize.length === 0) {
+          submatrix = (0, _array.broadcastTo)([submatrix], iSize);
+        } else {
+          try {
             submatrix = (0, _array.broadcastTo)(submatrix, iSize);
-          }
-          sSize = (0, _array.arraySize)(submatrix);
-        } catch (_unused) {}
+          } catch (error) {}
+        }
+        submatrixSize = (0, _array.arraySize)(submatrix);
       }
 
       // validate dimensions
       if (iSize.length < matrix._size.length) {
         throw new _DimensionError.DimensionError(iSize.length, matrix._size.length, '<');
       }
-      if (sSize.length < iSize.length) {
+      if (submatrixSize.length < iSize.length) {
         // calculate number of missing outer dimensions
         let i = 0;
         let outer = 0;
-        while (iSize[i] === 1 && sSize[i] === 1) {
+        while (iSize[i] === 1 && submatrixSize[i] === 1) {
           i++;
         }
         while (iSize[i] === 1) {
@@ -360,12 +369,12 @@ const createDenseMatrixClass = exports.createDenseMatrixClass = /* #__PURE__ */(
         }
 
         // unsqueeze both outer and inner dimensions
-        submatrix = (0, _array.unsqueeze)(submatrix, iSize.length, outer, sSize);
+        submatrix = (0, _array.unsqueeze)(submatrix, iSize.length, outer, submatrixSize);
       }
 
       // check whether the size of the submatrix matches the index size
-      if (!(0, _object.deepStrictEqual)(iSize, sSize)) {
-        throw new _DimensionError.DimensionError(iSize, sSize, '>');
+      if (!(0, _object.deepStrictEqual)(iSize, submatrixSize)) {
+        throw new _DimensionError.DimensionError(iSize, submatrixSize, '>');
       }
 
       // enlarge matrix when needed
@@ -394,16 +403,18 @@ const createDenseMatrixClass = exports.createDenseMatrixClass = /* #__PURE__ */(
     function setSubmatrixRecursive(data, submatrix) {
       let depth = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
       const range = index.dimension(depth);
+      const recursiveCallback = (rangeIndex, i) => {
+        (0, _array.validateIndex)(rangeIndex, data.length);
+        setSubmatrixRecursive(data[rangeIndex], submatrix[i[0]], depth + 1);
+      };
+      const finalCallback = (rangeIndex, i) => {
+        (0, _array.validateIndex)(rangeIndex, data.length);
+        data[rangeIndex] = submatrix[i[0]];
+      };
       if (depth < maxDepth) {
-        range.forEach((rangeIndex, i) => {
-          (0, _array.validateIndex)(rangeIndex, data.length);
-          setSubmatrixRecursive(data[rangeIndex], submatrix[i[0]], depth + 1);
-        });
+        if ((0, _is.isNumber)(range)) recursiveCallback(range, [0]);else range.forEach(recursiveCallback);
       } else {
-        range.forEach((rangeIndex, i) => {
-          (0, _array.validateIndex)(rangeIndex, data.length);
-          data[rangeIndex] = submatrix[i[0]];
-        });
+        if ((0, _is.isNumber)(range)) finalCallback(range, [0]);else range.forEach(finalCallback);
       }
     }
   }

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

@@ -37,7 +37,7 @@ const createIndexClass = exports.createIndexClass = /* #__PURE__ */(0, _factory.
    * @Constructor Index
    * @param {...*} ranges
    */
-  function Index(ranges) {
+  function Index() {
     if (!(this instanceof Index)) {
       throw new SyntaxError('Constructor must be called with the new operator');
     }
@@ -45,7 +45,7 @@ const createIndexClass = exports.createIndexClass = /* #__PURE__ */(0, _factory.
     this._sourceSize = [];
     this._isScalar = true;
     for (let i = 0, ii = arguments.length; i < ii; i++) {
-      const arg = arguments[i];
+      const arg = i < 0 || arguments.length <= i ? undefined : arguments[i];
       const argIsArray = (0, _is.isArray)(arg);
       const argIsMatrix = (0, _is.isMatrix)(arg);
       const argType = typeof arg;
@@ -56,6 +56,7 @@ const createIndexClass = exports.createIndexClass = /* #__PURE__ */(0, _factory.
       } else if (argIsArray || argIsMatrix) {
         // create matrix
         let m;
+        this._isScalar = false;
         if (getMatrixDataType(arg) === 'boolean') {
           if (argIsArray) m = _createImmutableMatrix(_booleansArrayToNumbersForIndex(arg).valueOf());
           if (argIsMatrix) m = _createImmutableMatrix(_booleansArrayToNumbersForIndex(arg._data).valueOf());
@@ -64,16 +65,10 @@ const createIndexClass = exports.createIndexClass = /* #__PURE__ */(0, _factory.
           m = _createImmutableMatrix(arg.valueOf());
         }
         this._dimensions.push(m);
-        // size
-        const size = m.size();
-        // scalar
-        if (size.length !== 1 || size[0] !== 1 || sourceSize !== null) {
-          this._isScalar = false;
-        }
       } else if (argType === 'number') {
-        this._dimensions.push(_createImmutableMatrix([arg]));
+        this._dimensions.push(arg);
       } else if (argType === 'bigint') {
-        this._dimensions.push(_createImmutableMatrix([Number(arg)]));
+        this._dimensions.push(Number(arg));
       } else if (argType === 'string') {
         // object property (arguments.count should be 1)
         this._dimensions.push(arg);
@@ -93,12 +88,15 @@ const createIndexClass = exports.createIndexClass = /* #__PURE__ */(0, _factory.
   function _createImmutableMatrix(arg) {
     // loop array elements
     for (let i = 0, l = arg.length; i < l; i++) {
-      if (typeof arg[i] !== 'number' || !(0, _number.isInteger)(arg[i])) {
+      if (!(0, _is.isNumber)(arg[i]) || !(0, _number.isInteger)(arg[i])) {
         throw new TypeError('Index parameters must be positive integer numbers');
       }
     }
     // create matrix
-    return new ImmutableDenseMatrix(arg);
+    const matrix = new ImmutableDenseMatrix();
+    matrix._data = arg;
+    matrix._size = [arg.length];
+    return matrix;
   }
 
   /**
@@ -136,7 +134,7 @@ const createIndexClass = exports.createIndexClass = /* #__PURE__ */(0, _factory.
     const size = [];
     for (let i = 0, ii = this._dimensions.length; i < ii; i++) {
       const d = this._dimensions[i];
-      size[i] = typeof d === 'string' ? 1 : d.size()[0];
+      size[i] = (0, _is.isString)(d) || (0, _is.isNumber)(d) ? 1 : d.size()[0];
     }
     return size;
   };
@@ -150,7 +148,7 @@ const createIndexClass = exports.createIndexClass = /* #__PURE__ */(0, _factory.
     const values = [];
     for (let i = 0, ii = this._dimensions.length; i < ii; i++) {
       const range = this._dimensions[i];
-      values[i] = typeof range === 'string' ? range : range.max();
+      values[i] = (0, _is.isString)(range) || (0, _is.isNumber)(range) ? range : range.max();
     }
     return values;
   };
@@ -164,7 +162,7 @@ const createIndexClass = exports.createIndexClass = /* #__PURE__ */(0, _factory.
     const values = [];
     for (let i = 0, ii = this._dimensions.length; i < ii; i++) {
       const range = this._dimensions[i];
-      values[i] = typeof range === 'string' ? range : range.min();
+      values[i] = (0, _is.isString)(range) || (0, _is.isNumber)(range) ? range : range.min();
     }
     return values;
   };
@@ -189,10 +187,11 @@ const createIndexClass = exports.createIndexClass = /* #__PURE__ */(0, _factory.
    * @returns {Range | null} range
    */
   Index.prototype.dimension = function (dim) {
-    if (typeof dim !== 'number') {
+    var _this$_dimensions$dim;
+    if (!(0, _is.isNumber)(dim)) {
       return null;
     }
-    return this._dimensions[dim] || null;
+    return (_this$_dimensions$dim = this._dimensions[dim]) !== null && _this$_dimensions$dim !== void 0 ? _this$_dimensions$dim : null;
   };
 
   /**
@@ -200,7 +199,7 @@ const createIndexClass = exports.createIndexClass = /* #__PURE__ */(0, _factory.
    * @returns {boolean} Returns true if the index is an object property
    */
   Index.prototype.isObjectProperty = function () {
-    return this._dimensions.length === 1 && typeof this._dimensions[0] === 'string';
+    return this._dimensions.length === 1 && (0, _is.isString)(this._dimensions[0]);
   };
 
   /**
@@ -234,7 +233,7 @@ const createIndexClass = exports.createIndexClass = /* #__PURE__ */(0, _factory.
     const array = [];
     for (let i = 0, ii = this._dimensions.length; i < ii; i++) {
       const dimension = this._dimensions[i];
-      array.push(typeof dimension === 'string' ? dimension : dimension.toArray());
+      array.push((0, _is.isString)(dimension) || (0, _is.isNumber)(dimension) ? dimension : dimension.toArray());
     }
     return array;
   };
@@ -256,7 +255,7 @@ const createIndexClass = exports.createIndexClass = /* #__PURE__ */(0, _factory.
     const strings = [];
     for (let i = 0, ii = this._dimensions.length; i < ii; i++) {
       const dimension = this._dimensions[i];
-      if (typeof dimension === 'string') {
+      if ((0, _is.isString)(dimension)) {
         strings.push(JSON.stringify(dimension));
       } else {
         strings.push(dimension.toString());

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

@@ -21,9 +21,27 @@ const createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ *
     Matrix
   } = _ref;
   /**
-   * Sparse Matrix implementation. This type implements
-   * a [Compressed Column Storage](https://en.wikipedia.org/wiki/Sparse_matrix#Compressed_sparse_column_(CSC_or_CCS))
-   * format for two-dimensional sparse matrices.
+   * Sparse Matrix implementation. This type (currently) implements 2D
+   * matrices only via the format known as
+   * [Compressed Column Storage](https://en.wikipedia.org/wiki/Sparse_matrix#Compressed_sparse_column_(CSC_or_CCS)).
+   *
+   * The structure/invariants of the internal data should be:
+   * 1. _values is an array of the nonzero values in order from top to bottom
+   *    (of each column), left to right.
+   * 2. _index is an array of row numbers, of the same length as and
+   *    corresponding positionally to _values.
+   * 3. _ptr is an array of length one more than the number of columns. For j
+   *    less than the number of columns, the "half-open" span of indices
+   *    _ptr[j] to _ptr[j+1] (i.e. including _ptr[j] if it is less than
+   *    _ptr[j+1], but never including _ptr[j+1]) are the indices in _values
+   *    of the nonzero elements in column j. Note there are no nonzero elements
+   *    in column j exactly when _ptr[j] === _ptr[j+1], and that the final
+   *    entry in _ptr is always exactly the number of nonzero entries in the
+   *    matrix.
+   * 4. _size is a length-2 array consisting of the number of rows followed by
+   *    the number of columns.
+   * 5. _datatype, if set, is the mathjs typeOf value of all entries of the
+   *    SparseMatrix.
    * @class SparseMatrix
    */
   function SparseMatrix(data, datatype) {
@@ -141,7 +159,9 @@ const createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ *
       } while (j < columns);
     }
     // store number of values in ptr
-    matrix._ptr.push(matrix._index.length);
+    while (matrix._ptr.length <= columns) {
+      matrix._ptr.push(matrix._index.length);
+    }
     // size
     matrix._size = [rows, columns];
   }
@@ -304,12 +324,13 @@ const createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ *
     const pv = [];
 
     // loop rows in resulting matrix
-    rows.forEach(function (i, r) {
+    function rowsCallback(i, r) {
       // update permutation vector
       pv[i] = r[0];
       // mark i in workspace
       w[i] = true;
-    });
+    }
+    if (Number.isInteger(rows)) rowsCallback(rows, [0]);else rows.forEach(rowsCallback);
 
     // result matrix arrays
     const values = mvalues ? [] : undefined;
@@ -317,7 +338,7 @@ const createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ *
     const ptr = [];
 
     // loop columns in result matrix
-    columns.forEach(function (j) {
+    function columnsCallback(j) {
       // update ptr
       ptr.push(index.length);
       // loop values in column j
@@ -334,7 +355,8 @@ const createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ *
           }
         }
       }
-    });
+    }
+    if (Number.isInteger(columns)) columnsCallback(columns);else columns.forEach(columnsCallback);
     // update ptr
     ptr.push(index.length);
 
@@ -408,7 +430,7 @@ const createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ *
       if (iSize.length === 1) {
         // if the replacement index only has 1 dimension, go trough each one and set its value
         const range = index.dimension(0);
-        range.forEach(function (dataIndex, subIndex) {
+        _forEachIndex(range, (dataIndex, subIndex) => {
           (0, _array.validateIndex)(dataIndex);
           matrix.set([dataIndex, 0], submatrix[subIndex[0]], defaultValue);
         });
@@ -416,9 +438,9 @@ const createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ *
         // if the replacement index has 2 dimensions, go through each one and set the value in the correct index
         const firstDimensionRange = index.dimension(0);
         const secondDimensionRange = index.dimension(1);
-        firstDimensionRange.forEach(function (firstDataIndex, firstSubIndex) {
+        _forEachIndex(firstDimensionRange, (firstDataIndex, firstSubIndex) => {
           (0, _array.validateIndex)(firstDataIndex);
-          secondDimensionRange.forEach(function (secondDataIndex, secondSubIndex) {
+          _forEachIndex(secondDimensionRange, (secondDataIndex, secondSubIndex) => {
             (0, _array.validateIndex)(secondDataIndex);
             matrix.set([firstDataIndex, secondDataIndex], submatrix[firstSubIndex[0]][secondSubIndex[0]], defaultValue);
           });
@@ -426,6 +448,10 @@ const createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ *
       }
     }
     return matrix;
+    function _forEachIndex(index, callback) {
+      // iterate cases where index is a Matrix or a Number
+      if ((0, _is.isNumber)(index)) callback(index, [0]);else index.forEach(callback);
+    }
   }
 
   /**

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

@@ -13,7 +13,7 @@ var _string = require("../../utils/string.js");
 var _object = require("../../utils/object.js");
 var _constants = require("../../utils/bignumber/constants.js");
 const name = 'Unit';
-const dependencies = ['?on', 'config', 'addScalar', 'subtractScalar', 'multiplyScalar', 'divideScalar', 'pow', 'abs', 'fix', 'round', 'equal', 'isNumeric', 'format', 'toBest', 'number', 'Complex', 'BigNumber', 'Fraction'];
+const dependencies = ['?on', 'config', 'addScalar', 'subtractScalar', 'multiplyScalar', 'divideScalar', 'pow', 'abs', 'fix', 'round', 'equal', 'isNumeric', 'format', 'number', 'Complex', 'BigNumber', 'Fraction'];
 const createUnitClass = exports.createUnitClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
   let {
     on,
@@ -29,13 +29,15 @@ const createUnitClass = exports.createUnitClass = /* #__PURE__ */(0, _factory.fa
     equal,
     isNumeric,
     format,
-    toBest,
     number,
     Complex,
     BigNumber,
     Fraction
   } = _ref;
   const toNumber = number;
+  const fixPrefixDefault = false;
+  const skipAutomaticSimplificationDefault = true;
+
   /**
    * A unit can be constructed in the following ways:
    *
@@ -62,13 +64,13 @@ const createUnitClass = exports.createUnitClass = /* #__PURE__ */(0, _factory.fa
     if (!(value === null || value === undefined || isNumeric(value) || (0, _is.isComplex)(value))) {
       throw new TypeError('First parameter in Unit constructor must be number, BigNumber, Fraction, Complex, or undefined');
     }
-    this.fixPrefix = false; // if true, function format will not search for the
+    this.fixPrefix = fixPrefixDefault; // if true, function format will not search for the
     // best prefix but leave it as initially provided.
     // fixPrefix is set true by the method Unit.to
 
     // The justification behind this is that if the constructor is explicitly called,
     // the caller wishes the units to be returned exactly as supplied.
-    this.skipAutomaticSimplification = true;
+    this.skipAutomaticSimplification = skipAutomaticSimplificationDefault;
     if (valuelessUnit === undefined) {
       this.units = [];
       this.dimensions = BASE_DIMENSIONS.map(x => 0);
@@ -862,14 +864,15 @@ const createUnitClass = exports.createUnitClass = /* #__PURE__ */(0, _factory.fa
    * Get a JSON representation of the unit
    * @memberof Unit
    * @returns {Object} Returns a JSON object structured as:
-   *                   `{"mathjs": "Unit", "value": 2, "unit": "cm", "fixPrefix": false}`
+   *                   `{"mathjs": "Unit", "value": 2, "unit": "cm", "fixPrefix": false, "skipSimp": true}`
    */
   Unit.prototype.toJSON = function () {
     return {
       mathjs: 'Unit',
       value: this._denormalize(this.value),
       unit: this.units.length > 0 ? this.formatUnits() : null,
-      fixPrefix: this.fixPrefix
+      fixPrefix: this.fixPrefix,
+      skipSimp: this.skipAutomaticSimplification
     };
   };
 
@@ -881,9 +884,10 @@ const createUnitClass = exports.createUnitClass = /* #__PURE__ */(0, _factory.fa
    * @return {Unit}
    */
   Unit.fromJSON = function (json) {
-    var _json$unit;
+    var _json$unit, _json$fixPrefix, _json$skipSimp;
     const unit = new Unit(json.value, (_json$unit = json.unit) !== null && _json$unit !== void 0 ? _json$unit : undefined);
-    unit.fixPrefix = json.fixPrefix || false;
+    unit.fixPrefix = (_json$fixPrefix = json.fixPrefix) !== null && _json$fixPrefix !== void 0 ? _json$fixPrefix : fixPrefixDefault;
+    unit.skipAutomaticSimplification = (_json$skipSimp = json.skipSimp) !== null && _json$skipSimp !== void 0 ? _json$skipSimp : skipAutomaticSimplificationDefault;
     return unit;
   };
 

package/lib/cjs/utils/number.js

@@ -36,7 +36,7 @@ function isInteger(value) {
   if (typeof value === 'boolean') {
     return true;
   }
-  return isFinite(value) ? value === Math.round(value) : false;
+  return Number.isFinite(value) ? value === Math.round(value) : false;
 }
 
 /**
@@ -128,7 +128,7 @@ const cbrt = exports.cbrt = Math.cbrt || function cbrt(x) {
   if (negate) {
     x = -x;
   }
-  if (isFinite(x)) {
+  if (Number.isFinite(x)) {
     result = Math.exp(Math.log(x) / 3);
     // from https://en.wikipedia.org/wiki/Cube_root#Numerical_methods
     result = (x / (result * result) + 2 * result) / 3;
@@ -404,7 +404,7 @@ function splitNumber(value) {
  * @param {number} [precision]        Optional number of significant figures to return.
  */
 function toEngineering(value, precision) {
-  if (isNaN(value) || !isFinite(value)) {
+  if (isNaN(value) || !Number.isFinite(value)) {
     return String(value);
   }
   const split = splitNumber(value);
@@ -453,7 +453,7 @@ function toEngineering(value, precision) {
  *                                        decimal point. null by default.
  */
 function toFixed(value, precision) {
-  if (isNaN(value) || !isFinite(value)) {
+  if (isNaN(value) || !Number.isFinite(value)) {
     return String(value);
   }
   const splitValue = splitNumber(value);
@@ -488,7 +488,7 @@ function toFixed(value, precision) {
  *                              is used.
  */
 function toExponential(value, precision) {
-  if (isNaN(value) || !isFinite(value)) {
+  if (isNaN(value) || !Number.isFinite(Number(value))) {
     return String(value);
   }
 
@@ -519,7 +519,7 @@ function toExponential(value, precision) {
  * @return {string}
  */
 function toPrecision(value, precision, options) {
-  if (isNaN(value) || !isFinite(value)) {
+  if (isNaN(value) || !Number.isFinite(value)) {
     return String(value);
   }
 
@@ -658,7 +658,7 @@ function nearlyEqual(a, b) {
   if (isNaN(a) || isNaN(b)) {
     return false;
   }
-  if (!isFinite(a) || !isFinite(b)) {
+  if (!Number.isFinite(a) || !Number.isFinite(b)) {
     return a === b;
   }
   if (a === b) {

package/lib/cjs/utils/optimizeCallback.js

@@ -23,7 +23,19 @@ function optimizeCallback(callback, array, name, isUnary) {
     if (isUnary) {
       numberOfArguments = 1;
     } else {
-      const firstIndex = (array.isMatrix ? array.size() : (0, _array.arraySize)(array)).map(() => 0);
+      const size = array.isMatrix ? array.size() : (0, _array.arraySize)(array);
+
+      // Check the size of the last dimension to see if the array/matrix is empty
+      const isEmpty = size.length ? size[size.length - 1] === 0 : true;
+      if (isEmpty) {
+        // don't optimize callbacks for empty arrays/matrix, as they will never be called
+        // and in fact will throw an exception when we try to access the first element below
+        return {
+          isUnary,
+          fn: callback
+        };
+      }
+      const firstIndex = size.map(() => 0);
       const firstValue = array.isMatrix ? array.get(firstIndex) : (0, _array.get)(array, firstIndex);
       numberOfArguments = _findNumberOfArgumentsTyped(callback, firstValue, firstIndex, array);
     }

package/lib/cjs/version.js

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

package/lib/esm/core/config.js

@@ -21,5 +21,9 @@ export var DEFAULT_CONFIG = {
   predictable: false,
   // random seed for seeded pseudo random number generation
   // null = randomly seed
-  randomSeed: null
+  randomSeed: null,
+  // legacy behavior for matrix subset. When true, the subset function
+  // returns a matrix or array with the same size as the index (except for scalars).
+  // When false, it returns a matrix or array with a size depending on the type of index.
+  legacySubset: false
 };

package/lib/esm/core/function/config.js

@@ -59,6 +59,10 @@ export function configFactory(config, emit) {
         delete optionsFix.epsilon;
         return _config(optionsFix);
       }
+      if (options.legacySubset === true) {
+        // this if is only for backwards compatibility, it can be removed in the future.
+        console.warn('Warning: The configuration option "legacySubset" is for compatibility only and might be deprecated in the future.');
+      }
       var prev = clone(config);
 
       // validate some of the options

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

@@ -0,0 +1,18 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+import { BigNumberDependencies } from './dependenciesBigNumberClass.generated.js';
+import { FractionDependencies } from './dependenciesFractionClass.generated.js';
+import { isIntegerDependencies } from './dependenciesIsInteger.generated.js';
+import { numberDependencies } from './dependenciesNumber.generated.js';
+import { typedDependencies } from './dependenciesTyped.generated.js';
+import { createBernoulli } from '../../factoriesAny.js';
+export var bernoulliDependencies = {
+  BigNumberDependencies,
+  FractionDependencies,
+  isIntegerDependencies,
+  numberDependencies,
+  typedDependencies,
+  createBernoulli
+};