mathjs 14.9.1 → 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/node/IndexNode.js

@@ -86,7 +86,7 @@ const createIndexNode = exports.createIndexNode = /* #__PURE__ */(0, _factory.fa
             if (!(0, _is.isMatrix)(context) && !(0, _is.isArray)(context) && !(0, _is.isString)(context)) {
               throw new TypeError('Cannot resolve "end": ' + 'context must be a Matrix, Array, or string but is ' + (0, _is.typeOf)(context));
             }
-            const s = size(context).valueOf();
+            const s = size(context);
             const childArgs = Object.create(args);
             childArgs.end = s[i];
             return _evalDimension(scope, childArgs, context);

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);
@@ -329,7 +332,7 @@ const createParse = exports.createParse = /* #__PURE__ */(0, _factory.factory)(n
         next(state);
         state.token += currentCharacter(state);
         next(state);
-        while (parse.isHexDigit(currentCharacter(state))) {
+        while (parse.isAlpha(currentCharacter(state), prevCharacter(state), nextCharacter(state)) || parse.isDigit(currentCharacter(state))) {
           state.token += currentCharacter(state);
           next(state);
         }
@@ -338,7 +341,7 @@ const createParse = exports.createParse = /* #__PURE__ */(0, _factory.factory)(n
           state.token += '.';
           next(state);
           // get the digits after the radix
-          while (parse.isHexDigit(currentCharacter(state))) {
+          while (parse.isAlpha(currentCharacter(state), prevCharacter(state), nextCharacter(state)) || parse.isDigit(currentCharacter(state))) {
             state.token += currentCharacter(state);
             next(state);
           }
@@ -544,15 +547,6 @@ const createParse = exports.createParse = /* #__PURE__ */(0, _factory.factory)(n
     return c >= '0' && c <= '9';
   };
 
-  /**
-   * checks if the given char c is a hex digit
-   * @param {string} c   a string with one character
-   * @return {boolean}
-   */
-  parse.isHexDigit = function isHexDigit(c) {
-    return c >= '0' && c <= '9' || c >= 'a' && c <= 'f' || c >= 'A' && c <= 'F';
-  };
-
   /**
    * Start of the parse levels below, in order of precedence
    * @return {Node} node
@@ -656,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);
@@ -941,7 +938,7 @@ const createParse = exports.createParse = /* #__PURE__ */(0, _factory.factory)(n
    */
   function parseAddSubtract(state) {
     let node, name, fn, params;
-    node = parseMultiplyDivideModulusPercentage(state);
+    node = parseMultiplyDivideModulus(state);
     const operators = {
       '+': 'add',
       '-': 'subtract'
@@ -950,7 +947,7 @@ const createParse = exports.createParse = /* #__PURE__ */(0, _factory.factory)(n
       name = state.token;
       fn = operators[name];
       getTokenSkipNewline(state);
-      const rightNode = parseMultiplyDivideModulusPercentage(state);
+      const rightNode = parseMultiplyDivideModulus(state);
       if (rightNode.isPercentage) {
         params = [node, new OperatorNode('*', 'multiply', [node, rightNode])];
       } else {
@@ -962,11 +959,11 @@ const createParse = exports.createParse = /* #__PURE__ */(0, _factory.factory)(n
   }
 
   /**
-   * multiply, divide, modulus, percentage
+   * multiply, divide, modulus
    * @return {Node} node
    * @private
    */
-  function parseMultiplyDivideModulusPercentage(state) {
+  function parseMultiplyDivideModulus(state) {
     let node, last, name, fn;
     node = parseImplicitMultiplication(state);
     last = node;
@@ -984,23 +981,8 @@ const createParse = exports.createParse = /* #__PURE__ */(0, _factory.factory)(n
         name = state.token;
         fn = operators[name];
         getTokenSkipNewline(state);
-        if (name === '%' && state.tokenType === TOKENTYPE.DELIMITER && state.token !== '(') {
-          // If the expression contains only %, then treat that as /100
-          if (state.token !== '' && operators[state.token]) {
-            const left = new OperatorNode('/', 'divide', [node, new ConstantNode(100)], false, true);
-            name = state.token;
-            fn = operators[name];
-            getTokenSkipNewline(state);
-            last = parseImplicitMultiplication(state);
-            node = new OperatorNode(name, fn, [left, last]);
-          } else {
-            node = new OperatorNode('/', 'divide', [node, new ConstantNode(100)], false, true);
-          }
-          // return node
-        } else {
-          last = parseImplicitMultiplication(state);
-          node = new OperatorNode(name, fn, [node, last]);
-        }
+        last = parseImplicitMultiplication(state);
+        node = new OperatorNode(name, fn, [node, last]);
       } else {
         break;
       }
@@ -1043,7 +1025,7 @@ const createParse = exports.createParse = /* #__PURE__ */(0, _factory.factory)(n
    * @private
    */
   function parseRule2(state) {
-    let node = parseUnary(state);
+    let node = parseUnaryPercentage(state);
     let last = node;
     const tokenStates = [];
     while (true) {
@@ -1065,7 +1047,7 @@ const createParse = exports.createParse = /* #__PURE__ */(0, _factory.factory)(n
             // Rewind once and build the "number / number" node; the symbol will be consumed later
             (0, _extends2.default)(state, tokenStates.pop());
             tokenStates.pop();
-            last = parseUnary(state);
+            last = parseUnaryPercentage(state);
             node = new OperatorNode('/', 'divide', [node, last]);
           } else {
             // Not a match, so rewind
@@ -1085,6 +1067,34 @@ const createParse = exports.createParse = /* #__PURE__ */(0, _factory.factory)(n
     return node;
   }
 
+  /**
+   * Unary percentage operator (treated as `value / 100`)
+   * @return {Node} node
+   * @private
+   */
+  function parseUnaryPercentage(state) {
+    let node = parseUnary(state);
+    if (state.token === '%') {
+      const previousState = (0, _extends2.default)({}, state);
+      getTokenSkipNewline(state);
+      // We need to decide if this is a unary percentage % or binary modulo %
+      // So we attempt to parse a unary expression at this point.
+      // If it fails, then the only possibility is that this is a unary percentage.
+      // If it succeeds, then we presume that this must be binary modulo, since the
+      // only things that parseUnary can handle are _higher_ precedence than unary %.
+      try {
+        parseUnary(state);
+        // Not sure if we could somehow use the result of that parseUnary? Without
+        // further analysis/testing, safer just to discard and let the parse proceed
+        (0, _extends2.default)(state, previousState);
+      } catch (_unused) {
+        // Not seeing a term at this point, so was a unary %
+        node = new OperatorNode('/', 'divide', [node, new ConstantNode(100)], false, true);
+      }
+    }
+    return node;
+  }
+
   /**
    * Unary plus and minus, and logical and bitwise not
    * @return {Node} node
@@ -1257,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
@@ -1271,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 !== ')') {
@@ -1294,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
@@ -1320,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/algebra/sylvester.js

@@ -23,7 +23,8 @@ const createSylvester = exports.createSylvester = /* #__PURE__ */(0, _factory.fa
     subtract,
     identity,
     lusolve,
-    abs
+    abs,
+    config
   } = _ref;
   /**
    *
@@ -94,7 +95,7 @@ const createSylvester = exports.createSylvester = /* #__PURE__ */(0, _factory.fa
     const vc = (a, b) => concat(a, b, 0);
     for (let k = 0; k < n; k++) {
       if (k < n - 1 && abs(subset(G, index(k + 1, k))) > 1e-5) {
-        let RHS = vc(subset(D, index(all, k)), subset(D, index(all, k + 1)));
+        let RHS = vc(subset(D, index(all, [k])), subset(D, index(all, [k + 1])));
         for (let j = 0; j < k; j++) {
           RHS = add(RHS, vc(multiply(y[j], subset(G, index(j, k))), multiply(y[j], subset(G, index(j, k + 1)))));
         }
@@ -104,11 +105,11 @@ const createSylvester = exports.createSylvester = /* #__PURE__ */(0, _factory.fa
         const gmm = multiply(identity(m), multiply(-1, subset(G, index(k + 1, k + 1))));
         const LHS = vc(hc(add(F, gkk), gmk), hc(gkm, add(F, gmm)));
         const yAux = lusolve(LHS, RHS);
-        y[k] = yAux.subset(index(range(0, m), 0));
-        y[k + 1] = yAux.subset(index(range(m, 2 * m), 0));
+        y[k] = yAux.subset(index(range(0, m), [0]));
+        y[k + 1] = yAux.subset(index(range(m, 2 * m), [0]));
         k++;
       } else {
-        let RHS = subset(D, index(all, k));
+        let RHS = subset(D, index(all, [k]));
         for (let j = 0; j < k; j++) {
           RHS = add(RHS, multiply(y[j], subset(G, index(j, k))));
         }