mathjs 11.2.1 → 11.3.0

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

@@ -32,6 +32,7 @@ export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _
     OperatorNode,
     SymbolNode
   });
+
   /**
    * simplifyConstant() takes a mathjs expression (either a Node representing
    * a parse tree or a string which it parses to produce a node), and replaces
@@ -59,30 +60,24 @@ export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _
    *     Simplification options, as per simplify()
    * @return {Node} Returns expression with constant subexpressions evaluated
    */
-
   var simplifyConstant = typed('simplifyConstant', {
     Node: node => _ensureNode(foldFraction(node, {})),
     'Node, Object': function NodeObject(expr, options) {
       return _ensureNode(foldFraction(expr, options));
     }
   });
-
   function _removeFractions(thing) {
     if (isFraction(thing)) {
       return thing.valueOf();
     }
-
     if (thing instanceof Array) {
       return thing.map(_removeFractions);
     }
-
     if (isMatrix(thing)) {
       return matrix(_removeFractions(thing.valueOf()));
     }
-
     return thing;
   }
-
   function _eval(fnname, args, options) {
     try {
       return mathWithTransform[fnname].apply(null, args);
@@ -92,23 +87,21 @@ export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _
       return _toNumber(mathWithTransform[fnname].apply(null, args), options);
     }
   }
-
   var _toNode = typed({
     Fraction: _fractionToNode,
     number: function number(n) {
       if (n < 0) {
         return unaryMinusNode(new ConstantNode(-n));
       }
-
       return new ConstantNode(n);
     },
     BigNumber: function BigNumber(n) {
       if (n < 0) {
         return unaryMinusNode(new ConstantNode(-n));
       }
-
       return new ConstantNode(n); // old parameters: (n.toString(), 'number')
     },
+
     Complex: function Complex(s) {
       throw new Error('Cannot convert Complex number to Node');
     },
@@ -119,20 +112,17 @@ export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _
       return new ArrayNode(m.valueOf().map(e => _toNode(e)));
     }
   });
-
   function _ensureNode(thing) {
     if (isNode(thing)) {
       return thing;
     }
-
     return _toNode(thing);
-  } // convert a number to a fraction only if it can be expressed exactly,
-  // and when both numerator and denominator are small enough
-
+  }
 
+  // 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;
-
     if (exactFractions && isFinite(n) && fraction) {
       var f = fraction(n);
       var fractionsLimit = options && typeof options.fractionsLimit === 'number' ? options.fractionsLimit : Infinity; // no limit by default
@@ -141,25 +131,22 @@ export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _
         return f;
       }
     }
-
     return n;
-  } // Convert numbers to a preferred number type in preference order: Fraction, number, Complex
-  // BigNumbers are left alone
-
+  }
 
+  // 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') {
         if (bignumber === undefined) {
           noBignumber();
         }
-
         return bignumber(s);
       } else if (config.number === 'Fraction') {
         if (fraction === undefined) {
           noFraction();
         }
-
         return fraction(s);
       } else {
         var n = parseFloat(s);
@@ -170,10 +157,12 @@ export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _
       return s;
     },
     // we don't need options here
+
     'BigNumber, Object': function BigNumberObject(s, options) {
       return s;
     },
     // we don't need options here
+
     'number, Object': function numberObject(s, options) {
       return _exactFraction(s, options);
     },
@@ -181,7 +170,6 @@ export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _
       if (s.im !== 0) {
         return s;
       }
-
       return _exactFraction(s.re, options);
     },
     'Matrix, Object': function MatrixObject(s, options) {
@@ -191,36 +179,29 @@ export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _
       return s.map(_exactFraction);
     }
   });
-
   function unaryMinusNode(n) {
     return new OperatorNode('-', 'unaryMinus', [n]);
   }
-
   function _fractionToNode(f) {
     var n;
     var vn = f.s * f.n;
-
     if (vn < 0) {
       n = new OperatorNode('-', 'unaryMinus', [new ConstantNode(-vn)]);
     } else {
       n = new ConstantNode(vn);
     }
-
     if (f.d === 1) {
       return n;
     }
-
     return new OperatorNode('/', 'divide', [n, new ConstantNode(f.d)]);
   }
