mathjs 14.9.1 → 15.1.0

package/lib/cjs/function/arithmetic/nthRoots.js

@@ -79,7 +79,11 @@ const createNthRoots = exports.createNthRoots = /* #__PURE__ */(0, _factory.fact
    * Calculate the nth roots of a value.
    * An nth root of a positive real number A,
    * is a positive real solution of the equation "x^root = A".
-   * This function returns an array of complex values.
+   * This function returns an array of Complex values.
+   * Note that currently the precision of Complex numbers are limited
+   * to the precision of a 64-bit IEEE floating point, so even if the input
+   * is a BigNumber with greater precision, rounding to 64 bits will occur
+   * in computing the nth roots.
    *
    * Syntax:
    *

package/lib/cjs/function/logical/nullish.js

@@ -68,8 +68,8 @@ const createNullish = exports.createNullish = /* #__PURE__ */(0, _factory.factor
     'undefined, any': (_x, y) => y,
     // SparseMatrix-first with collection RHS: enforce exact shape match
     'SparseMatrix, Array | Matrix': (x, y) => {
-      const sx = flatten(size(x).valueOf()); // work around #3529/#3530
-      const sy = flatten(size(y).valueOf());
+      const sx = size(x);
+      const sy = size(y);
       if (deepEqual(sx, sy)) return x;
       throw new _DimensionError.DimensionError(sx, sy);
     },

package/lib/cjs/function/matrix/column.js

@@ -58,8 +58,9 @@ const createColumn = exports.createColumn = /* #__PURE__ */(0, _factory.factory)
     }
     (0, _array.validateIndex)(column, value.size()[1]);
     const rowRange = range(0, value.size()[0]);
-    const index = new Index(rowRange, column);
+    const index = new Index(rowRange, [column]);
     const result = value.subset(index);
+    // once config.legacySubset just return result
     return (0, _is.isMatrix)(result) ? result : matrix([[result]]);
   }
 });

package/lib/cjs/function/matrix/dot.js

@@ -44,8 +44,8 @@ const createDot = exports.createDot = /* #__PURE__ */(0, _factory.factory)(name,
     'SparseMatrix, SparseMatrix': _sparseDot
   });
   function _validateDim(x, y) {
-    const xSize = _size(x);
-    const ySize = _size(y);
+    const xSize = size(x);
+    const ySize = size(y);
     let xLen, yLen;
     if (xSize.length === 1) {
       xLen = xSize[0];
@@ -73,8 +73,8 @@ const createDot = exports.createDot = /* #__PURE__ */(0, _factory.factory)(name,
     const bdt = (0, _is.isMatrix)(b) ? b._datatype || b.getDataType() : undefined;
 
     // are these 2-dimensional column vectors? (as opposed to 1-dimensional vectors)
-    const aIsColumn = _size(a).length === 2;
-    const bIsColumn = _size(b).length === 2;
+    const aIsColumn = size(a).length === 2;
+    const bIsColumn = size(b).length === 2;
     let add = addScalar;
     let mul = multiplyScalar;
 
@@ -154,9 +154,4 @@ const createDot = exports.createDot = /* #__PURE__ */(0, _factory.factory)(name,
     }
     return c;
   }
-
-  // TODO remove this once #1771 is fixed
-  function _size(x) {
-    return (0, _is.isMatrix)(x) ? x.size() : size(x);
-  }
 });

package/lib/cjs/function/matrix/flatten.js

@@ -28,17 +28,20 @@ const createFlatten = exports.createFlatten = /* #__PURE__ */(0, _factory.factor
    *
    *    concat, resize, size, squeeze
    *
-   * @param {Matrix | Array} x   Matrix to be flattened
-   * @return {Matrix | Array} Returns the flattened matrix
+   * @param {DenseMatrix | Array} x   Matrix to be flattened
+   * @return {DenseMatrix | Array} Returns the flattened matrix
    */
   return typed(name, {
     Array: function (x) {
       return (0, _array.flatten)(x);
     },
-    Matrix: function (x) {
+    DenseMatrix: function (x) {
       // Return the same matrix type as x (Dense or Sparse Matrix)
       // Return the same data type as x
       return x.create((0, _array.flatten)(x.valueOf(), true), x.datatype());
+    },
+    SparseMatrix: function (_x) {
+      throw new TypeError('SparseMatrix is not supported by function flatten ' + 'because it does not support 1D vectors. ' + 'Convert to a DenseMatrix or Array first. Example: flatten(x.toArray())');
     }
   });
 });

