mathjs 8.1.0 → 12.2.1

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

@@ -1,10 +1,8 @@
 import { isInteger } from '../../utils/number.js';
 import { factory } from '../../utils/factory.js';
-import { createSimplifyConstant } from './simplify/simplifyConstant.js';
-import { createSimplifyCore } from './simplify/simplifyCore.js';
 var name = 'rationalize';
-var dependencies = ['config', 'typed', 'equal', 'isZero', 'add', 'subtract', 'multiply', 'divide', 'pow', 'parse', 'simplify', '?bignumber', '?fraction', 'mathWithTransform', 'ConstantNode', 'OperatorNode', 'FunctionNode', 'SymbolNode', 'ParenthesisNode'];
-export var createRationalize = /* #__PURE__ */factory(name, dependencies, (_ref) => {
+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'];
+export var createRationalize = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     config,
     typed,
@@ -16,40 +14,23 @@ export var createRationalize = /* #__PURE__ */factory(name, dependencies, (_ref)
     divide,
     pow,
     parse,
+    simplifyConstant,
+    simplifyCore,
     simplify,
     fraction,
     bignumber,
     mathWithTransform,
+    matrix,
+    AccessorNode,
+    ArrayNode,
     ConstantNode,
-    OperatorNode,
     FunctionNode,
+    IndexNode,
+    ObjectNode,
+    OperatorNode,
     SymbolNode,
     ParenthesisNode
   } = _ref;
-  var simplifyConstant = createSimplifyConstant({
-    typed,
-    config,
-    mathWithTransform,
-    fraction,
-    bignumber,
-    ConstantNode,
-    OperatorNode,
-    FunctionNode,
-    SymbolNode
-  });
-  var simplifyCore = createSimplifyCore({
-    equal,
-    isZero,
-    add,
-    subtract,
-    multiply,
-    divide,
-    pow,
-    ConstantNode,
-    OperatorNode,
-    FunctionNode,
-    ParenthesisNode
-  });
   /**
    * Transform a rationalizable expression in a rational fraction.
    * If rational fraction is one variable polynomial then converts
@@ -58,10 +39,10 @@ export var createRationalize = /* #__PURE__ */factory(name, dependencies, (_ref)
    *
    * Syntax:
    *
-   *     rationalize(expr)
-   *     rationalize(expr, detailed)
-   *     rationalize(expr, scope)
-   *     rationalize(expr, scope, detailed)
+   *     math.rationalize(expr)
+   *     math.rationalize(expr, detailed)
+   *     math.rationalize(expr, scope)
+   *     math.rationalize(expr, scope, detailed)
    *
    * Examples:
    *
@@ -93,125 +74,95 @@ export var createRationalize = /* #__PURE__ */factory(name, dependencies, (_ref)
    * @param  {Object|boolean}      optional scope of expression or true for already evaluated rational expression at input
    * @param  {Boolean}  detailed   optional True if return an object, false if return expression node (default)
    *
-   * @return {Object | Node}    The rational polynomial of `expr` or na object
-   *            {Object}
-   *              {Expression Node} expression: node simplified expression
-   *              {Expression Node} numerator: simplified numerator of expression
-   *              {Expression Node | boolean} denominator: simplified denominator or false (if there is no denominator)
-   *              {Array}           variables:  variable names
-   *              {Array}           coefficients: coefficients of numerator sorted by increased exponent
+   * @return {Object | Node}    The rational polynomial of `expr` or an object
+   *            `{expression, numerator, denominator, variables, coefficients}`, where
+   *              `expression` is a `Node` with the node simplified expression,
+   *              `numerator` is a `Node` with the simplified numerator of expression,
+   *              `denominator` is a `Node` or `boolean` with the simplified denominator or `false` (if there is no denominator),
+   *              `variables` is an array with variable names,
+   *              and `coefficients` is an array with coefficients of numerator sorted by increased exponent
    *           {Expression Node}  node simplified expression
    *
    */
-
-  return typed(name, {
-    string: function string(expr) {
-      return this(parse(expr), {}, false);
-    },
-    'string, boolean': function stringBoolean(expr, detailed) {
-      return this(parse(expr), {}, detailed);
-    },
-    'string, Object': function stringObject(expr, scope) {
-      return this(parse(expr), scope, false);
-    },
-    'string, Object, boolean': function stringObjectBoolean(expr, scope, detailed) {
-      return this(parse(expr), scope, detailed);
-    },
-    Node: function Node(expr) {
-      return this(expr, {}, false);
-    },
-    'Node, boolean': function NodeBoolean(expr, detailed) {
-      return this(expr, {}, detailed);
-    },
-    'Node, Object': function NodeObject(expr, scope) {
-      return this(expr, scope, false);
-    },
-    'Node, Object, boolean': function NodeObjectBoolean(expr, scope, detailed) {
-      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;
-      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;
-        expr = simplify(expr, setRules.firstRules, {}, {
-          exactFractions: false
-        }); // Apply the initial rules, including succ div rules
-
-        var s;
-
-        while (true) {
-          // Apply alternately  successive division rules and distr.div.rules
-          rules = eDistrDiv ? setRules.distrDivRules : setRules.sucDivRules;
-          expr = simplify(expr, rules); // until no more changes
-
-          eDistrDiv = !eDistrDiv; // Swap between Distr.Div and Succ. Div. Rules
-
-          s = expr.toString();
-
-          if (s === sBefore) {
-            break; // No changes : end of the loop
-          }
-
-          redoInic = true;
-          sBefore = s;
-        }
-
-        if (redoInic) {
-          // Apply first rules again without succ div rules (if there are changes)
-          expr = simplify(expr, setRules.firstRulesAgain, {}, {
-            exactFractions: false
-          });
-        }
-
-        expr = simplify(expr, setRules.finalRules, {}, {
-          exactFractions: false
-        }); // Apply final rules
-      } // NVars >= 1
-
-
-      var coefficients = [];
-      var retRationalize = {};
-
-      if (expr.type === 'OperatorNode' && expr.isBinary() && expr.op === '/') {
-        // Separate numerator from denominator
-        if (nVars === 1) {
-          expr.args[0] = polyToCanonical(expr.args[0], coefficients);
-          expr.args[1] = polyToCanonical(expr.args[1]);
-        }
-
-        if (detailed) {
-          retRationalize.numerator = expr.args[0];
-          retRationalize.denominator = expr.args[1];
-        }
-      } else {
-        if (nVars === 1) {
-          expr = polyToCanonical(expr, coefficients);
-        }
-
-        if (detailed) {
-          retRationalize.numerator = expr;
-          retRationalize.denominator = null;
+  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 = {
+      exactFractions: false
+    };
+    var 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;
+      // Apply the initial rules, including succ div rules:
+      expr = simplify(expr, setRules.firstRules, {}, noExactFractions);
+      var s;
+      while (true) {
+        // Alternate applying successive division rules and distr.div.rules
+        // until there are no more changes:
+        rules = eDistrDiv ? setRules.distrDivRules : setRules.sucDivRules;
+        expr = simplify(expr, rules, {}, withExactFractions);
+        eDistrDiv = !eDistrDiv; // Swap between Distr.Div and Succ. Div. Rules
+
+        s = expr.toString();
+        if (s === sBefore) {
+          break; // No changes : end of the loop
         }
-      } // nVars
-
-
-      if (!detailed) return expr;
-      retRationalize.coefficients = coefficients;
-      retRationalize.variables = polyRet.variables;
-      retRationalize.expression = expr;
-      return retRationalize;
-    } // ^^^^^^^ end of rationalize ^^^^^^^^
-
+        redoInic = true;
+        sBefore = s;
+      }
+      if (redoInic) {
+        // Apply first rules again without succ div rules (if there are changes)
+        expr = simplify(expr, setRules.firstRulesAgain, {}, noExactFractions);
+      }
+      // Apply final rules:
+      expr = simplify(expr, setRules.finalRules, {}, noExactFractions);
+    } // NVars >= 1
+
+    var coefficients = [];
+    var retRationalize = {};
+    if (expr.type === 'OperatorNode' && expr.isBinary() && expr.op === '/') {
+      // Separate numerator from denominator
+      if (nVars === 1) {
+        expr.args[0] = polyToCanonical(expr.args[0], coefficients);
+        expr.args[1] = polyToCanonical(expr.args[1]);
+      }
+      if (detailed) {
+        retRationalize.numerator = expr.args[0];
+        retRationalize.denominator = expr.args[1];
+      }
+    } else {
+      if (nVars === 1) {
+        expr = polyToCanonical(expr, coefficients);
+      }
+      if (detailed) {
+        retRationalize.numerator = expr;
+        retRationalize.denominator = null;
+      }
+    }
+    // nVars
+
+    if (!detailed) return expr;
+    retRationalize.coefficients = coefficients;
+    retRationalize.variables = polyRet.variables;
+    retRationalize.expression = expr;
+    return retRationalize;
+  }
+  return typed(name, {
+    Node: _rationalize,
+    'Node, boolean': (expr, detailed) => _rationalize(expr, {}, detailed),
+    'Node, Object': _rationalize,
+    'Node, Object, boolean': _rationalize
   }); // end of typed rationalize
 
   /**
@@ -234,20 +185,20 @@ export var createRationalize = /* #__PURE__ */factory(name, dependencies, (_ref)
    *            {Object} node:   node simplified expression
    *            {Array}  variables:  variable names
    */
-
   function polynomial(expr, scope, extended, rules) {
     var variables = [];
     var node = simplify(expr, rules, scope, {
       exactFractions: false
     }); // Resolves any variables and functions with all defined parameters
-
     extended = !!extended;
     var oper = '+-*' + (extended ? '/' : '');
     recPoly(node);
     var retFunc = {};
     retFunc.expression = node;
     retFunc.variables = variables;
-    return retFunc; // -------------------------------------------------------------------------------------------------------
+    return retFunc;
+
+    // -------------------------------------------------------------------------------------------------------
 
     /**
      *  Function to simplify an expression using an optional scope and
@@ -264,10 +215,8 @@ export var createRationalize = /* #__PURE__ */factory(name, dependencies, (_ref)
      *
      * @return                           nothing, throw an exception if error
      */
-
     function recPoly(node) {
       var tp = node.type; // node type
-
       if (tp === 'FunctionNode') {
         // No function call in polynomial expression
         throw new Error('There is an unsolved function call');
@@ -283,17 +232,13 @@ export var createRationalize = /* #__PURE__ */factory(name, dependencies, (_ref)
           if (oper.indexOf(node.op) === -1) {
             throw new Error('Operator ' + node.op + ' invalid in polynomial expression');
           }
-
           for (var 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);
-
         if (pos === -1) {
           // new variable in expression
           variables.push(_name);
@@ -304,10 +249,9 @@ export var createRationalize = /* #__PURE__ */factory(name, dependencies, (_ref)
         throw new Error('type ' + tp + ' is not allowed in polynomial expression');
       }
     } // end of recPoly
-
   } // end of polynomial
-  // ---------------------------------------------------------------------------------------
 
+  // ---------------------------------------------------------------------------------------
   /**
    * Return a rule set to rationalize an polynomial expression in rationalize
    *
@@ -317,17 +261,17 @@ export var createRationalize = /* #__PURE__ */factory(name, dependencies, (_ref)
    *
    * @return {array}        rule set to rationalize an polynomial expression
    */
-
-
   function rulesRationalize() {
-    var oldRules = [simplifyCore, // sCore
+    var oldRules = [simplifyCore,
+    // sCore
     {
       l: 'n+n',
       r: '2*n'
     }, {
       l: 'n+-n',
       r: '0'
-    }, simplifyConstant, // sConstant
+    }, simplifyConstant,
+    // sConstant
     {
       l: 'n*(n1^-1)',
       r: 'n/n1'
@@ -347,91 +291,113 @@ export var createRationalize = /* #__PURE__ */factory(name, dependencies, (_ref)
     var rulesFirst = [{
       l: '(-n1)/(-n2)',
       r: 'n1/n2'
-    }, // Unary division
+    },
+    // Unary division
     {
       l: '(-n1)*(-n2)',
       r: 'n1*n2'
-    }, // Unary multiplication
+    },
+    // Unary multiplication
     {
       l: 'n1--n2',
       r: 'n1+n2'
-    }, // '--' elimination
+    },
+    // '--' elimination
     {
       l: 'n1-n2',
       r: 'n1+(-n2)'
-    }, // Subtraction turn into add with un�ry minus
+    },
+    // Subtraction turn into add with un�ry minus
     {
       l: '(n1+n2)*n3',
       r: '(n1*n3 + n2*n3)'
-    }, // Distributive 1
+    },
+    // Distributive 1
     {
       l: 'n1*(n2+n3)',
       r: '(n1*n2+n1*n3)'
-    }, // Distributive 2
+    },
+    // Distributive 2
     {
       l: 'c1*n + c2*n',
       r: '(c1+c2)*n'
-    }, // Joining constants
+    },
+    // Joining constants
     {
       l: 'c1*n + n',
       r: '(c1+1)*n'
-    }, // Joining constants
+    },
+    // Joining constants
     {
       l: 'c1*n - c2*n',
       r: '(c1-c2)*n'
-    }, // Joining constants
+    },
+    // Joining constants
     {
       l: 'c1*n - n',
       r: '(c1-1)*n'
-    }, // Joining constants
+    },
+    // Joining constants
     {
       l: 'v/c',
       r: '(1/c)*v'
-    }, // variable/constant (new!)
+    },
+    // variable/constant (new!)
     {
       l: 'v/-c',
       r: '-(1/c)*v'
-    }, // variable/constant (new!)
+    },
+    // variable/constant (new!)
     {
       l: '-v*-c',
       r: 'c*v'
-    }, // Inversion constant and variable 1
+    },
+    // Inversion constant and variable 1
     {
       l: '-v*c',
       r: '-c*v'
-    }, // Inversion constant and variable 2
+    },
+    // Inversion constant and variable 2
     {
       l: 'v*-c',
       r: '-c*v'
-    }, // Inversion constant and variable 3
+    },
+    // Inversion constant and variable 3
     {
       l: 'v*c',
       r: 'c*v'
-    }, // Inversion constant and variable 4
+    },
+    // Inversion constant and variable 4
     {
       l: '-(-n1*n2)',
       r: '(n1*n2)'
-    }, // Unary propagation
+    },
+    // Unary propagation
     {
       l: '-(n1*n2)',
       r: '(-n1*n2)'
-    }, // Unary propagation
+    },
+    // Unary propagation
     {
       l: '-(-n1+n2)',
       r: '(n1-n2)'
-    }, // Unary propagation
+    },
+    // Unary propagation
     {
       l: '-(n1+n2)',
       r: '(-n1-n2)'
-    }, // Unary propagation
+    },
+    // Unary propagation
     {
       l: '(n1^n2)^n3',
       r: '(n1^(n2*n3))'
-    }, // Power to Power
+    },
+    // Power to Power
     {
       l: '-(-n1/n2)',
       r: '(n1/n2)'
-    }, // Division and Unary
+    },
+    // Division and Unary
     {
       l: '-(n1/n2)',
       r: '(-n1/n2)'
@@ -440,11 +406,13 @@ export var createRationalize = /* #__PURE__ */factory(name, dependencies, (_ref)
     var rulesDistrDiv = [{
       l: '(n1/n2 + n3/n4)',
       r: '((n1*n4 + n3*n2)/(n2*n4))'
-    }, // Sum of fractions
+    },
+    // Sum of fractions
     {
       l: '(n1/n2 + n3)',
       r: '((n1 + n3*n2)/n2)'
-    }, // Sum fraction with number 1
+    },
+    // Sum fraction with number 1
     {
       l: '(n1 + n2/n3)',
       r: '((n1*n3 + n2)/n3)'
@@ -453,100 +421,120 @@ export var createRationalize = /* #__PURE__ */factory(name, dependencies, (_ref)
     var rulesSucDiv = [{
       l: '(n1/(n2/n3))',
       r: '((n1*n3)/n2)'
-    }, // Division simplification
+    },
+    // Division simplification
     {
       l: '(n1/n2/n3)',
       r: '(n1/(n2*n3))'
     }];
     var setRules = {}; // rules set in 4 steps.
+
     // All rules => infinite loop
     // setRules.allRules =oldRules.concat(rulesFirst,rulesDistrDiv,rulesSucDiv)
 
     setRules.firstRules = oldRules.concat(rulesFirst, rulesSucDiv); // First rule set
-
     setRules.distrDivRules = rulesDistrDiv; // Just distr. div. rules
-
     setRules.sucDivRules = rulesSucDiv; // Jus succ. div. rules
-
     setRules.firstRulesAgain = oldRules.concat(rulesFirst); // Last rules set without succ. div.
+
     // Division simplification
+
     // Second rule set.
     // There is no aggregate expression with parentesis, but the only variable can be scattered.
-
-    setRules.finalRules = [simplifyCore, // simplify.rules[0]
+    setRules.finalRules = [simplifyCore,
+    // simplify.rules[0]
     {
       l: 'n*-n',
       r: '-n^2'
-    }, // Joining multiply with power 1
+    },
+    // Joining multiply with power 1
     {
       l: 'n*n',
       r: 'n^2'
-    }, // Joining multiply with power 2
-    simplifyConstant, // simplify.rules[14] old 3rd index in oldRules
+    },
+    // Joining multiply with power 2
+    simplifyConstant,
+    // simplify.rules[14] old 3rd index in oldRules
     {
       l: 'n*-n^n1',
       r: '-n^(n1+1)'
-    }, // Joining multiply with power 3
+    },
+    // Joining multiply with power 3
     {
       l: 'n*n^n1',
       r: 'n^(n1+1)'
-    }, // Joining multiply with power 4
+    },
+    // Joining multiply with power 4
     {
       l: 'n^n1*-n^n2',
       r: '-n^(n1+n2)'
-    }, // Joining multiply with power 5
+    },
+    // Joining multiply with power 5
     {
       l: 'n^n1*n^n2',
       r: 'n^(n1+n2)'
-    }, // Joining multiply with power 6
+    },
+    // Joining multiply with power 6
     {
       l: 'n^n1*-n',
       r: '-n^(n1+1)'
-    }, // Joining multiply with power 7
+    },
+    // Joining multiply with power 7
     {
       l: 'n^n1*n',
       r: 'n^(n1+1)'
-    }, // Joining multiply with power 8
+    },
+    // Joining multiply with power 8
     {
       l: 'n^n1/-n',
       r: '-n^(n1-1)'
-    }, // Joining multiply with power 8
+    },
+    // Joining multiply with power 8
     {
       l: 'n^n1/n',
       r: 'n^(n1-1)'
-    }, // Joining division with power 1
+    },
+    // Joining division with power 1
     {
       l: 'n/-n^n1',
       r: '-n^(1-n1)'
-    }, // Joining division with power 2
+    },
+    // Joining division with power 2
     {
       l: 'n/n^n1',
       r: 'n^(1-n1)'
-    }, // Joining division with power 3
+    },
+    // Joining division with power 3
     {
       l: 'n^n1/-n^n2',
       r: 'n^(n1-n2)'
-    }, // Joining division with power 4
+    },
+    // Joining division with power 4
     {
       l: 'n^n1/n^n2',
       r: 'n^(n1-n2)'
-    }, // Joining division with power 5
+    },
+    // Joining division with power 5
     {
       l: 'n1+(-n2*n3)',
       r: 'n1-n2*n3'
-    }, // Solving useless parenthesis 1
+    },
+    // Solving useless parenthesis 1
     {
       l: 'v*(-c)',
       r: '-c*v'
-    }, // Solving useless unary 2
+    },
+    // Solving useless unary 2
     {
       l: 'n1+-n2',
       r: 'n1-n2'
-    }, // Solving +- together (new!)
+    },
+    // Solving +- together (new!)
     {
       l: 'v*c',
       r: 'c*v'
-    }, // inversion constant with variable
+    },
+    // inversion constant with variable
     {
       l: '(n1^n2)^n3',
       r: '(n1^(n2*n3))'
@@ -554,8 +542,8 @@ export var createRationalize = /* #__PURE__ */factory(name, dependencies, (_ref)
     ];
     return setRules;
   } // End rulesRationalize
