mathjs 12.4.3 → 13.0.0

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

@@ -6,35 +6,37 @@ Object.defineProperty(exports, "__esModule", {
 exports.createRationalize = void 0;
 var _number = require("../../utils/number.js");
 var _factory = require("../../utils/factory.js");
-var name = 'rationalize';
-var dependencies = ['config', 'typed', 'equal', 'isZero', 'add', 'subtract', 'multiply', 'divide', 'pow', 'parse', 'simplifyConstant', 'simplifyCore', 'simplify', '?bignumber', '?fraction', 'mathWithTransform', 'matrix', 'AccessorNode', 'ArrayNode', 'ConstantNode', 'FunctionNode', 'IndexNode', 'ObjectNode', 'OperatorNode', 'SymbolNode', 'ParenthesisNode'];
-var createRationalize = exports.createRationalize = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var config = _ref.config,
-    typed = _ref.typed,
-    equal = _ref.equal,
-    isZero = _ref.isZero,
-    add = _ref.add,
-    subtract = _ref.subtract,
-    multiply = _ref.multiply,
-    divide = _ref.divide,
-    pow = _ref.pow,
-    parse = _ref.parse,
-    simplifyConstant = _ref.simplifyConstant,
-    simplifyCore = _ref.simplifyCore,
-    simplify = _ref.simplify,
-    fraction = _ref.fraction,
-    bignumber = _ref.bignumber,
-    mathWithTransform = _ref.mathWithTransform,
-    matrix = _ref.matrix,
-    AccessorNode = _ref.AccessorNode,
-    ArrayNode = _ref.ArrayNode,
-    ConstantNode = _ref.ConstantNode,
-    FunctionNode = _ref.FunctionNode,
-    IndexNode = _ref.IndexNode,
-    ObjectNode = _ref.ObjectNode,
-    OperatorNode = _ref.OperatorNode,
-    SymbolNode = _ref.SymbolNode,
-    ParenthesisNode = _ref.ParenthesisNode;
+const name = 'rationalize';
+const dependencies = ['config', 'typed', 'equal', 'isZero', 'add', 'subtract', 'multiply', 'divide', 'pow', 'parse', 'simplifyConstant', 'simplifyCore', 'simplify', '?bignumber', '?fraction', 'mathWithTransform', 'matrix', 'AccessorNode', 'ArrayNode', 'ConstantNode', 'FunctionNode', 'IndexNode', 'ObjectNode', 'OperatorNode', 'SymbolNode', 'ParenthesisNode'];
+const createRationalize = exports.createRationalize = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    config,
+    typed,
+    equal,
+    isZero,
+    add,
+    subtract,
+    multiply,
+    divide,
+    pow,
+    parse,
+    simplifyConstant,
+    simplifyCore,
+    simplify,
+    fraction,
+    bignumber,
+    mathWithTransform,
+    matrix,
+    AccessorNode,
+    ArrayNode,
+    ConstantNode,
+    FunctionNode,
+    IndexNode,
+    ObjectNode,
+    OperatorNode,
+    SymbolNode,
+    ParenthesisNode
+  } = _ref;
   /**
    * Transform a rationalizable expression in a rational fraction.
    * If rational fraction is one variable polynomial then converts
@@ -89,28 +91,28 @@ var createRationalize = exports.createRationalize = /* #__PURE__ */(0, _factory.
    *
    */
   function _rationalize(expr) {
-    var scope = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    var detailed = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-    var setRules = rulesRationalize(); // Rules for change polynomial in near canonical form
-    var polyRet = polynomial(expr, scope, true, setRules.firstRules); // Check if expression is a rationalizable polynomial
-    var nVars = polyRet.variables.length;
-    var noExactFractions = {
+    let scope = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    let detailed = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    const setRules = rulesRationalize(); // Rules for change polynomial in near canonical form
+    const polyRet = polynomial(expr, scope, true, setRules.firstRules); // Check if expression is a rationalizable polynomial
+    const nVars = polyRet.variables.length;
+    const noExactFractions = {
       exactFractions: false
     };
-    var withExactFractions = {
+    const withExactFractions = {
       exactFractions: true
     };
     expr = polyRet.expression;
     if (nVars >= 1) {
       // If expression in not a constant
       expr = expandPower(expr); // First expand power of polynomials (cannot be made from rules!)
-      var sBefore; // Previous expression
-      var rules;
-      var eDistrDiv = true;
-      var redoInic = false;
+      let sBefore; // Previous expression
+      let rules;
+      let eDistrDiv = true;
+      let redoInic = false;
       // Apply the initial rules, including succ div rules:
       expr = simplify(expr, setRules.firstRules, {}, noExactFractions);
-      var s;
+      let s;
       while (true) {
         // Alternate applying successive division rules and distr.div.rules
         // until there are no more changes:
@@ -133,8 +135,8 @@ var createRationalize = exports.createRationalize = /* #__PURE__ */(0, _factory.
       expr = simplify(expr, setRules.finalRules, {}, noExactFractions);
     } // NVars >= 1
 
-    var coefficients = [];
-    var retRationalize = {};
+    const coefficients = [];
+    const retRationalize = {};
     if (expr.type === 'OperatorNode' && expr.isBinary() && expr.op === '/') {
       // Separate numerator from denominator
       if (nVars === 1) {
@@ -164,9 +166,7 @@ var createRationalize = exports.createRationalize = /* #__PURE__ */(0, _factory.
   }
   return typed(name, {
     Node: _rationalize,
-    'Node, boolean': function NodeBoolean(expr, detailed) {
-      return _rationalize(expr, {}, detailed);
-    },
+    'Node, boolean': (expr, detailed) => _rationalize(expr, {}, detailed),
     'Node, Object': _rationalize,
     'Node, Object, boolean': _rationalize
   }); // end of typed rationalize
@@ -192,14 +192,14 @@ var createRationalize = exports.createRationalize = /* #__PURE__ */(0, _factory.
    *            {Array}  variables:  variable names
    */
   function polynomial(expr, scope, extended, rules) {
-    var variables = [];
-    var node = simplify(expr, rules, scope, {
+    const variables = [];
+    const node = simplify(expr, rules, scope, {
       exactFractions: false
     }); // Resolves any variables and functions with all defined parameters
     extended = !!extended;
-    var oper = '+-*' + (extended ? '/' : '');
+    const oper = '+-*' + (extended ? '/' : '');
     recPoly(node);
-    var retFunc = {};
+    const retFunc = {};
     retFunc.expression = node;
     retFunc.variables = variables;
     return retFunc;
@@ -222,7 +222,7 @@ var createRationalize = exports.createRationalize = /* #__PURE__ */(0, _factory.
      * @return                           nothing, throw an exception if error
      */
     function recPoly(node) {
-      var tp = node.type; // node type
+      const tp = node.type; // node type
       if (tp === 'FunctionNode') {
         // No function call in polynomial expression
         throw new Error('There is an unsolved function call');
@@ -238,16 +238,16 @@ var createRationalize = exports.createRationalize = /* #__PURE__ */(0, _factory.
           if (!oper.includes(node.op)) {
             throw new Error('Operator ' + node.op + ' invalid in polynomial expression');
           }
-          for (var i = 0; i < node.args.length; i++) {
+          for (let i = 0; i < node.args.length; i++) {
             recPoly(node.args[i]);
           }
         } // type of operator
       } else if (tp === 'SymbolNode') {
-        var _name = node.name; // variable name
-        var pos = variables.indexOf(_name);
+        const name = node.name; // variable name
+        const pos = variables.indexOf(name);
         if (pos === -1) {
           // new variable in expression
-          variables.push(_name);
+          variables.push(name);
         }
       } else if (tp === 'ParenthesisNode') {
         recPoly(node.content);
@@ -268,7 +268,7 @@ var createRationalize = exports.createRationalize = /* #__PURE__ */(0, _factory.
    * @return {array}        rule set to rationalize an polynomial expression
    */
   function rulesRationalize() {
-    var oldRules = [simplifyCore,
+    const oldRules = [simplifyCore,
     // sCore
     {
       l: 'n+n',
@@ -294,7 +294,7 @@ var createRationalize = exports.createRationalize = /* #__PURE__ */(0, _factory.
       l: '1*n',
       r: 'n'
     }];
-    var rulesFirst = [{
+    const rulesFirst = [{
       l: '(-n1)/(-n2)',
       r: 'n1/n2'
     },
@@ -409,7 +409,7 @@ var createRationalize = exports.createRationalize = /* #__PURE__ */(0, _factory.
       r: '(-n1/n2)'
     }]; // Divisao and Unary
 
-    var rulesDistrDiv = [{
+    const rulesDistrDiv = [{
       l: '(n1/n2 + n3/n4)',
       r: '((n1*n4 + n3*n2)/(n2*n4))'
     },
@@ -424,7 +424,7 @@ var createRationalize = exports.createRationalize = /* #__PURE__ */(0, _factory.
       r: '((n1*n3 + n2)/n3)'
     }]; // Sum fraction with number 1
 
-    var rulesSucDiv = [{
+    const rulesSucDiv = [{
       l: '(n1/(n2/n3))',
       r: '((n1*n3)/n2)'
     },
@@ -433,7 +433,7 @@ var createRationalize = exports.createRationalize = /* #__PURE__ */(0, _factory.
       l: '(n1/n2/n3)',
       r: '(n1/(n2*n3))'
     }];
-    var setRules = {}; // rules set in 4 steps.
+    const setRules = {}; // rules set in 4 steps.
 
     // All rules => infinite loop
     // setRules.allRules =oldRules.concat(rulesFirst,rulesDistrDiv,rulesSucDiv)
@@ -566,12 +566,12 @@ var createRationalize = exports.createRationalize = /* #__PURE__ */(0, _factory.
    * @return {node}        node expression with all powers expanded.
    */
   function expandPower(node, parent, indParent) {
-    var tp = node.type;
-    var internal = arguments.length > 1; // TRUE in internal calls
+    const tp = node.type;
+    const internal = arguments.length > 1; // TRUE in internal calls
 
     if (tp === 'OperatorNode' && node.isBinary()) {
-      var does = false;
-      var val;
+      let does = false;
+      let val;
       if (node.op === '^') {
         // First operator: Parenthesis or UnaryMinus
         if ((node.args[0].type === 'ParenthesisNode' || node.args[0].type === 'OperatorNode') && node.args[1].type === 'ConstantNode') {
@@ -596,8 +596,8 @@ var createRationalize = exports.createRationalize = /* #__PURE__ */(0, _factory.
           //             pow
           //                 constant - 1
           //
-          var nEsqTopo = node.args[0];
-          var nDirTopo = new OperatorNode('^', 'pow', [node.args[0].cloneDeep(), new ConstantNode(val - 1)]);
+          const nEsqTopo = node.args[0];
+          const nDirTopo = new OperatorNode('^', 'pow', [node.args[0].cloneDeep(), new ConstantNode(val - 1)]);
           node = new OperatorNode('*', 'multiply', [nEsqTopo, nDirTopo]);
         } else {
           // Expo = 2 - no power
@@ -623,7 +623,7 @@ var createRationalize = exports.createRationalize = /* #__PURE__ */(0, _factory.
       // Recursion
       expandPower(node.content, node, 'content');
     } else if (tp !== 'ConstantNode' && tp !== 'SymbolNode') {
-      for (var i = 0; i < node.args.length; i++) {
+      for (let i = 0; i < node.args.length; i++) {
         expandPower(node.args[i], node, i);
       }
     }
@@ -662,29 +662,29 @@ var createRationalize = exports.createRationalize = /* #__PURE__ */(0, _factory.
     } // coefficients.
 
     coefficients[0] = 0; // index is the exponent
-    var o = {};
+    const o = {};
     o.cte = 1;
     o.oper = '+';
 
     // fire: mark with * or ^ when finds * or ^ down tree, reset to "" with + and -.
     //       It is used to deduce the exponent: 1 for *, 0 for "".
     o.fire = '';
-    var maxExpo = 0; // maximum exponent
-    var varname = ''; // variable name
+    let maxExpo = 0; // maximum exponent
+    let varname = ''; // variable name
 
     recurPol(node, null, o);
     maxExpo = coefficients.length - 1;
-    var first = true;
-    var no;
-    for (var i = maxExpo; i >= 0; i--) {
+    let first = true;
+    let no;
+    for (let i = maxExpo; i >= 0; i--) {
       if (coefficients[i] === 0) continue;
-      var n1 = new ConstantNode(first ? coefficients[i] : Math.abs(coefficients[i]));
-      var op = coefficients[i] < 0 ? '-' : '+';
+      let n1 = new ConstantNode(first ? coefficients[i] : Math.abs(coefficients[i]));
+      const op = coefficients[i] < 0 ? '-' : '+';
       if (i > 0) {
         // Is not a constant without variable
-        var n2 = new SymbolNode(varname);
+        let n2 = new SymbolNode(varname);
         if (i > 1) {
-          var n3 = new ConstantNode(i);
+          const n3 = new ConstantNode(i);
           n2 = new OperatorNode('^', 'pow', [n2, n3]);
         }
         if (coefficients[i] === -1 && first) {
@@ -726,7 +726,7 @@ var createRationalize = exports.createRationalize = /* #__PURE__ */(0, _factory.
      * @return {}                    No return. If error, throws an exception
      */
     function recurPol(node, noPai, o) {
-      var tp = node.type;
+      const tp = node.type;
       if (tp === 'FunctionNode') {
         // ***** FunctionName *****
         // No function call in polynomial expression
@@ -755,16 +755,16 @@ var createRationalize = exports.createRationalize = /* #__PURE__ */(0, _factory.
         if (node.op === '^' || node.op === '*') {
           o.fire = node.op;
         }
-        for (var _i = 0; _i < node.args.length; _i++) {
+        for (let i = 0; i < node.args.length; i++) {
           // +,-: reset fire
           if (node.fn === 'unaryMinus') o.oper = '-';
           if (node.op === '+' || node.fn === 'subtract') {
             o.fire = '';
             o.cte = 1; // default if there is no constant
-            o.oper = _i === 0 ? '+' : node.op;
+            o.oper = i === 0 ? '+' : node.op;
           }
-          o.noFil = _i; // number of son
-          recurPol(node.args[_i], node, o);
+          o.noFil = i; // number of son
+          recurPol(node.args[i], node, o);
         } // for in children
       } else if (tp === 'SymbolNode') {
         // ***** SymbolName *****
@@ -794,7 +794,7 @@ var createRationalize = exports.createRationalize = /* #__PURE__ */(0, _factory.
           maxExpo = Math.max(1, maxExpo);
         }
       } else if (tp === 'ConstantNode') {
-        var valor = parseFloat(node.value);
+        const valor = parseFloat(node.value);
         if (noPai === null) {
           coefficients[0] = valor;
           return;
@@ -805,7 +805,7 @@ var createRationalize = exports.createRationalize = /* #__PURE__ */(0, _factory.
           if (!(0, _number.isInteger)(valor) || valor <= 0) {
             throw new Error('Non-integer exponent is not allowed');
           }
-          for (var _i2 = maxExpo + 1; _i2 < valor; _i2++) coefficients[_i2] = 0;
+          for (let i = maxExpo + 1; i < valor; i++) coefficients[i] = 0;
           if (valor > maxExpo) coefficients[valor] = 0;
           coefficients[valor] += o.cte * (o.oper === '+' ? 1 : -1);
           maxExpo = Math.max(valor, maxExpo);

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

@@ -7,15 +7,17 @@ exports.createResolve = void 0;
 var _map = require("../../utils/map.js");
 var _is = require("../../utils/is.js");
 var _factory = require("../../utils/factory.js");
-var name = 'resolve';
-var dependencies = ['typed', 'parse', 'ConstantNode', 'FunctionNode', 'OperatorNode', 'ParenthesisNode'];
-var createResolve = exports.createResolve = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed,
-    parse = _ref.parse,
-    ConstantNode = _ref.ConstantNode,
-    FunctionNode = _ref.FunctionNode,
-    OperatorNode = _ref.OperatorNode,
-    ParenthesisNode = _ref.ParenthesisNode;
+const name = 'resolve';
+const dependencies = ['typed', 'parse', 'ConstantNode', 'FunctionNode', 'OperatorNode', 'ParenthesisNode'];
+const createResolve = exports.createResolve = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    parse,
+    ConstantNode,
+    FunctionNode,
+    OperatorNode,
+    ParenthesisNode
+  } = _ref;
   /**
    * resolve(expr, scope) replaces variable nodes with their scoped values
    *
@@ -43,7 +45,7 @@ var createResolve = exports.createResolve = /* #__PURE__ */(0, _factory.factory)
    *     resolution is impossible and a ReferenceError is thrown.
    */
   function _resolve(node, scope) {
-    var within = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new Set();
+    let within = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new Set();
     // note `within`:
     // `within` is not documented, since it is for internal cycle
     // detection only
@@ -52,12 +54,12 @@ var createResolve = exports.createResolve = /* #__PURE__ */(0, _factory.factory)
     }
     if ((0, _is.isSymbolNode)(node)) {
       if (within.has(node.name)) {
-        var variables = Array.from(within).join(', ');
-        throw new ReferenceError("recursive loop of variable definitions among {".concat(variables, "}"));
+        const variables = Array.from(within).join(', ');
+        throw new ReferenceError(`recursive loop of variable definitions among {${variables}}`);
       }
-      var value = scope.get(node.name);
+      const value = scope.get(node.name);
       if ((0, _is.isNode)(value)) {
-        var nextWithin = new Set(within);
+        const nextWithin = new Set(within);
         nextWithin.add(node.name);
         return _resolve(value, scope, nextWithin);
       } else if (typeof value === 'number') {
@@ -68,64 +70,34 @@ var createResolve = exports.createResolve = /* #__PURE__ */(0, _factory.factory)
         return node;
       }
     } else if ((0, _is.isOperatorNode)(node)) {
-      var args = node.args.map(function (arg) {
+      const args = node.args.map(function (arg) {
         return _resolve(arg, scope, within);
       });
       return new OperatorNode(node.op, node.fn, args, node.implicit);
     } else if ((0, _is.isParenthesisNode)(node)) {
       return new ParenthesisNode(_resolve(node.content, scope, within));
     } else if ((0, _is.isFunctionNode)(node)) {
-      var _args = node.args.map(function (arg) {
+      const args = node.args.map(function (arg) {
         return _resolve(arg, scope, within);
       });
-      return new FunctionNode(node.name, _args);
+      return new FunctionNode(node.name, args);
     }
 
     // Otherwise just recursively resolve any children (might also work
     // for some of the above special cases)
-    return node.map(function (child) {
-      return _resolve(child, scope, within);
-    });
+    return node.map(child => _resolve(child, scope, within));
   }
   return typed('resolve', {
     Node: _resolve,
     'Node, Map | null | undefined': _resolve,
-    'Node, Object': function NodeObject(n, scope) {
-      return _resolve(n, (0, _map.createMap)(scope));
-    },
+    'Node, Object': (n, scope) => _resolve(n, (0, _map.createMap)(scope)),
     // For arrays and matrices, we map `self` rather than `_resolve`
     // because resolve is fairly expensive anyway, and this way
     // we get nice error messages if one entry in the array has wrong type.
-    'Array | Matrix': typed.referToSelf(function (self) {
-      return function (A) {
-        return A.map(function (n) {
-          return self(n);
-        });
-      };
-    }),
-    'Array | Matrix, null | undefined': typed.referToSelf(function (self) {
-      return function (A) {
-        return A.map(function (n) {
-          return self(n);
-        });
-      };
-    }),
-    'Array, Object': typed.referTo('Array,Map', function (selfAM) {
-      return function (A, scope) {
-        return selfAM(A, (0, _map.createMap)(scope));
-      };
-    }),
-    'Matrix, Object': typed.referTo('Matrix,Map', function (selfMM) {
-      return function (A, scope) {
-        return selfMM(A, (0, _map.createMap)(scope));
-      };
-    }),
-    'Array | Matrix, Map': typed.referToSelf(function (self) {
-      return function (A, scope) {
-        return A.map(function (n) {
-          return self(n, scope);
-        });
-      };
-    })
+    'Array | Matrix': typed.referToSelf(self => A => A.map(n => self(n))),
+    'Array | Matrix, null | undefined': typed.referToSelf(self => A => A.map(n => self(n))),
+    'Array, Object': typed.referTo('Array,Map', selfAM => (A, scope) => selfAM(A, (0, _map.createMap)(scope))),
+    'Matrix, Object': typed.referTo('Matrix,Map', selfMM => (A, scope) => selfMM(A, (0, _map.createMap)(scope))),
+    'Array | Matrix, Map': typed.referToSelf(self => (A, scope) => A.map(n => self(n, scope)))
   });
 });