mathjs 15.0.0 → 15.1.0

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

@@ -136,6 +136,7 @@ const createParse = exports.createParse = /* #__PURE__ */(0, _factory.factory)(n
     '=': true,
     ':': true,
     '?': true,
+    '?.': true,
     '??': true,
     '==': true,
     '!=': true,
@@ -302,7 +303,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 +650,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);
@@ -1261,9 +1267,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 +1281,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 +1319,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 +1345,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/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/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/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);