-  /* Handles constant indexing of ArrayNodes, matrices, and ObjectNodes */
-
 
+  /* Handles constant indexing of ArrayNodes, matrices, and ObjectNodes */
   function _foldAccessor(obj, index, options) {
     if (!isIndexNode(index)) {
       // don't know what to do with that...
       return new AccessorNode(_ensureNode(obj), _ensureNode(index));
     }
-
     if (isArrayNode(obj) || isMatrix(obj)) {
       var remainingDims = Array.from(index.dimensions);
       /* We will resolve constant indices one at a time, looking
@@ -229,27 +210,22 @@ export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _
        * out the third or higher dimension would be pretty intricate.
        * The price is that we miss simplifying [..3d array][x,y,1]
        */
-
       while (remainingDims.length > 0) {
         if (isConstantNode(remainingDims[0]) && typeof remainingDims[0].value !== 'string') {
           var first = _toNumber(remainingDims.shift().value, options);
-
           if (isArrayNode(obj)) {
             obj = obj.items[first - 1];
           } else {
             // matrix
             obj = obj.valueOf()[first - 1];
-
             if (obj instanceof Array) {
               obj = matrix(obj);
             }
           }
         } else if (remainingDims.length > 1 && isConstantNode(remainingDims[1]) && typeof remainingDims[1].value !== 'string') {
           var second = _toNumber(remainingDims[1].value, options);
-
           var tryItems = [];
           var fromItems = isArrayNode(obj) ? obj.items : obj.valueOf();
-
           for (var item of fromItems) {
             if (isArrayNode(item)) {
               tryItems.push(item.items[second - 1]);
@@ -259,7 +235,6 @@ export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _
               break;
             }
           }
-
           if (tryItems.length === fromItems.length) {
             if (isArrayNode(obj)) {
               obj = new ArrayNode(tryItems);
@@ -267,7 +242,6 @@ export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _
               // matrix
               obj = matrix(tryItems);
             }
-
             remainingDims.splice(1, 1);
           } else {
             // extracting slice along 2nd dimension failed, give up
@@ -278,37 +252,29 @@ export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _
           break;
         }
       }
-
       if (remainingDims.length === index.dimensions.length) {
         /* No successful constant indexing */
         return new AccessorNode(_ensureNode(obj), index);
       }
-
       if (remainingDims.length > 0) {
         /* Indexed some but not all dimensions */
         index = new IndexNode(remainingDims);
         return new AccessorNode(_ensureNode(obj), index);
       }
       /* All dimensions were constant, access completely resolved */
-
-
       return obj;
     }
-
     if (isObjectNode(obj) && index.dimensions.length === 1 && isConstantNode(index.dimensions[0])) {
       var key = index.dimensions[0].value;
-
       if (key in obj.properties) {
         return obj.properties[key];
       }
-
       return new ConstantNode(); // undefined
     }
     /* Don't know how to index this sort of obj, at least not with this index */
-
-
     return new AccessorNode(_ensureNode(obj), index);
   }
+
   /*
    * Create a binary tree from a list of Fractions and Nodes.
    * Tries to fold Fractions by evaluating them until the first Node in the list is hit, so
@@ -319,15 +285,12 @@ export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _
    * if args.length is 1, returns args[0]
    * @return - Either a Node representing a binary expression or Fraction
    */
-
-
   function foldOp(fn, args, makeNode, options) {
     return args.reduce(function (a, b) {
       if (!isNode(a) && !isNode(b)) {
         try {
           return _eval(fn, [a, b], options);
         } catch (ignoreandcontinue) {}
-
         a = _toNode(a);
         b = _toNode(b);
       } else if (!isNode(a)) {
@@ -335,82 +298,68 @@ export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _
       } else if (!isNode(b)) {
         b = _toNode(b);
       }
-
       return makeNode([a, b]);
     });
-  } // destroys the original node and returns a folded one
-
+  }
 
