mathjs 10.0.0 → 10.6.4

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

@@ -1,20 +1,25 @@
 // TODO this could be improved by simplifying seperated constants under associative and commutative operators
-import { isFraction, isNode, isOperatorNode } from '../../../utils/is.js';
+import { isFraction, isMatrix, isNode, isArrayNode, isConstantNode, isIndexNode, isObjectNode, isOperatorNode } from '../../../utils/is.js';
 import { factory } from '../../../utils/factory.js';
 import { createUtil } from './util.js';
 import { noBignumber, noFraction } from '../../../utils/noop.js';
 var name = 'simplifyConstant';
-var dependencies = ['typed', 'config', 'mathWithTransform', '?fraction', '?bignumber', 'ConstantNode', 'OperatorNode', 'FunctionNode', 'SymbolNode'];
+var dependencies = ['typed', 'config', 'mathWithTransform', 'matrix', '?fraction', '?bignumber', 'AccessorNode', 'ArrayNode', 'ConstantNode', 'FunctionNode', 'IndexNode', 'ObjectNode', 'OperatorNode', 'SymbolNode'];
 export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     config,
     mathWithTransform,
+    matrix,
     fraction,
     bignumber,
+    AccessorNode,
+    ArrayNode,
     ConstantNode,
-    OperatorNode,
     FunctionNode,
+    IndexNode,
+    ObjectNode,
+    OperatorNode,
     SymbolNode
   } = _ref;
   var {
@@ -29,22 +34,31 @@ export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _
   });
 
   function simplifyConstant(expr, options) {
-    var res = foldFraction(expr, options);
-    return isNode(res) ? res : _toNode(res);
+    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 _toNumber(mathWithTransform[fnname].apply(null, args), options);
+      return mathWithTransform[fnname].apply(null, args);
     } catch (ignore) {
       // sometimes the implicit type conversion causes the evaluation to fail, so we'll try again after removing Fractions
-      args = args.map(function (x) {
-        if (isFraction(x)) {
-          return x.valueOf();
-        }
-
-        return x;
-      });
+      args = args.map(_removeFractions);
       return _toNumber(mathWithTransform[fnname].apply(null, args), options);
     }
   }
@@ -67,8 +81,22 @@ export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _
     },
     Complex: function Complex(s) {
       throw new Error('Cannot convert Complex number to Node');
+    },
+    string: function string(s) {
+      return new ConstantNode(s);
+    },
+    Matrix: function Matrix(m) {
+      return new ArrayNode(m.valueOf().map(e => _toNode(e)));
+    }
+  });
+
+  function _ensureNode(thing) {
+    if (isNode(thing)) {
+      return thing;
     }
-  }); // convert a number to a fraction only if it can be expressed exactly,
+
+    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
 
 
@@ -125,6 +153,12 @@ export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _
       }
 
       return _exactFraction(s.re, options);
+    },
+    'Matrix, Object': function MatrixObject(s, options) {
+      return matrix(_exactFraction(s.valueOf()));
+    },
+    'Array, Object': function ArrayObject(s, options) {
+      return s.map(_exactFraction);
     }
   });
 
@@ -148,6 +182,103 @@ export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _
 
     return new OperatorNode('/', 'divide', [n, new ConstantNode(f.d)]);
   }
+  /* 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
+       * just in the first or second dimensions because (a) arrays
+       * of more than two dimensions are likely rare, and (b) pulling
+       * 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]);
+            } else if (isMatrix(obj)) {
+              tryItems.push(item[second - 1]);
+            } else {
+              break;
+            }
+          }
+
+          if (tryItems.length === fromItems.length) {
+            if (isArrayNode(obj)) {
+              obj = new ArrayNode(tryItems);
+            } else {
+              // matrix
+              obj = matrix(tryItems);
+            }
+
+            remainingDims.splice(1, 1);
+          } else {
+            // extracting slice along 2nd dimension failed, give up
+            break;
+          }
+        } else {
+          // neither 1st or 2nd dimension is constant, give up
+          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
@@ -186,8 +317,15 @@ export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _
         return node;
 
       case 'ConstantNode':
-        if (typeof node.value === 'number' || !isNaN(node.value)) {
-          return _toNumber(node.value, options);
+        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;
@@ -207,14 +345,24 @@ export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _
             if (!args.some(isNode)) {
               try {
                 return _eval(node.name, args, options);
-              } catch (ignoreandcontine) {}
+              } catch (ignoreandcontinue) {}
+            } // 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
 
 
-            args = args.map(function (arg) {
-              return isNode(arg) ? arg : _toNode(arg);
-            });
-            return new FunctionNode(node.name, args);
+            return new FunctionNode(node.name, args.map(_ensureNode));
           } else {// treat as operator
           }
         }
@@ -238,11 +386,11 @@ export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _
             } else {
               res = makeNode(_args);
             }
-          } else if (isAssociative(node)) {
-            _args = allChildren(node);
+          } else if (isAssociative(node, options.context)) {
+            _args = allChildren(node, options.context);
             _args = _args.map(arg => foldFraction(arg, options));
 
-            if (isCommutative(fn)) {
+            if (isCommutative(fn, options.context)) {
               // commutative binary operator
               var consts = [];
               var vars = [];
@@ -281,10 +429,36 @@ export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _
         return foldFraction(node.content, options);
 
       case 'AccessorNode':
-      /* falls through */
+        return _foldAccessor(foldFraction(node.object, options), foldFraction(node.index, options), options);
 
       case 'ArrayNode':