package/lib/cjs/function/matrix/kron.js

@@ -31,7 +31,7 @@ const createKron = exports.createKron = /* #__PURE__ */(0, _factory.factory)(nam
      *    // returns [ [ 1, 2, 0, 0 ], [ 3, 4, 0, 0 ], [ 0, 0, 1, 2 ], [ 0, 0, 3, 4 ] ]
      *
      *    math.kron([1,1], [2,3,4])
-     *    // returns [ [ 2, 3, 4, 2, 3, 4 ] ]
+     *    // returns [2, 3, 4, 2, 3, 4]
      *
      * See also:
      *
@@ -55,37 +55,38 @@ const createKron = exports.createKron = /* #__PURE__ */(0, _factory.factory)(nam
   });
 
   /**
-     * Calculate the Kronecker product of two matrices / vectors
-     * @param {Array} a  First vector
-     * @param {Array} b  Second vector
-     * @returns {Array} Returns the Kronecker product of x and y
-     * @private
+   * Calculate the Kronecker product of two (1-dimensional) vectors,
+   * with no dimension checking
+   * @param {Array} a  First vector
+   * @param {Array} b  Second vector
+   * @returns {Array}  the 1-dimensional Kronecker product of a and b
+   * @private
+   */
+  function _kron1d(a, b) {
+    // TODO in core overhaul: would be faster to see if we can choose a
+    // particular implementation of multiplyScalar at the beginning,
+    // rather than re-dispatch for _every_ ordered pair of entries.
+    return a.flatMap(x => b.map(y => multiplyScalar(x, y)));
+  }
+
+  /**
+   * Calculate the Kronecker product of two possibly multidimensional arrays
+   * @param {Array} a  First array
+   * @param {Array} b  Second array
+   * @param {number} [d]  common dimension; if missing, compute and match args
+   * @returns {Array} Returns the Kronecker product of x and y
+   * @private
      */
   function _kron(a, b) {
-    // Deal with the dimensions of the matricies.
-    if ((0, _array.arraySize)(a).length === 1) {
-      // Wrap it in a 2D Matrix
-      a = [a];
-    }
-    if ((0, _array.arraySize)(b).length === 1) {
-      // Wrap it in a 2D Matrix
-      b = [b];
-    }
-    if ((0, _array.arraySize)(a).length > 2 || (0, _array.arraySize)(b).length > 2) {
-      throw new RangeError('Vectors with dimensions greater then 2 are not supported expected ' + '(Size x = ' + JSON.stringify(a.length) + ', y = ' + JSON.stringify(b.length) + ')');
+    let d = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : -1;
+    if (d < 0) {
+      let adim = (0, _array.arraySize)(a).length;
+      let bdim = (0, _array.arraySize)(b).length;
+      d = Math.max(adim, bdim);
+      while (adim++ < d) a = [a];
+      while (bdim++ < d) b = [b];
     }
-    const t = [];
-    let r = [];
-    return a.map(function (a) {
-      return b.map(function (b) {
-        r = [];
-        t.push(r);
-        return a.map(function (y) {
-          return b.map(function (x) {
-            return r.push(multiplyScalar(y, x));
-          });
-        });
-      });
-    }) && t;
+    if (d === 1) return _kron1d(a, b);
+    return a.flatMap(aSlice => b.map(bSlice => _kron(aSlice, bSlice, d - 1)));
   }
 });

package/lib/cjs/function/matrix/row.js

@@ -58,8 +58,9 @@ const createRow = exports.createRow = /* #__PURE__ */(0, _factory.factory)(name,
     }
     (0, _array.validateIndex)(row, value.size()[0]);
     const columnRange = range(0, value.size()[1]);
-    const index = new Index(row, columnRange);
+    const index = new Index([row], columnRange);
     const result = value.subset(index);
+    // once config.legacySubset just return result
     return (0, _is.isMatrix)(result) ? result : matrix([[result]]);
   }
 });

package/lib/cjs/function/matrix/size.js