+  // destroys the original node and returns a folded one
   function foldFraction(node, options) {
     switch (node.type) {
       case 'SymbolNode':
         return node;
-
       case 'ConstantNode':
         switch (typeof node.value) {
           case 'number':
             return _toNumber(node.value, options);
-
           case 'string':
             return node.value;
-
           default:
             if (!isNaN(node.value)) return _toNumber(node.value, options);
         }
-
         return node;
-
       case 'FunctionNode':
         if (mathWithTransform[node.name] && mathWithTransform[node.name].rawArgs) {
           return node;
         }
-
         {
           // Process operators as OperatorNode
           var operatorFunctions = ['add', 'multiply'];
-
           if (operatorFunctions.indexOf(node.name) === -1) {
-            var args = node.args.map(arg => foldFraction(arg, options)); // If all args are numbers
+            var args = node.args.map(arg => foldFraction(arg, options));
 
+            // If all args are numbers
             if (!args.some(isNode)) {
               try {
                 return _eval(node.name, args, options);
               } catch (ignoreandcontinue) {}
-            } // Size of a matrix does not depend on entries
-
+            }
 
+            // Size of a matrix does not depend on entries
             if (node.name === 'size' && args.length === 1 && isArrayNode(args[0])) {
               var sz = [];
               var section = args[0];
-
               while (isArrayNode(section)) {
                 sz.push(section.items.length);
                 section = section.items[0];
               }
-
               return matrix(sz);
-            } // Convert all args to nodes and construct a symbolic function call
-
+            }
 
+            // Convert all args to nodes and construct a symbolic function call
             return new FunctionNode(node.name, args.map(_ensureNode));
-          } else {// treat as operator
+          } else {
+            // treat as operator
           }
         }
-
       /* falls through */
-
       case 'OperatorNode':
         {
           var fn = node.fn.toString();
-
           var _args;
-
           var res;
           var makeNode = createMakeNodeFunction(node);
-
           if (isOperatorNode(node) && node.isUnary()) {
             _args = [foldFraction(node.args[0], options)];
-
             if (!isNode(_args[0])) {
               res = _eval(fn, _args, options);
             } else {
@@ -419,12 +368,10 @@ export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _
           } else if (isAssociative(node, options.context)) {
             _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 (!isNode(_args[i])) {
                   consts.push(_args[i]);
@@ -432,7 +379,6 @@ export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _
                   vars.push(_args[i]);
                 }
               }
-
               if (consts.length > 1) {
                 res = foldOp(fn, consts, makeNode, options);
                 vars.unshift(res);
@@ -450,65 +396,47 @@ export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _
             _args = node.args.map(arg => foldFraction(arg, options));
             res = foldOp(fn, _args, makeNode, options);
           }
-
           return res;
         }
-
       case 'ParenthesisNode':
         // remove the uneccessary parenthesis
         return foldFraction(node.content, options);
-
       case 'AccessorNode':
         return _foldAccessor(foldFraction(node.object, options), foldFraction(node.index, options), options);
-
       case 'ArrayNode':
         {
           var foldItems = node.items.map(item => foldFraction(item, options));
-
           if (foldItems.some(isNode)) {
             return new ArrayNode(foldItems.map(_ensureNode));
           }
           /* All literals -- return a Matrix so we can operate on it */
-
-
           return matrix(foldItems);
         }
-
       case 'IndexNode':
         {
           return new IndexNode(node.dimensions.map(n => simplifyConstant(n, options)));
         }
-
       case 'ObjectNode':
         {
           var foldProps = {};
-
           for (var prop in node.properties) {
             foldProps[prop] = simplifyConstant(node.properties[prop], options);
           }
-
           return new ObjectNode(foldProps);
         }
-
       case 'AssignmentNode':
       /* falls through */
-
       case 'BlockNode':
       /* falls through */
-
       case 'FunctionAssignmentNode':
       /* falls through */
-
       case 'RangeNode':
       /* falls through */
-
       case 'ConditionalNode':
       /* falls through */
-
       default:
         throw new Error("Unimplemented node type in simplifyConstant: ".concat(node.type));
     }
   }
