mathjs 12.4.2 → 13.0.0

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

@@ -1,44 +1,43 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createSimplifyConstant = void 0;
-var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
 var _is = require("../../utils/is.js");
 var _factory = require("../../utils/factory.js");
+var _number = require("../../utils/number.js");
 var _util = require("./simplify/util.js");
 var _noop = require("../../utils/noop.js");
-function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
-var name = 'simplifyConstant';
-var dependencies = ['typed', 'config', 'mathWithTransform', 'matrix', '?fraction', '?bignumber', 'AccessorNode', 'ArrayNode', 'ConstantNode', 'FunctionNode', 'IndexNode', 'ObjectNode', 'OperatorNode', 'SymbolNode'];
-var createSimplifyConstant = exports.createSimplifyConstant = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed,
-    config = _ref.config,
-    mathWithTransform = _ref.mathWithTransform,
-    matrix = _ref.matrix,
-    fraction = _ref.fraction,
-    bignumber = _ref.bignumber,
-    AccessorNode = _ref.AccessorNode,
-    ArrayNode = _ref.ArrayNode,
-    ConstantNode = _ref.ConstantNode,
-    FunctionNode = _ref.FunctionNode,
-    IndexNode = _ref.IndexNode,
-    ObjectNode = _ref.ObjectNode,
-    OperatorNode = _ref.OperatorNode,
-    SymbolNode = _ref.SymbolNode;
-  var _createUtil = (0, _util.createUtil)({
-      FunctionNode: FunctionNode,
-      OperatorNode: OperatorNode,
-      SymbolNode: SymbolNode
-    }),
-    isCommutative = _createUtil.isCommutative,
-    isAssociative = _createUtil.isAssociative,
-    allChildren = _createUtil.allChildren,
-    createMakeNodeFunction = _createUtil.createMakeNodeFunction;
+const name = 'simplifyConstant';
+const dependencies = ['typed', 'config', 'mathWithTransform', 'matrix', '?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,
+    fraction,
+    bignumber,
+    AccessorNode,
+    ArrayNode,
+    ConstantNode,
+    FunctionNode,
+    IndexNode,
+    ObjectNode,
+    OperatorNode,
+    SymbolNode
+  } = _ref;
+  const {
+    isCommutative,
+    isAssociative,
+    allChildren,
+    createMakeNodeFunction
+  } = (0, _util.createUtil)({
+    FunctionNode,
+    OperatorNode,
+    SymbolNode
+  });
 
   /**
    * simplifyConstant() takes a mathjs expression (either a Node representing
@@ -67,11 +66,9 @@ var createSimplifyConstant = exports.createSimplifyConstant = /* #__PURE__ */(0,
    *     Simplification options, as per simplify()
    * @return {Node} Returns expression with constant subexpressions evaluated
    */
-  var simplifyConstant = typed('simplifyConstant', {
-    Node: function Node(node) {
-      return _ensureNode(foldFraction(node, {}));
-    },
-    'Node, Object': function NodeObject(expr, options) {
+  const simplifyConstant = typed('simplifyConstant', {
+    Node: node => _ensureNode(foldFraction(node, {})),
+    'Node, Object': function (expr, options) {
       return _ensureNode(foldFraction(expr, options));
     }
   });
@@ -96,30 +93,34 @@ var createSimplifyConstant = exports.createSimplifyConstant = /* #__PURE__ */(0,
       return _toNumber(mathWithTransform[fnname].apply(null, args), options);
     }
   }
-  var _toNode = typed({
+  const _toNode = typed({
     Fraction: _fractionToNode,
-    number: function number(n) {
+    number: function (n) {
       if (n < 0) {
         return unaryMinusNode(new ConstantNode(-n));
       }
       return new ConstantNode(n);
     },
-    BigNumber: function BigNumber(n) {
+    BigNumber: function (n) {
       if (n < 0) {
         return unaryMinusNode(new ConstantNode(-n));
       }
       return new ConstantNode(n); // old parameters: (n.toString(), 'number')
     },
-    Complex: function Complex(s) {
+    bigint: function (n) {
+      if (n < 0n) {
+        return unaryMinusNode(new ConstantNode(-n));
+      }
+      return new ConstantNode(n);
+    },
+    Complex: function (s) {
       throw new Error('Cannot convert Complex number to Node');
     },
-    string: function string(s) {
+    string: function (s) {
       return new ConstantNode(s);
     },
-    Matrix: function Matrix(m) {
-      return new ArrayNode(m.valueOf().map(function (e) {
-        return _toNode(e);
-      }));
+    Matrix: function (m) {
+      return new ArrayNode(m.valueOf().map(e => _toNode(e)));
     }
   });
   function _ensureNode(thing) {
@@ -132,10 +133,10 @@ var createSimplifyConstant = exports.createSimplifyConstant = /* #__PURE__ */(0,
   // convert a number to a fraction only if it can be expressed exactly,
   // and when both numerator and denominator are small enough
   function _exactFraction(n, options) {
-    var exactFractions = options && options.exactFractions !== false;
+    const exactFractions = options && options.exactFractions !== false;
     if (exactFractions && isFinite(n) && fraction) {
-      var f = fraction(n);
-      var fractionsLimit = options && typeof options.fractionsLimit === 'number' ? options.fractionsLimit : Infinity; // no limit by default
+      const f = fraction(n);
+      const fractionsLimit = options && typeof options.fractionsLimit === 'number' ? options.fractionsLimit : Infinity; // no limit by default
 
       if (f.valueOf() === n && f.n < fractionsLimit && f.d < fractionsLimit) {
         return f;
@@ -146,46 +147,52 @@ var createSimplifyConstant = exports.createSimplifyConstant = /* #__PURE__ */(0,
 
   // Convert numbers to a preferred number type in preference order: Fraction, number, Complex
   // BigNumbers are left alone
-  var _toNumber = typed({
-    'string, Object': function stringObject(s, options) {
-      if (config.number === 'BigNumber') {
+  const _toNumber = typed({
+    'string, Object': function (s, options) {
+      const numericType = (0, _number.safeNumberType)(s, config);
+      if (numericType === 'BigNumber') {
         if (bignumber === undefined) {
           (0, _noop.noBignumber)();
         }
         return bignumber(s);
-      } else if (config.number === 'Fraction') {
+      } else if (numericType === 'bigint') {
+        return BigInt(s);
+      } else if (numericType === 'Fraction') {
         if (fraction === undefined) {
           (0, _noop.noFraction)();
         }
         return fraction(s);
       } else {
-        var n = parseFloat(s);
+        const n = parseFloat(s);
         return _exactFraction(n, options);
       }
     },
-    'Fraction, Object': function FractionObject(s, options) {
+    'Fraction, Object': function (s, options) {
       return s;
     },
     // we don't need options here
 
-    'BigNumber, Object': function BigNumberObject(s, options) {
+    'BigNumber, Object': function (s, options) {
       return s;
     },
     // we don't need options here
 
-    'number, Object': function numberObject(s, options) {
+    'number, Object': function (s, options) {
       return _exactFraction(s, options);
     },
-    'Complex, Object': function ComplexObject(s, options) {
+    'bigint, Object': function (s, options) {
+      return s;
+    },
+    'Complex, Object': function (s, options) {
       if (s.im !== 0) {
         return s;
       }
       return _exactFraction(s.re, options);
     },
-    'Matrix, Object': function MatrixObject(s, options) {
+    'Matrix, Object': function (s, options) {
       return matrix(_exactFraction(s.valueOf()));
     },
-    'Array, Object': function ArrayObject(s, options) {
+    'Array, Object': function (s, options) {
       return s.map(_exactFraction);
     }
   });
@@ -193,8 +200,8 @@ var createSimplifyConstant = exports.createSimplifyConstant = /* #__PURE__ */(0,
     return new OperatorNode('-', 'unaryMinus', [n]);
   }
   function _fractionToNode(f) {
-    var n;
-    var vn = f.s * f.n;
+    let n;
+    const vn = f.s * f.n;
     if (vn < 0) {
       n = new OperatorNode('-', 'unaryMinus', [new ConstantNode(-vn)]);
     } else {
@@ -213,7 +220,7 @@ var createSimplifyConstant = exports.createSimplifyConstant = /* #__PURE__ */(0,
       return new AccessorNode(_ensureNode(obj), _ensureNode(index));
     }
     if ((0, _is.isArrayNode)(obj) || (0, _is.isMatrix)(obj)) {
-      var remainingDims = Array.from(index.dimensions);
+      const remainingDims = Array.from(index.dimensions);
       /* We will resolve constant indices one at a time, looking
        * just in the first or second dimensions because (a) arrays
        * of more than two dimensions are likely rare, and (b) pulling
@@ -222,7 +229,7 @@ var createSimplifyConstant = exports.createSimplifyConstant = /* #__PURE__ */(0,
        */
       while (remainingDims.length > 0) {
         if ((0, _is.isConstantNode)(remainingDims[0]) && typeof remainingDims[0].value !== 'string') {
-          var first = _toNumber(remainingDims.shift().value, options);
+          const first = _toNumber(remainingDims.shift().value, options);
           if ((0, _is.isArrayNode)(obj)) {
             obj = obj.items[first - 1];
           } else {
@@ -233,26 +240,17 @@ var createSimplifyConstant = exports.createSimplifyConstant = /* #__PURE__ */(0,
             }
           }
         } else if (remainingDims.length > 1 && (0, _is.isConstantNode)(remainingDims[1]) && typeof remainingDims[1].value !== 'string') {
-          var second = _toNumber(remainingDims[1].value, options);
-          var tryItems = [];
-          var fromItems = (0, _is.isArrayNode)(obj) ? obj.items : obj.valueOf();
-          var _iterator = _createForOfIteratorHelper(fromItems),
-            _step;
-          try {
-            for (_iterator.s(); !(_step = _iterator.n()).done;) {
-              var item = _step.value;
-              if ((0, _is.isArrayNode)(item)) {
-                tryItems.push(item.items[second - 1]);
-              } else if ((0, _is.isMatrix)(obj)) {
-                tryItems.push(item[second - 1]);
-              } else {
-                break;
-              }
+          const second = _toNumber(remainingDims[1].value, options);
+          const tryItems = [];
+          const fromItems = (0, _is.isArrayNode)(obj) ? obj.items : obj.valueOf();
+          for (const item of fromItems) {
+            if ((0, _is.isArrayNode)(item)) {
+              tryItems.push(item.items[second - 1]);
+            } else if ((0, _is.isMatrix)(obj)) {
+              tryItems.push(item[second - 1]);
+            } else {
+              break;
             }
-          } catch (err) {
-            _iterator.e(err);
-          } finally {
-            _iterator.f();
           }
           if (tryItems.length === fromItems.length) {
             if ((0, _is.isArrayNode)(obj)) {
@@ -284,7 +282,7 @@ var createSimplifyConstant = exports.createSimplifyConstant = /* #__PURE__ */(0,
       return obj;
     }
     if ((0, _is.isObjectNode)(obj) && index.dimensions.length === 1 && (0, _is.isConstantNode)(index.dimensions[0])) {
-      var key = index.dimensions[0].value;
+      const key = index.dimensions[0].value;
       if (key in obj.properties) {
         return obj.properties[key];
       }
@@ -305,13 +303,13 @@ var createSimplifyConstant = exports.createSimplifyConstant = /* #__PURE__ */(0,
    * @return - Either a Node representing a binary expression or Fraction
    */
   function foldOp(fn, args, makeNode, options) {
-    var first = args.shift();
+    const first = args.shift();
 
     // In the following reduction, sofar always has one of the three following
     // forms: [NODE], [CONSTANT], or [NODE, CONSTANT]
-    var reduction = args.reduce(function (sofar, next) {
+    const reduction = args.reduce((sofar, next) => {
       if (!(0, _is.isNode)(next)) {
-        var last = sofar.pop();
+        const last = sofar.pop();
         if ((0, _is.isNode)(last)) {
           return [last, next];
         }
@@ -328,7 +326,7 @@ var createSimplifyConstant = exports.createSimplifyConstant = /* #__PURE__ */(0,
       // Encountered a Node, or failed folding --
       // collapse everything so far into a single tree:
       sofar.push(_ensureNode(sofar.pop()));
-      var newtree = sofar.length === 1 ? sofar[0] : makeNode(sofar);
+      const newtree = sofar.length === 1 ? sofar[0] : makeNode(sofar);
       return [makeNode([newtree, _ensureNode(next)])];
     }, [first]);
     if (reduction.length === 1) {
@@ -344,9 +342,11 @@ var createSimplifyConstant = exports.createSimplifyConstant = /* #__PURE__ */(0,
       case 'SymbolNode':
         return node;
       case 'ConstantNode':
-        switch ((0, _typeof2["default"])(node.value)) {
+        switch (typeof node.value) {
           case 'number':
             return _toNumber(node.value, options);
+          case 'bigint':
+            return _toNumber(node.value, options);
           case 'string':
             return node.value;
           default:
@@ -359,11 +359,9 @@ var createSimplifyConstant = exports.createSimplifyConstant = /* #__PURE__ */(0,
         }
         {
           // Process operators as OperatorNode
-          var operatorFunctions = ['add', 'multiply'];
-          if (operatorFunctions.indexOf(node.name) === -1) {
-            var args = node.args.map(function (arg) {
-              return foldFraction(arg, options);
-            });
+          const operatorFunctions = ['add', 'multiply'];
+          if (!operatorFunctions.includes(node.name)) {
+            const args = node.args.map(arg => foldFraction(arg, options));
 
             // If all args are numbers
             if (!args.some(_is.isNode)) {
@@ -374,8 +372,8 @@ var createSimplifyConstant = exports.createSimplifyConstant = /* #__PURE__ */(0,
 
             // Size of a matrix does not depend on entries
             if (node.name === 'size' && args.length === 1 && (0, _is.isArrayNode)(args[0])) {
-              var sz = [];
-              var section = args[0];
+              const sz = [];
+              let section = args[0];
               while ((0, _is.isArrayNode)(section)) {
                 sz.push(section.items.length);
                 section = section.items[0];
@@ -392,31 +390,29 @@ var createSimplifyConstant = exports.createSimplifyConstant = /* #__PURE__ */(0,
       /* falls through */
       case 'OperatorNode':
         {
-          var fn = node.fn.toString();
-          var _args;
-          var res;
-          var makeNode = createMakeNodeFunction(node);
+          const fn = node.fn.toString();
+          let args;
+          let res;
+          const makeNode = createMakeNodeFunction(node);
           if ((0, _is.isOperatorNode)(node) && node.isUnary()) {
-            _args = [foldFraction(node.args[0], options)];
-            if (!(0, _is.isNode)(_args[0])) {
-              res = _eval(fn, _args, options);
+            args = [foldFraction(node.args[0], options)];
+            if (!(0, _is.isNode)(args[0])) {
+              res = _eval(fn, args, options);
             } else {
-              res = makeNode(_args);
+              res = makeNode(args);
             }
           } else if (isAssociative(node, options.context)) {
-            _args = allChildren(node, options.context);
-            _args = _args.map(function (arg) {
-              return foldFraction(arg, options);
-            });
+            args = allChildren(node, options.context);
+            args = args.map(arg => foldFraction(arg, options));
             if (isCommutative(fn, options.context)) {
               // commutative binary operator
-              var consts = [];
-              var vars = [];
-              for (var i = 0; i < _args.length; i++) {
-                if (!(0, _is.isNode)(_args[i])) {
-                  consts.push(_args[i]);
+              const consts = [];
+              const vars = [];
+              for (let i = 0; i < args.length; i++) {
+                if (!(0, _is.isNode)(args[i])) {
+                  consts.push(args[i]);
                 } else {
-                  vars.push(_args[i]);
+                  vars.push(args[i]);
                 }
               }
               if (consts.length > 1) {
@@ -425,18 +421,16 @@ var createSimplifyConstant = exports.createSimplifyConstant = /* #__PURE__ */(0,
                 res = foldOp(fn, vars, makeNode, options);
               } else {
                 // we won't change the children order since it's not neccessary
-                res = foldOp(fn, _args, makeNode, options);
+                res = foldOp(fn, args, makeNode, options);
               }
             } else {
               // non-commutative binary operator
-              res = foldOp(fn, _args, makeNode, options);
+              res = foldOp(fn, args, makeNode, options);
             }
           } else {
             // non-associative binary operator
-            _args = node.args.map(function (arg) {
-              return foldFraction(arg, options);
-            });
-            res = foldOp(fn, _args, makeNode, options);
+            args = node.args.map(arg => foldFraction(arg, options));
+            res = foldOp(fn, args, makeNode, options);
           }
           return res;
         }
@@ -447,9 +441,7 @@ var createSimplifyConstant = exports.createSimplifyConstant = /* #__PURE__ */(0,
         return _foldAccessor(foldFraction(node.object, options), foldFraction(node.index, options), options);
       case 'ArrayNode':
         {
-          var foldItems = node.items.map(function (item) {
-            return foldFraction(item, options);
-          });
+          const foldItems = node.items.map(item => foldFraction(item, options));
           if (foldItems.some(_is.isNode)) {
             return new ArrayNode(foldItems.map(_ensureNode));
           }
@@ -458,14 +450,12 @@ var createSimplifyConstant = exports.createSimplifyConstant = /* #__PURE__ */(0,
         }
       case 'IndexNode':
         {
-          return new IndexNode(node.dimensions.map(function (n) {
-            return simplifyConstant(n, options);
-          }));
+          return new IndexNode(node.dimensions.map(n => simplifyConstant(n, options)));
         }
       case 'ObjectNode':
         {
-          var foldProps = {};
-          for (var prop in node.properties) {
+          const foldProps = {};
+          for (const prop in node.properties) {
             foldProps[prop] = simplifyConstant(node.properties[prop], options);
           }
           return new ObjectNode(foldProps);
@@ -481,7 +471,7 @@ var createSimplifyConstant = exports.createSimplifyConstant = /* #__PURE__ */(0,
       case 'ConditionalNode':
       /* falls through */
       default:
-        throw new Error("Unimplemented node type in simplifyConstant: ".concat(node.type));
+        throw new Error(`Unimplemented node type in simplifyConstant: ${node.type}`);
     }
   }
   return simplifyConstant;