mathjs 15.0.0 → 15.1.1

package/lib/cjs/expression/node/AccessorNode.js

@@ -38,8 +38,13 @@ const createAccessorNode = exports.createAccessorNode = /* #__PURE__ */(0, _fact
      * @param {Node} object                 The object from which to retrieve
      *                                      a property or subset.
      * @param {IndexNode} index             IndexNode containing ranges
+     * @param {boolean} [optionalChaining=false]
+     *     Optional property, if the accessor was written as optional-chaining
+     *     using `a?.b`, or `a?.["b"] with bracket notation.
+     *     Forces evaluate to undefined if the given object is undefined or null.
      */
     constructor(object, index) {
+      let optionalChaining = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
       super();
       if (!(0, _is.isNode)(object)) {
         throw new TypeError('Node expected for parameter "object"');
@@ -49,6 +54,7 @@ const createAccessorNode = exports.createAccessorNode = /* #__PURE__ */(0, _fact
       }
       this.object = object;
       this.index = index;
+      this.optionalChaining = optionalChaining;
     }
 
     // readonly property name
@@ -82,15 +88,36 @@ const createAccessorNode = exports.createAccessorNode = /* #__PURE__ */(0, _fact
     _compile(math, argNames) {
       const evalObject = this.object._compile(math, argNames);
       const evalIndex = this.index._compile(math, argNames);
+      const optionalChaining = this.optionalChaining;
+      const prevOptionalChaining = (0, _is.isAccessorNode)(this.object) && this.object.optionalChaining;
       if (this.index.isObjectProperty()) {
         const prop = this.index.getObjectProperty();
         return function evalAccessorNode(scope, args, context) {
+          const ctx = context || {};
+          const object = evalObject(scope, args, ctx);
+          if (optionalChaining && object == null) {
+            ctx.optionalShortCircuit = true;
+            return undefined;
+          }
+          if (prevOptionalChaining && ctx !== null && ctx !== void 0 && ctx.optionalShortCircuit) {
+            return undefined;
+          }
+
           // get a property from an object evaluated using the scope.
-          return (0, _customs.getSafeProperty)(evalObject(scope, args, context), prop);
+          return (0, _customs.getSafeProperty)(object, prop);
         };
       } else {
         return function evalAccessorNode(scope, args, context) {
-          const object = evalObject(scope, args, context);
+          const ctx = context || {};
+          const object = evalObject(scope, args, ctx);
+          if (optionalChaining && object == null) {
+            ctx.optionalShortCircuit = true;
+            return undefined;
+          }
+          if (prevOptionalChaining && ctx !== null && ctx !== void 0 && ctx.optionalShortCircuit) {
+            return undefined;
+          }
+
           // we pass just object here instead of context:
           const index = evalIndex(scope, args, object);
           return access(object, index);
@@ -114,7 +141,7 @@ const createAccessorNode = exports.createAccessorNode = /* #__PURE__ */(0, _fact
      * @returns {AccessorNode} Returns a transformed copy of the node
      */
     map(callback) {
-      return new AccessorNode(this._ifNode(callback(this.object, 'object', this)), this._ifNode(callback(this.index, 'index', this)));
+      return new AccessorNode(this._ifNode(callback(this.object, 'object', this)), this._ifNode(callback(this.index, 'index', this)), this.optionalChaining);
     }
 
     /**
@@ -122,7 +149,7 @@ const createAccessorNode = exports.createAccessorNode = /* #__PURE__ */(0, _fact
      * @return {AccessorNode}
      */
     clone() {
-      return new AccessorNode(this.object, this.index);
+      return new AccessorNode(this.object, this.index, this.optionalChaining);
     }
 
     /**
@@ -135,7 +162,8 @@ const createAccessorNode = exports.createAccessorNode = /* #__PURE__ */(0, _fact
       if (needParenthesis(this.object)) {
         object = '(' + object + ')';
       }
-      return object + this.index.toString(options);
+      const optionalChaining = this.optionalChaining ? this.index.dotNotation ? '?' : '?.' : '';
+      return object + optionalChaining + this.index.toString(options);
     }
 
     /**
@@ -172,7 +200,8 @@ const createAccessorNode = exports.createAccessorNode = /* #__PURE__ */(0, _fact
       return {
         mathjs: name,
         object: this.object,
-        index: this.index
+        index: this.index,
+        optionalChaining: this.optionalChaining
       };
     }
 
@@ -185,7 +214,7 @@ const createAccessorNode = exports.createAccessorNode = /* #__PURE__ */(0, _fact
      * @returns {AccessorNode}
      */
     static fromJSON(json) {
-      return new AccessorNode(json.object, json.index);
+      return new AccessorNode(json.object, json.index, json.optionalChaining);
     }
   }
   (0, _defineProperty2.default)(AccessorNode, "name", name);

package/lib/cjs/expression/node/ConstantNode.js

@@ -11,10 +11,11 @@ var _is = require("../../utils/is.js");
 var _latex = require("../../utils/latex.js");
 var _factory = require("../../utils/factory.js");
 const name = 'ConstantNode';
-const dependencies = ['Node'];
+const dependencies = ['Node', 'isBounded'];
 const createConstantNode = exports.createConstantNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
   let {
-    Node
+    Node,
+    isBounded
   } = _ref;
   class ConstantNode extends Node {
     /**
@@ -157,8 +158,7 @@ const createConstantNode = exports.createConstantNode = /* #__PURE__ */(0, _fact
         case 'number':
         case 'BigNumber':
           {
-            const finite = type === 'BigNumber' ? this.value.isFinite() : isFinite(this.value);
-            if (!finite) {
+            if (!isBounded(this.value)) {
               return this.value.valueOf() < 0 ? '-\\infty' : '\\infty';
             }
             const index = value.toLowerCase().indexOf('e');

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

@@ -107,7 +107,7 @@ const createFunctionNode = exports.createFunctionNode = /* #__PURE__ */(0, _fact
      *     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);
@@ -118,8 +118,13 @@ const createFunctionNode = exports.createFunctionNode = /* #__PURE__ */(0, _fact
       if (!Array.isArray(args) || !args.every(_is.isNode)) {
         throw new TypeError('Array containing Nodes expected for parameter "args"');
       }
+      const 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
@@ -149,6 +154,7 @@ const createFunctionNode = exports.createFunctionNode = /* #__PURE__ */(0, _fact
     _compile(math, argNames) {
       // compile arguments
       const evalArgs = this.args.map(arg => arg._compile(math, argNames));
+      const fromOptionalChaining = this.optional || (0, _is.isAccessorNode)(this.fn) && this.fn.optionalChaining;
       if ((0, _is.isSymbolNode)(this.fn)) {
         const name = this.fn.name;
         if (!argNames[name]) {
@@ -162,10 +168,8 @@ const createFunctionNode = exports.createFunctionNode = /* #__PURE__ */(0, _fact
               value = scope.get(name);
             } else if (name in math) {
               value = (0, _customs.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(`'${name}' is not a function; its value is:\n  ${strin(value)}`);
@@ -192,17 +196,20 @@ const createFunctionNode = exports.createFunctionNode = /* #__PURE__ */(0, _fact
               case 0:
                 return function evalFunctionNode(scope, args, context) {
                   const fn = resolveFn(scope);
+                  if (fromOptionalChaining && fn === undefined) return undefined;
                   return fn();
                 };
               case 1:
                 return function evalFunctionNode(scope, args, context) {
                   const fn = resolveFn(scope);
+                  if (fromOptionalChaining && fn === undefined) return undefined;
                   const evalArg0 = evalArgs[0];
                   return fn(evalArg0(scope, args, context));
                 };
               case 2:
                 return function evalFunctionNode(scope, args, context) {
                   const fn = resolveFn(scope);
+                  if (fromOptionalChaining && fn === undefined) return undefined;
                   const evalArg0 = evalArgs[0];
                   const evalArg1 = evalArgs[1];
                   return fn(evalArg0(scope, args, context), evalArg1(scope, args, context));
@@ -210,6 +217,7 @@ const createFunctionNode = exports.createFunctionNode = /* #__PURE__ */(0, _fact
               default:
                 return function evalFunctionNode(scope, args, context) {
                   const fn = resolveFn(scope);
+                  if (fromOptionalChaining && fn === undefined) return undefined;
                   const values = evalArgs.map(evalArg => evalArg(scope, args, context));
                   return fn(...values);
                 };
@@ -220,6 +228,7 @@ const createFunctionNode = exports.createFunctionNode = /* #__PURE__ */(0, _fact
           const rawArgs = this.args;
           return function evalFunctionNode(scope, args, context) {
             const fn = (0, _customs.getSafeProperty)(args, name);
+            if (fromOptionalChaining && fn === undefined) return undefined;
             if (typeof fn !== 'function') {
               throw new TypeError(`Argument '${name}' was not a function; received: ${strin(fn)}`);
             }
@@ -241,6 +250,11 @@ const createFunctionNode = exports.createFunctionNode = /* #__PURE__ */(0, _fact
         const rawArgs = this.args;
         return function evalFunctionNode(scope, args, context) {
           const 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;
+          }
           const fn = (0, _customs.getSafeMethod)(object, prop);
           if (fn !== null && fn !== void 0 && fn.rawArgs) {
             // "Raw" evaluation
@@ -260,6 +274,7 @@ const createFunctionNode = exports.createFunctionNode = /* #__PURE__ */(0, _fact
         const rawArgs = this.args;
         return function evalFunctionNode(scope, args, context) {
           const fn = evalFn(scope, args, context);
+          if (fromOptionalChaining && fn === undefined) return undefined;
           if (typeof fn !== 'function') {
             throw new TypeError(`Expression '${fnExpr}' did not evaluate to a function; value is:` + `\n  ${strin(fn)}`);
           }

package/lib/cjs/expression/parse.js

@@ -68,6 +68,23 @@ const createParse = exports.createParse = /* #__PURE__ */(0, _factory.factory)(n
    *
    *     evaluate, compile
    *
+   * History:
+   *
+   *     v0.9   Created
+   *     v0.13  Switched to one-based indices
+   *     v0.14  Added `[1,2;3,4]` notation for matrices
+   *     v0.18  Dropped the `function` keyword
+   *     v0.20  Added ternary conditional
+   *     v0.27  Allow multi-line expressions; allow functions that receive
+   *            unevaluated parameters (`rawArgs`)
+   *     v3     Add object notation; allow assignments internal to other
+   *            expressions
+   *     v7.3   Supported binary, octal, and hexadecimal notation
+   *     v9.5   Support for calculations with percentages
+   *     v12.4  Allow trailing commas in matrices
+   *     v14.8  Add nullish coalescing operator
+   *     v15.1  Add optional chaining operator
+   *
    * @param {string | string[] | Matrix} expr          Expression to be parsed
    * @param {{nodes: Object<string, Node>}} [options]  Available options:
    *                                                   - `nodes` a set of custom nodes
@@ -136,6 +153,7 @@ const createParse = exports.createParse = /* #__PURE__ */(0, _factory.factory)(n
     '=': true,
     ':': true,
     '?': true,
+    '?.': true,
     '??': true,
     '==': true,
     '!=': true,
@@ -302,7 +320,9 @@ const createParse = exports.createParse = /* #__PURE__ */(0, _factory.factory)(n
     }
 
     // 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);
@@ -647,6 +667,9 @@ const createParse = exports.createParse = /* #__PURE__ */(0, _factory.factory)(n
         return new AssignmentNode(new SymbolNode(name), value);
       } else if ((0, _is.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);
@@ -891,8 +914,15 @@ const createParse = exports.createParse = /* #__PURE__ */(0, _factory.factory)(n
     let node;
     const params = [];
     if (state.token === ':') {
-      // implicit start=1 (one-based)
-      node = new ConstantNode(1);
+      if (state.conditionalLevel === state.nestingLevel) {
+        // we are in the midst of parsing a conditional operator, so not
+        // a range, but rather an empty true-expr, which is considered a
+        // syntax error
+        throw createSyntaxError(state, 'The true-expression of a conditional operator may not be empty');
+      } else {
+        // implicit start of range = 1 (one-based)
+        node = new ConstantNode(1);
+      }
     } else {
       // explicit start
       node = parseAddSubtract(state);
@@ -1261,9 +1291,9 @@ const createParse = exports.createParse = /* #__PURE__ */(0, _factory.factory)(n
 
   /**
    * 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
@@ -1275,12 +1305,27 @@ const createParse = exports.createParse = /* #__PURE__ */(0, _factory.factory)(n
    */
   function parseAccessors(state, node, types) {
     let 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
+      let optional = false;
+
+      // Consume an optional chaining operator if present
+      if (state.token === '?.') {
+        optional = true;
+        // consume the '?.' token
+        getToken(state);
+      }
+      const hasNextAccessor = (state.token === '(' || state.token === '[' || state.token === '.') && (!types || types.includes(state.token));
+      if (!(optional || hasNextAccessor)) {
+        break;
+      }
       params = [];
       if (state.token === '(') {
-        if ((0, _is.isSymbolNode)(node) || (0, _is.isAccessorNode)(node)) {
-          // function invocation like fn(2, 3) or obj.fn(2, 3)
+        if (optional || (0, _is.isSymbolNode)(node) || (0, _is.isAccessorNode)(node)) {
+          // function invocation: fn(2, 3) or obj.fn(2, 3) or (anything)?.(2, 3)
           openParams(state);
           getToken(state);
           if (state.token !== ')') {
@@ -1298,7 +1343,7 @@ const createParse = exports.createParse = /* #__PURE__ */(0, _factory.factory)(n
           }
           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
@@ -1324,18 +1369,21 @@ const createParse = exports.createParse = /* #__PURE__ */(0, _factory.factory)(n
         }
         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);
         const isPropertyName = state.tokenType === TOKENTYPE.SYMBOL || state.tokenType === TOKENTYPE.DELIMITER && state.token in NAMED_DELIMITERS;
         if (!isPropertyName) {
-          throw createSyntaxError(state, 'Property name expected after dot');
+          let message = 'Property name expected after ';
+          message += optional ? 'optional chain' : 'dot';
+          throw createSyntaxError(state, message);
         }
         params.push(new ConstantNode(state.token));
         getToken(state);
         const dotNotation = true;
-        node = new AccessorNode(node, new IndexNode(params, dotNotation));
+        node = new AccessorNode(node, new IndexNode(params, dotNotation), optional);
       }
     }
     return node;

package/lib/cjs/factoriesAny.js

@@ -153,6 +153,12 @@ Object.defineProperty(exports, "createBellNumbers", {
     return _bellNumbers.createBellNumbers;
   }
 });
+Object.defineProperty(exports, "createBernoulli", {
+  enumerable: true,
+  get: function () {
+    return _bernoulli.createBernoulli;
+  }
+});
 Object.defineProperty(exports, "createBigNumberClass", {
   enumerable: true,
   get: function () {
@@ -939,6 +945,18 @@ Object.defineProperty(exports, "createInvmod", {
     return _invmod.createInvmod;
   }
 });
+Object.defineProperty(exports, "createIsBounded", {
+  enumerable: true,
+  get: function () {
+    return _isBounded.createIsBounded;
+  }
+});
+Object.defineProperty(exports, "createIsFinite", {
+  enumerable: true,
+  get: function () {
+    return _isFinite.createIsFinite;
+  }
+});
 Object.defineProperty(exports, "createIsInteger", {
   enumerable: true,
   get: function () {
@@ -2215,6 +2233,8 @@ var _hasNumericValue = require("./function/utils/hasNumericValue.js");
 var _isPositive = require("./function/utils/isPositive.js");
 var _isZero = require("./function/utils/isZero.js");
 var _isNaN = require("./function/utils/isNaN.js");
+var _isBounded = require("./function/utils/isBounded.js");
+var _isFinite = require("./function/utils/isFinite.js");
 var _typeOf = require("./function/utils/typeOf.js");
 var _equalScalar = require("./function/relational/equalScalar.js");
 var _SparseMatrix = require("./type/matrix/SparseMatrix.js");
@@ -2443,6 +2463,7 @@ var _variance = require("./function/statistics/variance.js");
 var _quantileSeq = require("./function/statistics/quantileSeq.js");
 var _std = require("./function/statistics/std.js");
 var _corr = require("./function/statistics/corr.js");
+var _bernoulli = require("./function/probability/bernoulli.js");
 var _combinations = require("./function/probability/combinations.js");
 var _combinationsWithRep = require("./function/probability/combinationsWithRep.js");
 var _gamma = require("./function/probability/gamma.js");

package/lib/cjs/factoriesNumber.js

@@ -31,6 +31,12 @@ Object.defineProperty(exports, "createBellNumbers", {
     return _bellNumbers.createBellNumbers;
   }
 });
+Object.defineProperty(exports, "createBernoulli", {
+  enumerable: true,
+  get: function () {
+    return _bernoulli.createBernoulli;
+  }
+});
 Object.defineProperty(exports, "createBigint", {
   enumerable: true,
   get: function () {
@@ -303,6 +309,18 @@ Object.defineProperty(exports, "createInfinity", {
     return _constants.createInfinity;
   }
 });
+Object.defineProperty(exports, "createIsBounded", {
+  enumerable: true,
+  get: function () {
+    return _isBounded.createIsBounded;
+  }
+});
+Object.defineProperty(exports, "createIsFinite", {
+  enumerable: true,
+  get: function () {
+    return _isFinite.createIsFinite;
+  }
+});
 exports.createIsNegative = exports.createIsNaN = exports.createIsInteger = void 0;
 Object.defineProperty(exports, "createIsNumeric", {
   enumerable: true,
@@ -354,8 +372,7 @@ Object.defineProperty(exports, "createLargerEq", {
     return _largerEq.createLargerEqNumber;
   }
 });
-exports.createLeftShift = exports.createLcm = void 0;
-exports.createLog2 = exports.createLog1p = exports.createLog10 = exports.createLog = exports.createLgamma = void 0;
+exports.createLog2 = exports.createLog1p = exports.createLog10 = exports.createLog = exports.createLgamma = exports.createLeftShift = exports.createLcm = void 0;
 Object.defineProperty(exports, "createMad", {
   enumerable: true,
   get: function () {
@@ -853,6 +870,7 @@ var _map = require("./function/matrix/map.js");
 var _range = require("./function/matrix/range.js");
 var _size = require("./function/matrix/size.js");
 var _partitionSelect = require("./function/matrix/partitionSelect.js");
+var _bernoulli = require("./function/probability/bernoulli.js");
 var _combinationsWithRep = require("./function/probability/combinationsWithRep.js");
 var _factorial = require("./function/probability/factorial.js");
 var _multinomial = require("./function/probability/multinomial.js");
@@ -904,6 +922,8 @@ var _varianceTransform = require("./expression/transform/variance.transform.js")
 var _clone = require("./function/utils/clone.js");
 var _isNumeric = require("./function/utils/isNumeric.js");
 var _hasNumericValue = require("./function/utils/hasNumericValue.js");
+var _isBounded = require("./function/utils/isBounded.js");
+var _isFinite = require("./function/utils/isFinite.js");
 var _typeOf = require("./function/utils/typeOf.js");
 var _isPrime = require("./function/utils/isPrime.js");
 var _numeric = require("./function/utils/numeric.js");
@@ -986,6 +1006,7 @@ const createSubset = exports.createSubset = /* #__PURE__ */(0, _factory.factory)
 // TODO: create range implementation for range?
 
 // probability
+
 const createCombinations = exports.createCombinations = createNumberFactory('combinations', _index.combinationsNumber);
 const createGamma = exports.createGamma = createNumberFactory('gamma', _index.gammaNumber);
 const createLgamma = exports.createLgamma = createNumberFactory('lgamma', _index.lgammaNumber);

package/lib/cjs/function/algebra/polynomialRoot.js

@@ -52,6 +52,10 @@ const createPolynomialRoot = exports.createPolynomialRoot = /* #__PURE__ */(0, _
    * See also:
    *     cbrt, sqrt
    *
+   * History:
+   *
+   *     v11.4  Created
+   *
    * @param {... number | Complex} coeffs
    *     The coefficients of the polynomial, starting with with the constant coefficent, followed
    *     by the linear coefficient and subsequent coefficients of increasing powers.

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

@@ -10,13 +10,14 @@ var _number = require("../../utils/number.js");
 var _util = require("./simplify/util.js");
 var _noop = require("../../utils/noop.js");
 const name = 'simplifyConstant';
-const dependencies = ['typed', 'config', 'mathWithTransform', 'matrix', '?fraction', '?bignumber', 'AccessorNode', 'ArrayNode', 'ConstantNode', 'FunctionNode', 'IndexNode', 'ObjectNode', 'OperatorNode', 'SymbolNode'];
+const dependencies = ['typed', 'config', 'mathWithTransform', 'matrix', 'isBounded', '?fraction', '?bignumber', 'AccessorNode', 'ArrayNode', 'ConstantNode', 'FunctionNode', 'IndexNode', 'ObjectNode', 'OperatorNode', 'SymbolNode'];
 const createSimplifyConstant = exports.createSimplifyConstant = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
   let {
     typed,
     config,
     mathWithTransform,
     matrix,
+    isBounded,
     fraction,
     bignumber,
     AccessorNode,
@@ -134,7 +135,7 @@ const createSimplifyConstant = exports.createSimplifyConstant = /* #__PURE__ */(
   // and when both numerator and denominator are small enough
   function _exactFraction(n, options) {
     const exactFractions = options && options.exactFractions !== false;
-    if (exactFractions && isFinite(n) && fraction) {
+    if (exactFractions && isBounded(n) && fraction) {
       const f = fraction(n);
       const fractionsLimit = options && typeof options.fractionsLimit === 'number' ? options.fractionsLimit : Infinity; // no limit by default
 

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

@@ -59,7 +59,7 @@ const createAdd = exports.createAdd = /* #__PURE__ */(0, _factory.factory)(name,
    *
    *    const c = math.unit('5 cm')
    *    const d = math.unit('2.1 mm')
-   *    math.add(c, d)               // returns Unit 52.1 mm
+   *    math.add(c, d)               // returns Unit 5.21 cm
    *
    *    math.add("2.3", "4")         // returns number 6.3
    *
@@ -67,6 +67,13 @@ const createAdd = exports.createAdd = /* #__PURE__ */(0, _factory.factory)(name,
    *
    *    subtract, sum
    *
+   * History:
+   *
+   *     v13     Handle bigint arguments
+   *     v11.6   Support matrix broadcasting
+   *     v3.8    Allow more than two arguments
+   *     v0.0.2  Created
+   *
    * @param  {number | BigNumber | bigint | Fraction | Complex | Unit | Array | Matrix} x First value to add
    * @param  {number | BigNumber | bigint | Fraction | Complex | Unit | Array | Matrix} y Second value to add
    * @return {number | BigNumber | bigint | Fraction | Complex | Unit | Array | Matrix} Sum of `x` and `y`

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

@@ -41,17 +41,18 @@ const createCbrt = exports.createCbrt = /* #__PURE__ */(0, _factory.factory)(nam
    *    math.map([27, 64, 125], x => math.cbrt(x))       // returns [3, 4, 5]
    *
    *    const x = math.complex('8i')
-   *    math.cbrt(x)                   // returns Complex 1.7320508075689 + i
-   *    math.cbrt(x, true)             // returns Matrix [
-   *                                    //    1.7320508075689 + i
-   *                                    //   -1.7320508075689 + i
-   *                                    //   -2i
-   *                                    // ]
+   *    math.cbrt(x)                   // returns 1.7320508075689 + i ...
+   *    math.cbrt(x, true)
+   *    // Complex Matrix ["1.7320508075689+i", "-1.7320508075689+i", "-2i"]
    *
    * See also:
    *
    *    square, sqrt, cube
    *
+   * History:
+   *
+   *    v2.3  Created
+   *
    * @param {number | BigNumber | Complex | Unit} x
    *            Value for which to calculate the cubic root.
    * @param {boolean} [allRoots]  Optional, false by default. Only applicable

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

@@ -106,13 +106,13 @@ const createCeil = exports.createCeil = /* #__PURE__ */(0, _factory.factory)(nam
    *    math.ceil(-4.782, 2)         // returns number -4.78
    *
    *    const c = math.complex(3.24, -2.71)
-   *    math.ceil(c)                 // returns Complex 4 - 2i
+   *    math.ceil(c)                 // returns Complex 4 - 2i ...
    *    math.ceil(c, 1)              // returns Complex 3.3 - 2.7i
    *
    *    const unit = math.unit('3.241 cm')
    *    const cm = math.unit('cm')
    *    const mm = math.unit('mm')
-   *    math.ceil(unit, 1, cm)      // returns Unit 3.3 cm
+   *    math.ceil(unit, 1, cm)      // returns Unit 3.3 cm ...
    *    math.ceil(unit, 1, mm)      // returns Unit 32.5 mm
    *
    *    math.ceil([3.2, 3.8, -4.7])  // returns Array [4, 4, -4]
@@ -122,6 +122,14 @@ const createCeil = exports.createCeil = /* #__PURE__ */(0, _factory.factory)(nam
    *
    *    floor, fix, round
    *
+   * History:
+   *
+   *     v14    Handle Units
+   *     v7.4   Allow second "precision" argument
+   *     v5.7   Support tolerance for round-off errors
+   *     v2     Handle Fractions
+   *     v0.1   Created
+   *
    * @param  {number | BigNumber | Fraction | Complex | Unit | Array | Matrix} x  Value to be rounded
    * @param  {number | BigNumber | Array} [n=0]                            Number of decimals
    * @param  {Unit} [valuelessUnit]                                        A valueless unit

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

@@ -29,16 +29,18 @@ const createExp = exports.createExp = /* #__PURE__ */(0, _factory.factory)(name,
    *    math.log(math.exp(2))        // returns number 2
    *
    *    math.map([1, 2, 3], math.exp)
-   *    // returns Array [
-   *    //   2.718281828459045,
-   *    //   7.3890560989306495,
-   *    //   20.085536923187668
-   *    // ]
+   *    // returns [2.718281828459045, 7.3890560989306495, 20.085536923187668]
    *
    * See also:
    *
    *    expm1, expm, log, pow
    *
+   * History:
+   *
+   *    v11     Don't apply elementwise, avoid confusion with matrix exponential
+   *    v0.20   Handle BigNumbers
+   *    v0.0.2  Created
+   *
    * @param {number | BigNumber | Complex} x  A number to exponentiate
    * @return {number | BigNumber | Complex} Exponential of `x`
    */

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

@@ -33,16 +33,17 @@ const createExpm1 = exports.createExpm1 = /* #__PURE__ */(0, _factory.factory)(n
    *    math.log(math.expm1(2) + 1)        // returns number 2
    *
    *    math.map([1, 2, 3], math.expm1)
-   *    // returns Array [
-   *    //   1.718281828459045,
-   *    //   6.3890560989306495,
-   *    //   19.085536923187668
-   *    // ]
+   *    // returns [1.718281828459045, 6.3890560989306495, 19.085536923187668]
    *
    * See also:
    *
    *    exp, expm, log, pow
    *
+   * History:
+   *
+   *    v11    Don't apply elementwise, avoids confusion with matrix exponential
+   *    v4.2   Created
+   *
    * @param {number | BigNumber | Complex} x  The number to exponentiate
    * @return {number | BigNumber | Complex} Exponential of `x`, minus one
    */