@@ -6,17 +6,17 @@ Object.defineProperty(exports, "__esModule", {
 exports.createSize = void 0;
 var _array = require("../../utils/array.js");
 var _factory = require("../../utils/factory.js");
-var _noop = require("../../utils/noop.js");
 const name = 'size';
-const dependencies = ['typed', 'config', '?matrix'];
+const dependencies = ['typed'];
 const createSize = exports.createSize = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
   let {
-    typed,
-    config,
-    matrix
+    typed
   } = _ref;
   /**
-   * Calculate the size of a matrix or scalar.
+   * Calculate the size of a matrix or scalar. Always returns an Array containing numbers.
+   *
+   * Note that in mathjs v14 and older, function size could return a Matrix depending on
+   * the input type and configuration.
    *
    * Syntax:
    *
@@ -36,19 +36,13 @@ const createSize = exports.createSize = /* #__PURE__ */(0, _factory.factory)(nam
    *     count, resize, squeeze, subset
    *
    * @param {boolean | number | Complex | Unit | string | Array | Matrix} x  A matrix
-   * @return {Array | Matrix} A vector with size of `x`.
+   * @return {Array} A vector with size of `x`.
    */
   return typed(name, {
-    Matrix: function (x) {
-      return x.create(x.size(), 'number');
-    },
+    Matrix: x => x.size(),
     Array: _array.arraySize,
-    string: function (x) {
-      return config.matrix === 'Array' ? [x.length] : matrix([x.length], 'dense', 'number');
-    },
-    'number | Complex | BigNumber | Unit | boolean | null': function (x) {
-      // scalar
-      return config.matrix === 'Array' ? [] : matrix ? matrix([], 'dense', 'number') : (0, _noop.noMatrix)();
-    }
+    string: x => [x.length],
+    // scalar
+    'number | Complex | BigNumber | Unit | boolean | null': _x => []
   });
 });

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

@@ -31,8 +31,8 @@ const createSubset = exports.createSubset = /* #__PURE__ */(0, _factory.factory)
    *     // 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([false, true], 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 = []
@@ -42,9 +42,9 @@ const createSubset = exports.createSubset = /* #__PURE__ */(0, _factory.factory)
    *
    *     // get submatrix using ranges
    *     const M = [
-   *       [1,2,3],
-   *       [4,5,6],
-   *       [7,8,9]
+   *       [1, 2, 3],
+   *       [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]]
    *
@@ -123,7 +123,7 @@ const createSubset = exports.createSubset = /* #__PURE__ */(0, _factory.factory)
     if (typeof replacement === 'string') {
       throw new Error('can\'t boradcast a string');
     }
-    if (index._isScalar) {
+    if (index.isScalar()) {
       return replacement;
     }
     const indexSize = index.size();
@@ -165,9 +165,14 @@ function _getSubstring(str, index) {
   (0, _array.validateIndex)(index.max()[0], strLen);
   const range = index.dimension(0);
   let substr = '';
-  range.forEach(function (v) {
+  function callback(v) {
     substr += str.charAt(v);
-  });
+  }
+  if (Number.isInteger(range)) {
+    callback(range);
+  } else {
+    range.forEach(callback);
+  }
   return substr;
 }
 
@@ -201,7 +206,7 @@ function _setSubstring(str, index, replacement, defaultValue) {
     defaultValue = ' ';
   }
   const range = index.dimension(0);
-  const len = range.size()[0];
+  const len = Number.isInteger(range) ? 1 : range.size()[0];
   if (len !== replacement.length) {
     throw new _DimensionError.DimensionError(range.size()[0], replacement.length);
   }
@@ -216,9 +221,14 @@ function _setSubstring(str, index, replacement, defaultValue) {
   for (let i = 0; i < strLen; i++) {
     chars[i] = str.charAt(i);
   }
-  range.forEach(function (v, i) {
+  function callback(v, i) {
     chars[v] = replacement.charAt(i[0]);
-  });
+  }
+  if (Number.isInteger(range)) {
+    callback(range, [0]);
+  } else {
+    range.forEach(callback);
+  }
 
   // initialize undefined characters with a space
   if (chars.length > strLen) {

package/lib/cjs/function/probability/bernoulli.js

@@ -0,0 +1,108 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createBernoulli = void 0;
+var _factory = require("../../utils/factory.js");
+var _number = require("../../utils/number.js");
+const name = 'bernoulli';
+const dependencies = ['typed', 'config', 'isInteger', 'number', '?BigNumber', '?Fraction'];
+const createBernoulli = exports.createBernoulli = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    config,
+    number,
+    BigNumber,
+    Fraction
+  } = _ref;
+  /**
+   * Return the `n`th Bernoulli number, for positive integers `n`
+   *
+   * Syntax:
+   *
+   *     math.bernoulli(n)
+   *
+   * Examples:
+   *
+   *     math.bernoulli(1)                  // returns -0.5
+   *     // All other odd Bernoulli numbers are 0:
+   *     math.bernoulli(7)                  // returns 0
+   *     math.bernoulli(math.bignumber(6))  // value bignumber(1).div(42)
+   *     // Produces exact rationals for bigint or fraction input:
+   *     math.bernoulli(8n)                 // Fraction -1,30
+   *     math.bernoulli(math.fraction(10))  // Fraction 5,66
+   *
+   * See also:
+   *
+   *     combinations, gamma, stirlingS2
+   *
+   * @param {number | BigNumber | bigint | Fraction} n
+   *    Index of the Bernoulli number
+   * @return {number | BigNumber | Fraction}
+   *    nth Bernoulli number, of a type corresponding to the argument n
+   */
+
+  const numberCache = [undefined];
+  const fractionCache = [undefined];
+  let bigCache = [undefined];
+  let cachedPrecision = 50;
+  return typed(name, {
+    number: index => _bernoulli(index, n => n, numberCache, (a, b) => a + b, (a, b) => a * b, (a, b) => a / b),
+    'bigint | Fraction': index => _bernoulli(number(index), n => new Fraction(n), fractionCache, (a, b) => a.add(b), (a, b) => a.mul(b), (a, b) => a.div(b)),
+    BigNumber: index => {
+      if (config.precision !== cachedPrecision) {
+        bigCache = [undefined];
+        cachedPrecision = config.precision;
+      }
+      return _bernoulli(number(index), n => new BigNumber(n), bigCache, (a, b) => a.add(b), (a, b) => a.mul(b), (a, b) => a.div(b));
+    }
+  });
+});
+
+/**
+ * Underlying implementation, with all operations passed in.
+ * Parameters:
+ * 1. index: a (positive integer) number specifying which Bernoulli number
+ *    to compute.
+ * 2. promote: a function that takes an integer number and returns
+ *    the desired type for the Bernoulli number values.
+ * 3. A: a cache array of partial computation data that _bernoulli should use.
+ *    Different cache arrays should be provided for different types.
+ * 4. plus: a function that adds two values of the desired type.
+ * 5. times: a function that multiplies two values of the desired type.
+ * 6. divide: a function that divides one value of the desired type by another.
+ */
+function _bernoulli(index, promote, A, plus, times, divide) {
+  if (index < 0 || !(0, _number.isInteger)(index)) {
+    throw new RangeError('Bernoulli index must be nonnegative integer');
+  }
+  if (index === 0) return promote(1);
+  if (index === 1) return divide(promote(-1), promote(2));
+  if (index % 2 === 1) return promote(0);
+  // We proceed as in https://math.stackexchange.com/a/2844337
+  // (by no means the most efficient, but very simple to implement)
+  // A cache entry consists of a triple
+  // [cotangent coefficient a_n, prefactor, Bernouilli number B_2n]
+  const one = promote(1);
+  if (A.length === 1) {
+    A.push([divide(one, promote(-3)), divide(one, promote(-2)), divide(one, promote(6))]);
+  }
+  const half = index / 2;
+  const zero = promote(0);
+  const two = promote(2);
+  while (A.length <= half) {
+    const i = A.length; // next cotangent coefficient to compute
+    const lim = Math.floor((i + 1) / 2);
+    let a = zero;
+    for (let m = 1; m < lim; ++m) {
+      a = plus(a, times(A[m][0], A[i - m][0]));
+    }
+    a = times(a, two);
+    if (i % 2 === 0) a = plus(a, times(A[lim][0], A[lim][0]));
+    a = divide(a, promote(-(2 * i + 1)));
+    const prefactor = divide(times(A[i - 1][1], promote(-i * (2 * i - 1))), two);
+    A.push([a, prefactor, times(prefactor, a)]);
+  }
+  return A[half][2];
+}

package/lib/cjs/function/relational/equal.js

@@ -10,7 +10,7 @@ var _matAlgo07xSSf = require("../../type/matrix/utils/matAlgo07xSSf.js");
 var _matAlgo12xSfs = require("../../type/matrix/utils/matAlgo12xSfs.js");
 var _matrixAlgorithmSuite = require("../../type/matrix/utils/matrixAlgorithmSuite.js");
 const name = 'equal';
-const dependencies = ['typed', 'matrix', 'equalScalar', 'DenseMatrix', 'concat', 'SparseMatrix'];
+const dependencies = ['typed', 'matrix', 'equalScalar', 'DenseMatrix', 'SparseMatrix'];
 const createEqual = exports.createEqual = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
   let {
     typed,
@@ -33,8 +33,7 @@ const createEqual = exports.createEqual = /* #__PURE__ */(0, _factory.factory)(n
   });
   const matrixAlgorithmSuite = (0, _matrixAlgorithmSuite.createMatrixAlgorithmSuite)({
     typed,
-    matrix,
-    concat
+    matrix
   });
 
   /**

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

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.createZeta = void 0;
 var _factory = require("../../utils/factory.js");
 const name = 'zeta';
-const dependencies = ['typed', 'config', 'multiply', 'pow', 'divide', 'factorial', 'equal', 'smallerEq', 'isNegative', 'gamma', 'sin', 'subtract', 'add', '?Complex', '?BigNumber', 'pi'];
+const dependencies = ['typed', 'config', 'multiply', 'pow', 'divide', 'factorial', 'equal', 'smallerEq', 'isBounded', 'isNegative', 'gamma', 'sin', 'subtract', 'add', '?Complex', '?BigNumber', 'pi'];
 const createZeta = exports.createZeta = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
   let {
     typed,
@@ -17,6 +17,7 @@ const createZeta = exports.createZeta = /* #__PURE__ */(0, _factory.factory)(nam
     factorial,
     equal,
     smallerEq,
+    isBounded,
     isNegative,
     gamma,
     sin,
@@ -75,7 +76,7 @@ const createZeta = exports.createZeta = /* #__PURE__ */(0, _factory.factory)(nam
     if (equal(s, 1)) {
       return createValue(NaN);
     }
-    if (!isFinite(s)) {
+    if (!isBounded(s)) {
       return isNegative(s) ? createValue(NaN) : createValue(1);
     }
     return zeta(s, createValue, determineDigits, s => s);

package/lib/cjs/function/utils/isBounded.js

@@ -0,0 +1,54 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createIsBounded = void 0;
+var _factory = require("../../utils/factory.js");
+const name = 'isBounded';
+const dependencies = ['typed'];
+const createIsBounded = exports.createIsBounded = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed
+  } = _ref;
+  /**
+   * Test whether a value is bounded. For scalars, this test is equivalent
+   * to the isFinite finiteness test. On the other hand, a Matrix or Array
+   * is defined to be bounded if every entry is finite.
+   *
+   * Syntax:
+   *
+   *     math.isBounded(x)
+   *
+   * Examples:
+   *
+   *    math.isBounded(0)                        // returns true
+   *    math.isBounded(NaN)                      // returns false
+   *    math.isBounded(math.bignumber(Infinity)) // returns false
+   *    math.isBounded(math.fraction(1,3))       // returns true
+   *    math.isBounded(math.complex('2 - 4i'))   // returns true
+   *    math.isBounded(-10000000000000000n)      // returns true
+   *    math.isBounded(undefined)                // returns false
+   *    math.isBounded(null)                     // returns false
+   *    math.isBounded([0.001, -3n, 0])          // returns true
+   *    math.isBounded([2, -Infinity, -3])       // returns false
+   *
+   * See also:
+   *
+   *    isFinite, isNumeric, isPositive, isNegative, isNaN
+   *
+   * @param {number | BigNumber | bigint | Complex | Fraction | Unit | Array | Matrix} x       Value to be tested
+   * @return {boolean}  Returns true when `x` is bounded.
+   */
+  return typed(name, {
+    number: n => Number.isFinite(n),
+    'BigNumber | Complex': x => x.isFinite(),
+    'bigint | Fraction': () => true,
+    'null | undefined': () => false,
+    Unit: typed.referToSelf(self => x => self(x.value)),
+    'Array | Matrix': typed.referToSelf(self => A => {
+      if (!Array.isArray(A)) A = A.valueOf();
+      return A.every(entry => self(entry));
+    })
+  });
+});

package/lib/cjs/function/utils/isFinite.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createIsFinite = void 0;
+var _factory = require("../../utils/factory.js");
+const name = 'isFinite';
+const dependencies = ['typed', 'isBounded', 'map'];
+const createIsFinite = exports.createIsFinite = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    isBounded,
+    map
+  } = _ref;
+  /**
+   * Test whether a value is finite.
+   *
+   * Operates elementwise on Array and Matrix values. To test if all entries
+   * of an Array or Matrix are finite, use isBounded.
+   *
+   * Syntax:
+   *
+   *     math.isFinite(x)
+   *
+   * Examples:
+   *
+   *    math.isFinite(0)                        // returns true
+   *    math.isFinite(NaN)                      // returns false
+   *    math.isFinite(math.bignumber(Infinity)) // returns false
+   *    math.isFinite(math.fraction(1,3))       // returns true
+   *    math.isFinite(math.complex('2 - 4i'))   // returns true
+   *    math.isFinite(-10000000000000000n)      // returns true
+   *    math.isFinite(undefined)                // returns false
+   *    math.isFinite(null)                     // returns false
+   *    math.isFinite([0.001, -3n, 0])          // Array [true, true, true]
+   *    math.isFinite([2, -Infinity, -3])       // Array [true, false, true]
+   *
+   * See also:
+   *
+   *    isBounded isNumeric, isPositive, isNegative, isNaN
+   *
+   * @param {number | BigNumber | bigint | Complex | Fraction | Unit | Array | Matrix} x       Value to be tested
+   * @return {boolean | Array | Matrix}
+   */
+  return typed(name, {
+    'Array | Matrix': A => map(A, isBounded),
+    any: x => isBounded(x)
+  });
+});

