mathjs 10.1.1 → 10.2.0

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

@@ -1,16 +1,24 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createUtil = void 0;
 
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
 var _is = require("../../../utils/is.js");
 
 var _factory = require("../../../utils/factory.js");
 
 var _object = require("../../../utils/object.js");
 
+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) { (0, _defineProperty2.default)(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; }
+
 var name = 'simplifyUtil';
 var dependencies = ['FunctionNode', 'OperatorNode', 'SymbolNode'];
 var createUtil = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
@@ -21,41 +29,166 @@ var createUtil = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functi
   // 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 (!(0, _is.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 ((0, _is.isOperatorNode)(nodeOrName)) {
+      name = nodeOrName.fn.toString();
+    } else if ((0, _is.isFunctionNode)(nodeOrName)) {
+      name = nodeOrName.name;
+    } else if ((0, _is.isParenthesisNode)(nodeOrName)) {
+      name = 'paren';
     }
 
-    var name = node.fn.toString();
+    if ((0, _object.hasOwnProperty)(context, name)) {
+      var properties = context[name];
+
+      if ((0, _object.hasOwnProperty)(properties, property)) {
+        return properties[property];
+      }
 
-    if (context && (0, _object.hasOwnProperty)(context, name) && (0, _object.hasOwnProperty)(context[name], 'commutative')) {
-      return context[name].commutative;
+      if ((0, _object.hasOwnProperty)(defaultContext, name)) {
+        return defaultContext[name][property];
+      }
     }
 
-    return commutative[name] || false;
-  }
+    if ((0, _object.hasOwnProperty)(context, defaultName)) {
+      var _properties = context[defaultName];
+
+      if ((0, _object.hasOwnProperty)(_properties, property)) {
+        return _properties[property];
+      }
 
-  function isAssociative(node, context) {
-    if (!(0, _is.isOperatorNode)(node)) {
-      return false;
+      return defaultContext[defaultName][property];
     }
+    /* name not found in context and context has no global default */
+
+    /* So use default context. */
 
-    var name = node.fn.toString();
 
-    if (context && (0, _object.hasOwnProperty)(context, name) && (0, _object.hasOwnProperty)(context[name], 'associative')) {
-      return context[name].associative;
+    if ((0, _object.hasOwnProperty)(defaultContext, name)) {
+      var _properties2 = defaultContext[name];
+
+      if ((0, _object.hasOwnProperty)(_properties2, property)) {
+        return _properties2[property];
+      }
+    }
+
+    return defaultContext[defaultName][property];
+  }
+
+  function isCommutative(node) {
+    var context = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : defaultContext;
+    return hasProperty(node, 'commutative', context);
+  }
+
+  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 ((0, _object.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.
@@ -63,15 +196,15 @@ var createUtil = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functi
    */
 
 
-  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);
     }
   }
   /**
@@ -80,7 +213,7 @@ var createUtil = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functi
    */
 
 
-  function allChildren(node) {
+  function allChildren(node, context) {
     var op;
     var children = [];
 
@@ -96,7 +229,7 @@ var createUtil = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functi
       }
     };
 
-    if (isAssociative(node)) {
+    if (isAssociative(node, context)) {
       op = node.op;
       findChildren(node);
       return children;
@@ -109,7 +242,7 @@ var createUtil = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functi
    */
 
 
-  function unflattenr(node) {
+  function unflattenr(node, context) {
     if (!node.args || node.args.length === 0) {
       return;
     }
@@ -118,10 +251,10 @@ var createUtil = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functi
     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) {
@@ -136,7 +269,7 @@ var createUtil = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functi
    */
 
 
-  function unflattenl(node) {
+  function unflattenl(node, context) {
     if (!node.args || node.args.length === 0) {
       return;
     }
@@ -145,10 +278,10 @@ var createUtil = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functi
     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) {
@@ -178,12 +311,17 @@ var createUtil = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functi
 
   return {
     createMakeNodeFunction: createMakeNodeFunction,
+    hasProperty: hasProperty,
     isCommutative: isCommutative,
     isAssociative: isAssociative,
+    mergeContext: mergeContext,
     flatten: flatten,
     allChildren: allChildren,
     unflattenr: unflattenr,
-    unflattenl: unflattenl
+    unflattenl: unflattenl,
+    defaultContext: defaultContext,
+    realContext: realContext,
+    positiveContext: positiveContext
   };
 });
 exports.createUtil = createUtil;