-      /* falls through */
+        {
+          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 */
@@ -295,12 +469,6 @@ export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _
       case 'FunctionAssignmentNode':
       /* falls through */
 
-      case 'IndexNode':
-      /* falls through */
-
-      case 'ObjectNode':
-      /* falls through */
-
       case 'RangeNode':
       /* falls through */
 

package/lib/esm/function/algebra/simplify/util.js

@@ -1,4 +1,10 @@
-import { isOperatorNode } from '../../../utils/is.js';
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+import { isFunctionNode, isOperatorNode, isParenthesisNode } from '../../../utils/is.js';
 import { factory } from '../../../utils/factory.js';
 import { hasOwnProperty } from '../../../utils/object.js';
 var name = 'simplifyUtil';
@@ -13,41 +19,166 @@ export var createUtil = /* #__PURE__ */factory(name, dependencies, _ref => {
   // e.g. multiply is not commutative for matrices
   // The properties should be calculated from an argument to simplify, or possibly something in math.config
   // the other option is for typed() to specify a return type so that we can evaluate the type of arguments
-  var commutative = {
-    add: true,
-    multiply: true
+
+  /* So that properties of an operator fit on one line: */
+  var T = true;
+  var F = false;
+  var defaultName = 'defaultF';
+  var defaultContext = {
+    /*      */
+    add: {
+      trivial: T,
+      total: T,
+      commutative: T,
+      associative: T
+    },
+
+    /**/
+    unaryPlus: {
+      trivial: T,
+      total: T,
+      commutative: T,
+      associative: T
+    },
+
+    /* */
+    subtract: {
+      trivial: F,
+      total: T,
+      commutative: F,
+      associative: F
+    },
+
+    /* */
+    multiply: {
+      trivial: T,
+      total: T,
+      commutative: T,
+      associative: T
+    },
+
+    /*   */
+    divide: {
+      trivial: F,
+      total: T,
+      commutative: F,
+      associative: F
+    },
+
+    /*    */
+    paren: {
+      trivial: T,
+      total: T,
+      commutative: T,
+      associative: F
+    },
+
+    /* */
+    defaultF: {
+      trivial: F,
+      total: T,
+      commutative: F,
+      associative: F
+    }
+  };
+  var realContext = {
+    divide: {
+      total: F
+    },
+    log: {
+      total: F
+    }
   };
-  var associative = {
-    add: true,
-    multiply: true
+  var positiveContext = {
+    subtract: {
+      total: F
+    },
+    abs: {
+      trivial: T
+    },
+    log: {
+      total: T
+    }
   };
 
-  function isCommutative(node, context) {
-    if (!isOperatorNode(node)) {
-      return true;
+  function hasProperty(nodeOrName, property) {
+    var context = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : defaultContext;
+    var name = defaultName;
+
+    if (typeof nodeOrName === 'string') {
+      name = nodeOrName;
+    } else if (isOperatorNode(nodeOrName)) {
+      name = nodeOrName.fn.toString();
+    } else if (isFunctionNode(nodeOrName)) {
+      name = nodeOrName.name;
+    } else if (isParenthesisNode(nodeOrName)) {
+      name = 'paren';
     }
 
-    var name = node.fn.toString();
+    if (hasOwnProperty(context, name)) {
+      var properties = context[name];
 
-    if (context && hasOwnProperty(context, name) && hasOwnProperty(context[name], 'commutative')) {
-      return context[name].commutative;
+      if (hasOwnProperty(properties, property)) {
+        return properties[property];
+      }
+
+      if (hasOwnProperty(defaultContext, name)) {
+        return defaultContext[name][property];
+      }
     }
 
-    return commutative[name] || false;
-  }
+    if (hasOwnProperty(context, defaultName)) {
+      var _properties = context[defaultName];
+
+      if (hasOwnProperty(_properties, property)) {
+        return _properties[property];
+      }
+
+      return defaultContext[defaultName][property];
+    }
+    /* name not found in context and context has no global default */
+
+    /* So use default context. */
+
+
+    if (hasOwnProperty(defaultContext, name)) {
+      var _properties2 = defaultContext[name];
 
-  function isAssociative(node, context) {
-    if (!isOperatorNode(node)) {
-      return false;
+      if (hasOwnProperty(_properties2, property)) {
+        return _properties2[property];
+      }
     }
 
-    var name = node.fn.toString();
+    return defaultContext[defaultName][property];
+  }
+
+  function isCommutative(node) {
+    var context = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : defaultContext;
+    return hasProperty(node, 'commutative', context);
+  }
 
-    if (context && hasOwnProperty(context, name) && hasOwnProperty(context[name], 'associative')) {
-      return context[name].associative;
+  function isAssociative(node) {
+    var context = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : defaultContext;
+    return hasProperty(node, 'associative', context);
+  }
+  /**
+   * Merge the given contexts, with primary overriding secondary
+   * wherever they might conflict
+   */
+
+
+  function mergeContext(primary, secondary) {
+    var merged = _objectSpread({}, primary);
+
+    for (var prop in secondary) {
+      if (hasOwnProperty(primary, prop)) {
+        merged[prop] = _objectSpread(_objectSpread({}, secondary[prop]), primary[prop]);
+      } else {
+        merged[prop] = secondary[prop];
+      }
     }
 
-    return associative[name] || false;
+    return merged;
   }
   /**
    * Flatten all associative operators in an expression tree.
@@ -55,15 +186,15 @@ export var createUtil = /* #__PURE__ */factory(name, dependencies, _ref => {
    */
 
 
-  function flatten(node) {
+  function flatten(node, context) {
     if (!node.args || node.args.length === 0) {
       return node;
     }
 
-    node.args = allChildren(node);
+    node.args = allChildren(node, context);
 
     for (var i = 0; i < node.args.length; i++) {
-      flatten(node.args[i]);
+      flatten(node.args[i], context);
     }
   }
   /**
@@ -72,7 +203,7 @@ export var createUtil = /* #__PURE__ */factory(name, dependencies, _ref => {
    */
 
 
-  function allChildren(node) {
+  function allChildren(node, context) {
     var op;
     var children = [];
 
@@ -88,7 +219,7 @@ export var createUtil = /* #__PURE__ */factory(name, dependencies, _ref => {
       }
     };
 
-    if (isAssociative(node)) {
+    if (isAssociative(node, context)) {
       op = node.op;
       findChildren(node);
       return children;
@@ -101,7 +232,7 @@ export var createUtil = /* #__PURE__ */factory(name, dependencies, _ref => {
    */
 
 
-  function unflattenr(node) {
+  function unflattenr(node, context) {
     if (!node.args || node.args.length === 0) {
       return;
     }
@@ -110,10 +241,10 @@ export var createUtil = /* #__PURE__ */factory(name, dependencies, _ref => {
     var l = node.args.length;
 
     for (var i = 0; i < l; i++) {
-      unflattenr(node.args[i]);
+      unflattenr(node.args[i], context);
     }
 
-    if (l > 2 && isAssociative(node)) {
+    if (l > 2 && isAssociative(node, context)) {
       var curnode = node.args.pop();
 
       while (node.args.length > 0) {
@@ -128,7 +259,7 @@ export var createUtil = /* #__PURE__ */factory(name, dependencies, _ref => {
    */
 
 
-  function unflattenl(node) {
+  function unflattenl(node, context) {
     if (!node.args || node.args.length === 0) {
       return;
     }
@@ -137,10 +268,10 @@ export var createUtil = /* #__PURE__ */factory(name, dependencies, _ref => {
     var l = node.args.length;
 
     for (var i = 0; i < l; i++) {
-      unflattenl(node.args[i]);
+      unflattenl(node.args[i], context);
     }
 
-    if (l > 2 && isAssociative(node)) {
+    if (l > 2 && isAssociative(node, context)) {
       var curnode = node.args.shift();
 
       while (node.args.length > 0) {
@@ -170,11 +301,16 @@ export var createUtil = /* #__PURE__ */factory(name, dependencies, _ref => {
 
   return {
     createMakeNodeFunction,
+    hasProperty,
     isCommutative,
     isAssociative,
+    mergeContext,
     flatten,
     allChildren,
     unflattenr,
-    unflattenl
+    unflattenl,
+    defaultContext,
+    realContext,
+    positiveContext
   };
 });