mathjs 15.0.0 → 15.1.0

package/lib/esm/expression/node/FunctionNode.js

@@ -100,7 +100,7 @@ export var createFunctionNode = /* #__PURE__ */factory(name, dependencies, _ref
      *     the arguments, typically a SymbolNode or AccessorNode
      * @param {./Node[]} args
      */
-    constructor(fn, args) {
+    constructor(fn, args, optional) {
       super();
       if (typeof fn === 'string') {
         fn = new SymbolNode(fn);
@@ -111,8 +111,13 @@ export var createFunctionNode = /* #__PURE__ */factory(name, dependencies, _ref
       if (!Array.isArray(args) || !args.every(isNode)) {
         throw new TypeError('Array containing Nodes expected for parameter "args"');
       }
+      var optionalType = typeof optional;
+      if (!(optionalType === 'undefined' || optionalType === 'boolean')) {
+        throw new TypeError('optional flag, if specified, must be boolean');
+      }
       this.fn = fn;
       this.args = args || [];
+      this.optional = !!optional;
     }
 
     // readonly property name
@@ -142,6 +147,7 @@ export var createFunctionNode = /* #__PURE__ */factory(name, dependencies, _ref
     _compile(math, argNames) {
       // compile arguments
       var evalArgs = this.args.map(arg => arg._compile(math, argNames));
+      var fromOptionalChaining = this.optional || isAccessorNode(this.fn) && this.fn.optionalChaining;
       if (isSymbolNode(this.fn)) {
         var _name = this.fn.name;
         if (!argNames[_name]) {
@@ -155,10 +161,8 @@ export var createFunctionNode = /* #__PURE__ */factory(name, dependencies, _ref
               value = scope.get(_name);
             } else if (_name in math) {
               value = getSafeProperty(math, _name);
-            } else {
-              return FunctionNode.onUndefinedFunction(_name);
-            }
-            if (typeof value === 'function') {
+            } else if (fromOptionalChaining) value = undefined;else return FunctionNode.onUndefinedFunction(_name);
+            if (typeof value === 'function' || fromOptionalChaining && value === undefined) {
               return value;
             }
             throw new TypeError("'".concat(_name, "' is not a function; its value is:\n  ").concat(strin(value)));
@@ -185,17 +189,20 @@ export var createFunctionNode = /* #__PURE__ */factory(name, dependencies, _ref
               case 0:
                 return function evalFunctionNode(scope, args, context) {
                   var fn = resolveFn(scope);
+                  if (fromOptionalChaining && fn === undefined) return undefined;
                   return fn();
                 };
               case 1:
                 return function evalFunctionNode(scope, args, context) {
                   var fn = resolveFn(scope);
+                  if (fromOptionalChaining && fn === undefined) return undefined;
                   var evalArg0 = evalArgs[0];
                   return fn(evalArg0(scope, args, context));
                 };
               case 2:
                 return function evalFunctionNode(scope, args, context) {
                   var fn = resolveFn(scope);
+                  if (fromOptionalChaining && fn === undefined) return undefined;
                   var evalArg0 = evalArgs[0];
                   var evalArg1 = evalArgs[1];
                   return fn(evalArg0(scope, args, context), evalArg1(scope, args, context));
@@ -203,6 +210,7 @@ export var createFunctionNode = /* #__PURE__ */factory(name, dependencies, _ref
               default:
                 return function evalFunctionNode(scope, args, context) {
                   var fn = resolveFn(scope);
+                  if (fromOptionalChaining && fn === undefined) return undefined;
                   var values = evalArgs.map(evalArg => evalArg(scope, args, context));
                   return fn(...values);
                 };
@@ -213,6 +221,7 @@ export var createFunctionNode = /* #__PURE__ */factory(name, dependencies, _ref
           var _rawArgs = this.args;
           return function evalFunctionNode(scope, args, context) {
             var fn = getSafeProperty(args, _name);
+            if (fromOptionalChaining && fn === undefined) return undefined;
             if (typeof fn !== 'function') {
               throw new TypeError("Argument '".concat(_name, "' was not a function; received: ").concat(strin(fn)));
             }
@@ -234,6 +243,11 @@ export var createFunctionNode = /* #__PURE__ */factory(name, dependencies, _ref
         var _rawArgs2 = this.args;
         return function evalFunctionNode(scope, args, context) {
           var object = evalObject(scope, args, context);
+
+          // Optional chaining: if the base object is nullish, short-circuit to undefined
+          if (fromOptionalChaining && (object == null || object[prop] === undefined)) {
+            return undefined;
+          }
           var fn = getSafeMethod(object, prop);
           if (fn !== null && fn !== void 0 && fn.rawArgs) {
             // "Raw" evaluation
@@ -253,6 +267,7 @@ export var createFunctionNode = /* #__PURE__ */factory(name, dependencies, _ref
         var _rawArgs3 = this.args;
         return function evalFunctionNode(scope, args, context) {
           var fn = evalFn(scope, args, context);
+          if (fromOptionalChaining && fn === undefined) return undefined;
           if (typeof fn !== 'function') {
             throw new TypeError("Expression '".concat(fnExpr, "' did not evaluate to a function; value is:") + "\n  ".concat(strin(fn)));
           }

package/lib/esm/expression/parse.js

@@ -129,6 +129,7 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
     '=': true,
     ':': true,
     '?': true,
+    '?.': true,
     '??': true,
     '==': true,
     '!=': true,
@@ -295,7 +296,9 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
     }
 
     // check for delimiters consisting of 2 characters
-    if (c2.length === 2 && DELIMITERS[c2]) {
+    // Special case: the check for '?.' is to prevent a case like 'a?.3:.7' from being interpreted as optional chaining
+    // TODO: refactor the tokenization into some better way to deal with cases like 'a?.3:.7', see https://github.com/josdejong/mathjs/pull/3584
+    if (c2.length === 2 && DELIMITERS[c2] && (c2 !== '?.' || !parse.isDigit(state.expression.charAt(state.index + 2)))) {
       state.tokenType = TOKENTYPE.DELIMITER;
       state.token = c2;
       next(state);
@@ -640,6 +643,9 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
         return new AssignmentNode(new SymbolNode(name), value);
       } else if (isAccessorNode(node)) {
         // parse a matrix subset assignment like 'A[1,2] = 4'
+        if (node.optionalChaining) {
+          throw createSyntaxError(state, 'Cannot assign to optional chain');
+        }
         getTokenSkipNewline(state);
         value = parseAssignment(state);
         return new AssignmentNode(node.object, node.index, value);
@@ -1254,9 +1260,9 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
 
   /**
    * parse accessors:
-   * - function invocation in round brackets (...), for example sqrt(2)
-   * - index enclosed in square brackets [...], for example A[2,3]
-   * - dot notation for properties, like foo.bar
+   * - function invocation in round brackets (...), for example sqrt(2) or sqrt?.(2) with optional chaining
+   * - index enclosed in square brackets [...], for example A[2,3] or A?.[2,3] with optional chaining
+   * - dot notation for properties, like foo.bar or foo?.bar with optional chaining
    * @param {Object} state
    * @param {Node} node    Node on which to apply the parameters. If there
    *                       are no parameters in the expression, the node
@@ -1268,12 +1274,27 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
    */
   function parseAccessors(state, node, types) {
     var params;
-    while ((state.token === '(' || state.token === '[' || state.token === '.') && (!types || types.includes(state.token))) {
+
+    // Iterate and handle chained accessors, including repeated optional chaining
+    while (true) {
       // eslint-disable-line no-unmodified-loop-condition
+      // Track whether an optional chaining operator precedes the next accessor
+      var optional = false;
+
+      // Consume an optional chaining operator if present
+      if (state.token === '?.') {
+        optional = true;
+        // consume the '?.' token
+        getToken(state);
+      }
+      var hasNextAccessor = (state.token === '(' || state.token === '[' || state.token === '.') && (!types || types.includes(state.token));
+      if (!(optional || hasNextAccessor)) {
+        break;
+      }
       params = [];
       if (state.token === '(') {
-        if (isSymbolNode(node) || isAccessorNode(node)) {
-          // function invocation like fn(2, 3) or obj.fn(2, 3)
+        if (optional || isSymbolNode(node) || isAccessorNode(node)) {
+          // function invocation: fn(2, 3) or obj.fn(2, 3) or (anything)?.(2, 3)
           openParams(state);
           getToken(state);
           if (state.token !== ')') {
@@ -1291,7 +1312,7 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
           }
           closeParams(state);
           getToken(state);
-          node = new FunctionNode(node, params);
+          node = new FunctionNode(node, params, optional);
         } else {
           // implicit multiplication like (2+3)(4+5) or sqrt(2)(1+2)
           // don't parse it here but let it be handled by parseImplicitMultiplication
@@ -1317,18 +1338,21 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
         }
         closeParams(state);
         getToken(state);
-        node = new AccessorNode(node, new IndexNode(params));
+        node = new AccessorNode(node, new IndexNode(params), optional);
       } else {
         // dot notation like variable.prop
-        getToken(state);
+        // consume the `.` (if it was ?., already consumed):
+        if (!optional) getToken(state);
         var isPropertyName = state.tokenType === TOKENTYPE.SYMBOL || state.tokenType === TOKENTYPE.DELIMITER && state.token in NAMED_DELIMITERS;
         if (!isPropertyName) {
-          throw createSyntaxError(state, 'Property name expected after dot');
+          var message = 'Property name expected after ';
+          message += optional ? 'optional chain' : 'dot';
+          throw createSyntaxError(state, message);
         }
         params.push(new ConstantNode(state.token));
         getToken(state);
         var dotNotation = true;
-        node = new AccessorNode(node, new IndexNode(params, dotNotation));
+        node = new AccessorNode(node, new IndexNode(params, dotNotation), optional);
       }
     }
     return node;

package/lib/esm/factoriesAny.js

@@ -14,6 +14,8 @@ export { createHasNumericValue } from './function/utils/hasNumericValue.js';
 export { createIsPositive } from './function/utils/isPositive.js';
 export { createIsZero } from './function/utils/isZero.js';
 export { createIsNaN } from './function/utils/isNaN.js';
+export { createIsBounded } from './function/utils/isBounded.js';
+export { createIsFinite } from './function/utils/isFinite.js';
 export { createTypeOf } from './function/utils/typeOf.js';
 export { createEqualScalar } from './function/relational/equalScalar.js';
 export { createSparseMatrixClass } from './type/matrix/SparseMatrix.js';
@@ -242,6 +244,7 @@ export { createVariance } from './function/statistics/variance.js';
 export { createQuantileSeq } from './function/statistics/quantileSeq.js';
 export { createStd } from './function/statistics/std.js';
 export { createCorr } from './function/statistics/corr.js';
+export { createBernoulli } from './function/probability/bernoulli.js';
 export { createCombinations } from './function/probability/combinations.js';
 export { createCombinationsWithRep } from './function/probability/combinationsWithRep.js';
 export { createGamma } from './function/probability/gamma.js';

package/lib/esm/factoriesNumber.js

@@ -136,6 +136,7 @@ export var createSubset = /* #__PURE__ */factory('subset', [], () => noSubset);
 export { createPartitionSelect } from './function/matrix/partitionSelect.js';
 
 // probability
+export { createBernoulli } from './function/probability/bernoulli.js';
 export var createCombinations = createNumberFactory('combinations', combinationsNumber);
 export var createGamma = createNumberFactory('gamma', gammaNumber);
 export var createLgamma = createNumberFactory('lgamma', lgammaNumber);
@@ -236,6 +237,8 @@ export { createHasNumericValue } from './function/utils/hasNumericValue.js';
 export var createIsPositive = /* #__PURE__ */createNumberFactory('isPositive', isPositiveNumber);
 export var createIsZero = /* #__PURE__ */createNumberFactory('isZero', isZeroNumber);
 export var createIsNaN = /* #__PURE__ */createNumberFactory('isNaN', isNaNNumber);
+export { createIsBounded } from './function/utils/isBounded.js';
+export { createIsFinite } from './function/utils/isFinite.js';
 export { createTypeOf } from './function/utils/typeOf.js';
 export { createIsPrime } from './function/utils/isPrime.js';
 export { createNumeric } from './function/utils/numeric.js';

package/lib/esm/function/algebra/simplifyConstant.js

@@ -4,13 +4,14 @@ import { safeNumberType } from '../../utils/number.js';
 import { createUtil } from './simplify/util.js';
 import { noBignumber, noFraction } from '../../utils/noop.js';
 var name = 'simplifyConstant';
-var dependencies = ['typed', 'config', 'mathWithTransform', 'matrix', '?fraction', '?bignumber', 'AccessorNode', 'ArrayNode', 'ConstantNode', 'FunctionNode', 'IndexNode', 'ObjectNode', 'OperatorNode', 'SymbolNode'];
+var dependencies = ['typed', 'config', 'mathWithTransform', 'matrix', 'isBounded', '?fraction', '?bignumber', 'AccessorNode', 'ArrayNode', 'ConstantNode', 'FunctionNode', 'IndexNode', 'ObjectNode', 'OperatorNode', 'SymbolNode'];
 export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     config,
     mathWithTransform,
     matrix,
+    isBounded,
     fraction,
     bignumber,
     AccessorNode,
@@ -128,7 +129,7 @@ export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _
   // and when both numerator and denominator are small enough
   function _exactFraction(n, options) {
     var exactFractions = options && options.exactFractions !== false;
-    if (exactFractions && isFinite(n) && fraction) {
+    if (exactFractions && isBounded(n) && fraction) {
       var f = fraction(n);
       var fractionsLimit = options && typeof options.fractionsLimit === 'number' ? options.fractionsLimit : Infinity; // no limit by default
 

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

@@ -73,7 +73,11 @@ export var createNthRoots = /* #__PURE__ */factory(name, dependencies, _ref => {
    * 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/esm/function/probability/bernoulli.js

@@ -0,0 +1,102 @@
+import { factory } from '../../utils/factory.js';
+import { isInteger } from '../../utils/number.js';
+var name = 'bernoulli';
+var dependencies = ['typed', 'config', 'isInteger', 'number', '?BigNumber', '?Fraction'];
+export var createBernoulli = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    config,
+    number,
+    BigNumber: _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
+   */
+
+  var numberCache = [undefined];
+  var fractionCache = [undefined];
+  var bigCache = [undefined];
+  var 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 || !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]
+  var one = promote(1);
+  if (A.length === 1) {
+    A.push([divide(one, promote(-3)), divide(one, promote(-2)), divide(one, promote(6))]);
+  }
+  var half = index / 2;
+  var zero = promote(0);
+  var two = promote(2);
+  while (A.length <= half) {
+    var i = A.length; // next cotangent coefficient to compute
+    var lim = Math.floor((i + 1) / 2);
+    var a = zero;
+    for (var 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)));
+    var 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/esm/function/relational/equal.js

@@ -4,7 +4,7 @@ import { createMatAlgo07xSSf } from '../../type/matrix/utils/matAlgo07xSSf.js';
 import { createMatAlgo12xSfs } from '../../type/matrix/utils/matAlgo12xSfs.js';
 import { createMatrixAlgorithmSuite } from '../../type/matrix/utils/matrixAlgorithmSuite.js';
 var name = 'equal';
-var dependencies = ['typed', 'matrix', 'equalScalar', 'DenseMatrix', 'concat', 'SparseMatrix'];
+var dependencies = ['typed', 'matrix', 'equalScalar', 'DenseMatrix', 'SparseMatrix'];
 export var createEqual = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
@@ -27,8 +27,7 @@ export var createEqual = /* #__PURE__ */factory(name, dependencies, _ref => {
   });
   var matrixAlgorithmSuite = createMatrixAlgorithmSuite({
     typed,
-    matrix,
-    concat
+    matrix
   });
 
   /**

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

@@ -1,6 +1,6 @@
 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'];
+var dependencies = ['typed', 'config', 'multiply', 'pow', 'divide', 'factorial', 'equal', 'smallerEq', 'isBounded', 'isNegative', 'gamma', 'sin', 'subtract', 'add', '?Complex', '?BigNumber', 'pi'];
 export var createZeta = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
@@ -11,6 +11,7 @@ export var createZeta = /* #__PURE__ */factory(name, dependencies, _ref => {
     factorial,
     equal,
     smallerEq,
+    isBounded,
     isNegative,
     gamma,
     sin,
@@ -69,7 +70,7 @@ export var createZeta = /* #__PURE__ */factory(name, dependencies, _ref => {
     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/esm/function/utils/isBounded.js

@@ -0,0 +1,48 @@
+import { factory } from '../../utils/factory.js';
+var name = 'isBounded';
+var dependencies = ['typed'];
+export var createIsBounded = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    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/esm/function/utils/isFinite.js

@@ -0,0 +1,44 @@
+import { factory } from '../../utils/factory.js';
+var name = 'isFinite';
+var dependencies = ['typed', 'isBounded', 'map'];
+export var createIsFinite = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    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/esm/function/utils/isInteger.js

@@ -1,11 +1,11 @@
 import { deepMap } from '../../utils/collection.js';
-import { isInteger as isIntegerNumber } from '../../utils/number.js';
 import { factory } from '../../utils/factory.js';
 var name = 'isInteger';
-var dependencies = ['typed'];
+var dependencies = ['typed', 'equal'];
 export var createIsInteger = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
-    typed
+    typed,
+    equal
   } = _ref;
   /**
    * Test whether a value is an integer number.
@@ -37,18 +37,10 @@ export var createIsInteger = /* #__PURE__ */factory(name, dependencies, _ref =>
    *                    Throws an error in case of an unknown data type.
    */
   return typed(name, {
-    number: isIntegerNumber,
-    // TODO: what to do with isInteger(add(0.1, 0.2))  ?
-
-    BigNumber: function BigNumber(x) {
-      return x.isInt();
-    },
-    bigint: function bigint(x) {
-      return true;
-    },
-    Fraction: function Fraction(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 => deepMap(x, self))
   });
 });

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

@@ -30,7 +30,7 @@ export var createIsNaN = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    * 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/esm/function/utils/isNumeric.js

@@ -29,7 +29,7 @@ export var createIsNumeric = /* #__PURE__ */factory(name, dependencies, _ref =>
    *
    * 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/esm/json/replacer.js

@@ -16,7 +16,7 @@ export var createReplacer = /* #__PURE__ */factory(name, dependencies, () => {
    */
   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)

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

@@ -6,7 +6,7 @@ export function gammaNumber(n) {
   var x;
   if (isInteger(n)) {
     if (n <= 0) {
-      return isFinite(n) ? Infinity : NaN;
+      return Number.isFinite(n) ? Infinity : NaN;
     }
     if (n > 171) {
       return Infinity; // Will overflow
@@ -53,7 +53,7 @@ export var lgammaSeries = [1.000000000190015, 76.18009172947146, -86.50532032941
 export 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/esm/plain/number/trigonometry.js

@@ -14,7 +14,7 @@ export function acotNumber(x) {
 }
 acotNumber.signature = n1;
 export 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;
 export function acscNumber(x) {

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

@@ -46,7 +46,7 @@ export var createFraction = /* #__PURE__ */factory(name, dependencies, _ref => {
    */
   return typed('fraction', {
     number: function number(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);