package/lib/cjs/function/utils/isInteger.js

@@ -5,13 +5,13 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.createIsInteger = void 0;
 var _collection = require("../../utils/collection.js");
-var _number = require("../../utils/number.js");
 var _factory = require("../../utils/factory.js");
 const name = 'isInteger';
-const dependencies = ['typed'];
+const dependencies = ['typed', 'equal'];
 const createIsInteger = exports.createIsInteger = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
   let {
-    typed
+    typed,
+    equal
   } = _ref;
   /**
    * Test whether a value is an integer number.
@@ -43,18 +43,10 @@ const createIsInteger = exports.createIsInteger = /* #__PURE__ */(0, _factory.fa
    *                    Throws an error in case of an unknown data type.
    */
   return typed(name, {
-    number: _number.isInteger,
-    // TODO: what to do with isInteger(add(0.1, 0.2))  ?
-
-    BigNumber: function (x) {
-      return x.isInt();
-    },
-    bigint: function (x) {
-      return true;
-    },
-    Fraction: function (x) {
-      return x.d === 1n;
-    },
+    number: n => Number.isFinite(n) ? equal(n, Math.round(n)) : false,
+    BigNumber: b => b.isFinite() ? equal(b.round(), b) : false,
+    bigint: b => true,
+    Fraction: r => r.d === 1n,
     'Array | Matrix': typed.referToSelf(self => x => (0, _collection.deepMap)(x, self))
   });
 });