-  // ---------------------------------------------------------------------------------------
 
+  // ---------------------------------------------------------------------------------------
   /**
    *  Expand recursively a tree node for handling with expressions with exponents
    *  (it's not for constants, symbols or functions with exponents)
@@ -571,8 +559,6 @@ export var createRationalize = /* #__PURE__ */factory(name, dependencies, (_ref)
    *
    * @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
@@ -580,7 +566,6 @@ export var createRationalize = /* #__PURE__ */factory(name, dependencies, (_ref)
     if (tp === 'OperatorNode' && node.isBinary()) {
       var does = false;
       var 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') {
@@ -589,7 +574,6 @@ export var createRationalize = /* #__PURE__ */factory(name, dependencies, (_ref)
           does = val >= 2 && isInteger(val);
         }
       }
-
       if (does) {
         // Exponent >= 2
         // Before:
@@ -618,7 +602,6 @@ export var createRationalize = /* #__PURE__ */factory(name, dependencies, (_ref)
           //
           node = new OperatorNode('*', 'multiply', [node.args[0], node.args[0].cloneDeep()]);
         }
-
         if (internal) {
           // Change parent references in internal recursive calls
           if (indParent === 'content') {
@@ -628,10 +611,8 @@ export var createRationalize = /* #__PURE__ */factory(name, dependencies, (_ref)
           }
         }
       } // does
-
     } // binary OperatorNode
 
-
     if (tp === 'ParenthesisNode') {
       // Recursion
       expandPower(node.content, node, 'content');
@@ -640,14 +621,13 @@ export var createRationalize = /* #__PURE__ */factory(name, dependencies, (_ref)
         expandPower(node.args[i], node, i);
       }
     }
-
     if (!internal) {
       // return the root node
       return node;
     }
   } // End expandPower
-  // ---------------------------------------------------------------------------------------
 
+  // ---------------------------------------------------------------------------------------
   /**
    * Auxilary function for rationalize
    * Convert near canonical polynomial in one variable in a canonical polynomial
@@ -670,45 +650,37 @@ export var createRationalize = /* #__PURE__ */factory(name, dependencies, (_ref)
    *
    * @return {node}        new node tree with one variable polynomial or string error.
    */
-
-
   function polyToCanonical(node, coefficients) {
     if (coefficients === undefined) {
       coefficients = [];
     } // coefficients.
 
-
     coefficients[0] = 0; // index is the exponent
-
     var 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.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
 
     recurPol(node, null, o);
     maxExpo = coefficients.length - 1;
     var first = true;
     var no;
-
     for (var 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 ? '-' : '+';
-
       if (i > 0) {
         // Is not a constant without variable
         var n2 = new SymbolNode(varname);
-
         if (i > 1) {
           var n3 = new ConstantNode(i);
           n2 = new OperatorNode('^', 'pow', [n2, n3]);
         }
-
         if (coefficients[i] === -1 && first) {
           n1 = new OperatorNode('-', 'unaryMinus', [n2]);
         } else if (Math.abs(coefficients[i]) === 1) {
@@ -717,7 +689,6 @@ export var createRationalize = /* #__PURE__ */factory(name, dependencies, (_ref)
           n1 = new OperatorNode('*', 'multiply', [n1, n2]);
         }
       }
-
       if (first) {
         no = n1;
       } else if (op === '+') {
@@ -725,16 +696,15 @@ export var createRationalize = /* #__PURE__ */factory(name, dependencies, (_ref)
       } else {
         no = new OperatorNode('-', 'subtract', [no, n1]);
       }
-
       first = false;
     } // for
 
-
     if (first) {
       return new ConstantNode(0);
     } else {
       return no;
     }
+
     /**
      * Recursive auxilary function inside polyToCanonical for
      * converting expression in canonical form
@@ -749,11 +719,8 @@ export var createRationalize = /* #__PURE__ */factory(name, dependencies, (_ref)
      *
      * @return {}                    No return. If error, throws an exception
      */
-
-
     function recurPol(node, noPai, o) {
       var tp = node.type;
-
       if (tp === 'FunctionNode') {
         // ***** FunctionName *****
         // No function call in polynomial expression
@@ -761,70 +728,60 @@ export var createRationalize = /* #__PURE__ */factory(name, dependencies, (_ref)
       } else if (tp === 'OperatorNode') {
         // ***** OperatorName *****
         if ('+-*^'.indexOf(node.op) === -1) throw new Error('Operator ' + node.op + ' invalid');
-
         if (noPai !== null) {
           // -(unary),^  : children of *,+,-
           if ((node.fn === 'unaryMinus' || node.fn === 'pow') && noPai.fn !== 'add' && noPai.fn !== 'subtract' && noPai.fn !== 'multiply') {
             throw new Error('Invalid ' + node.op + ' placing');
-          } // -,+,* : children of +,-
-
+          }
 
+          // -,+,* : children of +,-
           if ((node.fn === 'subtract' || node.fn === 'add' || node.fn === 'multiply') && noPai.fn !== 'add' && noPai.fn !== 'subtract') {
             throw new Error('Invalid ' + node.op + ' placing');
-          } // -,+ : first child
-
+          }
 
+          // -,+ : first child
           if ((node.fn === 'subtract' || node.fn === 'add' || node.fn === 'unaryMinus') && o.noFil !== 0) {
             throw new Error('Invalid ' + node.op + ' placing');
           }
         } // Has parent
-        // Firers: ^,*       Old:   ^,&,-(unary): firers
-
 
+        // Firers: ^,*       Old:   ^,&,-(unary): firers
         if (node.op === '^' || node.op === '*') {
           o.fire = node.op;
         }
-
         for (var _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.noFil = _i; // number of son
-
           recurPol(node.args[_i], node, o);
         } // for in children
-
       } else if (tp === 'SymbolNode') {
         // ***** SymbolName *****
         if (node.name !== varname && varname !== '') {
           throw new Error('There is more than one variable');
         }
-
         varname = node.name;
-
         if (noPai === null) {
           coefficients[1] = 1;
           return;
-        } // ^: Symbol is First child
-
+        }
 
+        // ^: Symbol is First child
         if (noPai.op === '^' && o.noFil !== 0) {
           throw new Error('In power the variable should be the first parameter');
-        } // *: Symbol is Second child
-
+        }
 
+        // *: Symbol is Second child
         if (noPai.op === '*' && o.noFil !== 1) {
           throw new Error('In multiply the variable should be the second parameter');
-        } // Symbol: firers '',* => it means there is no exponent above, so it's 1 (cte * var)
-
+        }
 
+        // Symbol: firers '',* => it means there is no exponent above, so it's 1 (cte * var)
         if (o.fire === '' || o.fire === '*') {
           if (maxExpo < 1) coefficients[1] = 0;
           coefficients[1] += o.cte * (o.oper === '+' ? 1 : -1);
@@ -832,32 +789,25 @@ export var createRationalize = /* #__PURE__ */factory(name, dependencies, (_ref)
         }
       } else if (tp === 'ConstantNode') {
         var valor = parseFloat(node.value);
-
         if (noPai === null) {
           coefficients[0] = valor;
           return;
         }
-
         if (noPai.op === '^') {
           // cte: second  child of power
           if (o.noFil !== 1) throw new Error('Constant cannot be powered');
-
           if (!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 (var _i2 = maxExpo + 1; _i2 < valor; _i2++) coefficients[_i2] = 0;
           if (valor > maxExpo) coefficients[valor] = 0;
           coefficients[valor] += o.cte * (o.oper === '+' ? 1 : -1);
           maxExpo = Math.max(valor, maxExpo);
           return;
         }
+        o.cte = valor;
 
-        o.cte = valor; // Cte: firer '' => There is no exponent and no multiplication, so the exponent is 0.
-
+        // Cte: firer '' => There is no exponent and no multiplication, so the exponent is 0.
         if (o.fire === '') {
           coefficients[0] += o.cte * (o.oper === '+' ? 1 : -1);
         }
@@ -865,7 +815,5 @@ export var createRationalize = /* #__PURE__ */factory(name, dependencies, (_ref)
         throw new Error('Type ' + tp + ' is not allowed');
       }
     } // End of recurPol
-
   } // End of polyToCanonical
-
 });