mathjs 11.2.0 → 11.3.0

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

@@ -31,7 +31,6 @@ export var createRationalize = /* #__PURE__ */factory(name, dependencies, _ref =
     SymbolNode,
     ParenthesisNode
   } = _ref;
-
   /**
    * Transform a rationalizable expression in a rational fraction.
    * If rational fraction is one variable polynomial then converts
@@ -89,9 +88,7 @@ export var createRationalize = /* #__PURE__ */factory(name, dependencies, _ref =
     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
@@ -100,20 +97,16 @@ export var createRationalize = /* #__PURE__ */factory(name, dependencies, _ref =
       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:
-
+      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:
@@ -122,7 +115,6 @@ export var createRationalize = /* #__PURE__ */factory(name, dependencies, _ref =
         eDistrDiv = !eDistrDiv; // Swap between Distr.Div and Succ. Div. Rules
 
         s = expr.toString();
-
         if (s === sBefore) {
           break; // No changes : end of the loop
         }
@@ -130,27 +122,22 @@ export var createRationalize = /* #__PURE__ */factory(name, dependencies, _ref =
         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:
-
-
+      }
+      // 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];
@@ -159,13 +146,12 @@ export var createRationalize = /* #__PURE__ */factory(name, dependencies, _ref =
       if (nVars === 1) {
         expr = polyToCanonical(expr, coefficients);
       }
-
       if (detailed) {
         retRationalize.numerator = expr;
         retRationalize.denominator = null;
       }
-    } // nVars
-
+    }
+    // nVars
 
     if (!detailed) return expr;
     retRationalize.coefficients = coefficients;
@@ -173,7 +159,6 @@ export var createRationalize = /* #__PURE__ */factory(name, dependencies, _ref =
     retRationalize.expression = expr;
     return retRationalize;
   }
-
   return typed(name, {
     Node: _rationalize,
     'Node, boolean': (expr, detailed) => _rationalize(expr, {}, detailed),
@@ -201,20 +186,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
@@ -231,10 +216,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');
@@ -250,17 +233,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);
@@ -271,10 +250,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
    *
@@ -284,17 +262,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'
@@ -314,91 +292,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)'
@@ -407,11 +407,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)'
@@ -420,109 +422,130 @@ 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))'
     } // Power to Power
     ];
+
     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)
@@ -538,8 +561,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
@@ -547,7 +568,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') {
@@ -556,7 +576,6 @@ export var createRationalize = /* #__PURE__ */factory(name, dependencies, _ref =
           does = val >= 2 && isInteger(val);
         }
       }
-
       if (does) {
         // Exponent >= 2
         // Before:
@@ -585,7 +604,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') {
@@ -595,10 +613,8 @@ export var createRationalize = /* #__PURE__ */factory(name, dependencies, _ref =
           }
         }
       } // does
-
     } // binary OperatorNode
 
-
     if (tp === 'ParenthesisNode') {
       // Recursion
       expandPower(node.content, node, 'content');
@@ -607,14 +623,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
@@ -637,45 +652,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) {
@@ -684,7 +691,6 @@ export var createRationalize = /* #__PURE__ */factory(name, dependencies, _ref =
           n1 = new OperatorNode('*', 'multiply', [n1, n2]);
         }
       }
-
       if (first) {
         no = n1;
       } else if (op === '+') {
@@ -692,16 +698,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
@@ -716,11 +721,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
@@ -728,70 +730,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);
@@ -799,32 +791,27 @@ 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;
           }
-
           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);
         }
@@ -832,7 +819,5 @@ export var createRationalize = /* #__PURE__ */factory(name, dependencies, _ref =
         throw new Error('Type ' + tp + ' is not allowed');
       }
     } // End of recurPol
-
   } // End of polyToCanonical
-
 });