-
   return simplifyConstant;
 });

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

@@ -28,13 +28,12 @@ export var createSimplifyCore = /* #__PURE__ */factory(name, dependencies, _ref
   var node0 = new ConstantNode(0);
   var node1 = new ConstantNode(1);
   var nodeT = new ConstantNode(true);
-  var nodeF = new ConstantNode(false); // test if a node will always have a boolean value (true/false)
+  var nodeF = new ConstantNode(false);
+  // test if a node will always have a boolean value (true/false)
   // not sure if this list is complete
-
   function isAlwaysBoolean(node) {
     return isOperatorNode(node) && ['and', 'not', 'or'].includes(node.op);
   }
-
   var {
     hasProperty,
     isCommutative
@@ -87,39 +86,31 @@ export var createSimplifyCore = /* #__PURE__ */factory(name, dependencies, _ref
    *     Simplification options, as per simplify()
    * @return {Node} Returns expression with basic simplifications applied
    */
-
   function _simplifyCore(nodeToSimplify) {
     var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
     var context = options ? options.context : undefined;
-
     if (hasProperty(nodeToSimplify, 'trivial', context)) {
       // This node does nothing if it has only one argument, so if so,
       // return that argument simplified
       if (isFunctionNode(nodeToSimplify) && nodeToSimplify.args.length === 1) {
         return _simplifyCore(nodeToSimplify.args[0], options);
-      } // For other node types, we try the generic methods
-
-
+      }
+      // For other node types, we try the generic methods
       var simpChild = false;
       var childCount = 0;
       nodeToSimplify.forEach(c => {
         ++childCount;
-
         if (childCount === 1) {
           simpChild = _simplifyCore(c, options);
         }
       });
-
       if (childCount === 1) {
         return simpChild;
       }
     }
-
     var node = nodeToSimplify;
-
     if (isFunctionNode(node)) {
       var op = getOperator(node.name);
-
       if (op) {
         // Replace FunctionNode with a new OperatorNode
         if (node.args.length > 2 && hasProperty(node, 'associative', context)) {
@@ -130,23 +121,19 @@ export var createSimplifyCore = /* #__PURE__ */factory(name, dependencies, _ref
             node.args.push(new OperatorNode(op, node.name, [last, seclast]));
           }
         }
-
         node = new OperatorNode(op, node.name, node.args);
       } else {
         return new FunctionNode(_simplifyCore(node.fn), node.args.map(n => _simplifyCore(n, options)));
       }
     }
-
     if (isOperatorNode(node) && node.isUnary()) {
       var a0 = _simplifyCore(node.args[0], options);
-
       if (node.op === '~') {
         // bitwise not
         if (isOperatorNode(a0) && a0.isUnary() && a0.op === '~') {
           return a0.args[0];
         }
       }
-
       if (node.op === 'not') {
         // logical not
         if (isOperatorNode(a0) && a0.isUnary() && a0.op === 'not') {
@@ -158,9 +145,7 @@ export var createSimplifyCore = /* #__PURE__ */factory(name, dependencies, _ref
           }
         }
       }
-
       var finish = true;
-
       if (node.op === '-') {
         // unary minus
         if (isOperatorNode(a0)) {
@@ -174,46 +159,35 @@ export var createSimplifyCore = /* #__PURE__ */factory(name, dependencies, _ref
           }
         }
       }
-
       if (finish) return new OperatorNode(node.op, node.fn, [a0]);
     }
-
     if (isOperatorNode(node) && node.isBinary()) {
       var _a = _simplifyCore(node.args[0], options);
-
       var a1 = _simplifyCore(node.args[1], options);
-
       if (node.op === '+') {
         if (isConstantNode(_a) && isZero(_a.value)) {
           return a1;
         }
-
         if (isConstantNode(a1) && isZero(a1.value)) {
           return _a;
         }
-
         if (isOperatorNode(a1) && a1.isUnary() && a1.op === '-') {
           a1 = a1.args[0];
           node = new OperatorNode('-', 'subtract', [_a, a1]);
         }
       }
-
       if (node.op === '-') {
         if (isOperatorNode(a1) && a1.isUnary() && a1.op === '-') {
           return _simplifyCore(new OperatorNode('+', 'add', [_a, a1.args[0]]), options);
         }
-
         if (isConstantNode(_a) && isZero(_a.value)) {
           return _simplifyCore(new OperatorNode('-', 'unaryMinus', [a1]));
         }
-
         if (isConstantNode(a1) && isZero(a1.value)) {
           return _a;
         }
-
         return new OperatorNode(node.op, node.fn, [_a, a1]);
       }
-
       if (node.op === '*') {
         if (isConstantNode(_a)) {
           if (isZero(_a.value)) {
@@ -222,14 +196,12 @@ export var createSimplifyCore = /* #__PURE__ */factory(name, dependencies, _ref
             return a1;
           }
         }
-
         if (isConstantNode(a1)) {
           if (isZero(a1.value)) {
             return node0;
           } else if (equal(a1.value, 1)) {
             return _a;
           }
-
           if (isCommutative(node, context)) {
             return new OperatorNode(node.op, node.fn, [a1, _a], node.implicit); // constants on left
           }
@@ -237,19 +209,15 @@ export var createSimplifyCore = /* #__PURE__ */factory(name, dependencies, _ref
 
         return new OperatorNode(node.op, node.fn, [_a, a1], node.implicit);
       }
-
       if (node.op === '/') {
         if (isConstantNode(_a) && isZero(_a.value)) {
           return node0;
         }
-
         if (isConstantNode(a1) && equal(a1.value, 1)) {
           return _a;
         }
-
         return new OperatorNode(node.op, node.fn, [_a, a1]);
       }
-
       if (node.op === '^') {
         if (isConstantNode(a1)) {
           if (isZero(a1.value)) {
@@ -259,7 +227,6 @@ export var createSimplifyCore = /* #__PURE__ */factory(name, dependencies, _ref
           }
         }
       }
-
       if (node.op === 'and') {
         if (isConstantNode(_a)) {
           if (_a.value) {
@@ -268,7 +235,6 @@ export var createSimplifyCore = /* #__PURE__ */factory(name, dependencies, _ref
             return nodeF;
           }
         }
-
         if (isConstantNode(a1)) {
           if (a1.value) {
             if (isAlwaysBoolean(_a)) return _a;
@@ -277,7 +243,6 @@ export var createSimplifyCore = /* #__PURE__ */factory(name, dependencies, _ref
           }
         }
       }
-
       if (node.op === 'or') {
         if (isConstantNode(_a)) {
           if (_a.value) {
@@ -286,7 +251,6 @@ export var createSimplifyCore = /* #__PURE__ */factory(name, dependencies, _ref
             if (isAlwaysBoolean(a1)) return a1;
           }
         }
-
         if (isConstantNode(a1)) {
           if (a1.value) {
             return nodeT;
@@ -295,40 +259,30 @@ export var createSimplifyCore = /* #__PURE__ */factory(name, dependencies, _ref
           }
         }
       }
-
       return new OperatorNode(node.op, node.fn, [_a, a1]);
     }
-
     if (isOperatorNode(node)) {
       return new OperatorNode(node.op, node.fn, node.args.map(a => _simplifyCore(a, options)));
     }
-
     if (isArrayNode(node)) {
       return new ArrayNode(node.items.map(n => _simplifyCore(n, options)));
     }
-
     if (isAccessorNode(node)) {
       return new AccessorNode(_simplifyCore(node.object, options), _simplifyCore(node.index, options));
     }
-
     if (isIndexNode(node)) {
       return new IndexNode(node.dimensions.map(n => _simplifyCore(n, options)));
     }
-
     if (isObjectNode(node)) {
       var newProps = {};
-
       for (var prop in node.properties) {
         newProps[prop] = _simplifyCore(node.properties[prop], options);
       }
-
       return new ObjectNode(newProps);
-    } // cannot simplify
-
-
+    }
+    // cannot simplify
     return node;
   }
-
   return typed(name, {
     Node: _simplifyCore,
     'Node,Object': _simplifyCore