package/lib/cjs/function/utils/isNaN.js

@@ -36,7 +36,7 @@ const createIsNaN = exports.createIsNaN = /* #__PURE__ */(0, _factory.factory)(n
    *
    * See also:
    *
-   *    isNumeric, isNegative, isPositive, isZero, isInteger
+   *    isNumeric, isNegative, isPositive, isZero, isInteger, isFinite, isBounded
    *
    * @param {number | BigNumber | bigint | Fraction | Unit | Array | Matrix} x  Value to be tested
    * @return {boolean}  Returns true when `x` is NaN.

package/lib/cjs/function/utils/isNumeric.js

@@ -35,7 +35,7 @@ const createIsNumeric = exports.createIsNumeric = /* #__PURE__ */(0, _factory.fa
    *
    * See also:
    *
-   *    isZero, isPositive, isNegative, isInteger, hasNumericValue
+   *    isZero, isPositive, isNegative, isInteger, hasNumericValue, isFinite, isBounded
    *
    * @param {*} x       Value to be tested
    * @return {boolean}  Returns true when `x` is a `number`, `BigNumber`,

package/lib/cjs/header.js

@@ -6,8 +6,8 @@
  * It features real and complex numbers, units, matrices, a large set of
  * mathematical functions, and a flexible expression parser.
  *
- * @version 14.9.1
- * @date    2025-10-10
+ * @version 15.1.0
+ * @date    2025-11-05
  *
  * @license
  * Copyright (C) 2013-2025 Jos de Jong <wjosdejong@gmail.com>

package/lib/cjs/json/replacer.js

@@ -22,7 +22,7 @@ const createReplacer = exports.createReplacer = /* #__PURE__ */(0, _factory.fact
    */
   return function replacer(key, value) {
     // the numeric values Infinitiy, -Infinity, and NaN cannot be serialized to JSON
-    if (typeof value === 'number' && (!isFinite(value) || isNaN(value))) {
+    if (typeof value === 'number' && (!Number.isFinite(value) || isNaN(value))) {
       return {
         mathjs: 'number',
         value: String(value)