mathjs 10.1.0 → 10.3.0

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

@@ -11,10 +11,8 @@ var _factory = require("../../utils/factory.js");
 
 var _simplifyConstant = require("./simplify/simplifyConstant.js");
 
-var _simplifyCore = require("./simplify/simplifyCore.js");
-
 var name = 'rationalize';
-var dependencies = ['config', 'typed', 'equal', 'isZero', 'add', 'subtract', 'multiply', 'divide', 'pow', 'parse', 'simplify', '?bignumber', '?fraction', 'mathWithTransform', 'matrix', 'AccessorNode', 'ArrayNode', 'ConstantNode', 'FunctionNode', 'IndexNode', 'ObjectNode', 'OperatorNode', 'SymbolNode', 'ParenthesisNode'];
+var dependencies = ['config', 'typed', 'equal', 'isZero', 'add', 'subtract', 'multiply', 'divide', 'pow', 'parse', 'simplifyCore', 'simplify', '?bignumber', '?fraction', 'mathWithTransform', 'matrix', 'AccessorNode', 'ArrayNode', 'ConstantNode', 'FunctionNode', 'IndexNode', 'ObjectNode', 'OperatorNode', 'SymbolNode', 'ParenthesisNode'];
 var createRationalize = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var config = _ref.config,
       typed = _ref.typed,
@@ -26,6 +24,7 @@ var createRationalize = /* #__PURE__ */(0, _factory.factory)(name, dependencies,
       divide = _ref.divide,
       pow = _ref.pow,
       parse = _ref.parse,
+      simplifyCore = _ref.simplifyCore,
       simplify = _ref.simplify,
       fraction = _ref.fraction,
       bignumber = _ref.bignumber,
@@ -56,23 +55,6 @@ var createRationalize = /* #__PURE__ */(0, _factory.factory)(name, dependencies,
     OperatorNode: OperatorNode,
     SymbolNode: SymbolNode
   });
-  var simplifyCore = (0, _simplifyCore.createSimplifyCore)({
-    equal: equal,
-    isZero: isZero,
-    add: add,
-    subtract: subtract,
-    multiply: multiply,
-    divide: divide,
-    pow: pow,
-    AccessorNode: AccessorNode,
-    ArrayNode: ArrayNode,
-    ConstantNode: ConstantNode,
-    FunctionNode: FunctionNode,
-    IndexNode: IndexNode,
-    ObjectNode: ObjectNode,
-    OperatorNode: OperatorNode,
-    ParenthesisNode: ParenthesisNode
-  });
   /**
    * Transform a rationalizable expression in a rational fraction.
    * If rational fraction is one variable polynomial then converts
@@ -116,13 +98,13 @@ var createRationalize = /* #__PURE__ */(0, _factory.factory)(name, dependencies,
    * @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
    *
    */
@@ -155,6 +137,12 @@ var createRationalize = /* #__PURE__ */(0, _factory.factory)(name, dependencies,
       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) {
@@ -165,18 +153,16 @@ var createRationalize = /* #__PURE__ */(0, _factory.factory)(name, dependencies,
 
         var rules;
         var eDistrDiv = true;
-        var redoInic = false;
-        expr = simplify(expr, setRules.firstRules, {}, {
-          exactFractions: 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) {
-          // Apply alternately  successive division rules and distr.div.rules
+          // 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); // until no more changes
-
+          expr = simplify(expr, rules, {}, withExactFractions);
           eDistrDiv = !eDistrDiv; // Swap between Distr.Div and Succ. Div. Rules
 
           s = expr.toString();
@@ -191,14 +177,11 @@ var createRationalize = /* #__PURE__ */(0, _factory.factory)(name, dependencies,
 
         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.firstRulesAgain, {}, noExactFractions);
+        } // Apply final rules:
+
 
-        expr = simplify(expr, setRules.finalRules, {}, {
-          exactFractions: false
-        }); // Apply final rules
+        expr = simplify(expr, setRules.finalRules, {}, noExactFractions);
       } // NVars >= 1
 
 

package/lib/cjs/function/algebra/resolve.js

@@ -0,0 +1,106 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createResolve = void 0;
+
+var _map = require("../../utils/map.js");
+
+var _is = require("../../utils/is.js");
+
+var _factory = require("../../utils/factory.js");
+
+var name = 'resolve';
+var dependencies = ['parse', 'ConstantNode', 'FunctionNode', 'OperatorNode', 'ParenthesisNode'];
+var createResolve = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var parse = _ref.parse,
+      ConstantNode = _ref.ConstantNode,
+      FunctionNode = _ref.FunctionNode,
+      OperatorNode = _ref.OperatorNode,
+      ParenthesisNode = _ref.ParenthesisNode;
+
+  /**
+   * resolve(expr, scope) replaces variable nodes with their scoped values
+   *
+   * Syntax:
+   *
+   *     resolve(expr, scope)
+   *
+   * Examples:
+   *
+   *     math.resolve('x + y', {x:1, y:2})           // Node {1 + 2}
+   *     math.resolve(math.parse('x+y'), {x:1, y:2}) // Node {1 + 2}
+   *     math.simplify('x+y', {x:2, y:'x+x'}).toString()      // "6"
+   *
+   * See also:
+   *
+   *     simplify, evaluate
+   *
+   * @param {Node} node
+   *     The expression tree to be simplified
+   * @param {Object} scope
+   *     Scope specifying variables to be resolved
+   * @return {Node} Returns `node` with variables recursively substituted.
+   * @throws {ReferenceError}
+   *     If there is a cyclic dependency among the variables in `scope`,
+   *     resolution is impossible and a ReferenceError is thrown.
+   */
+  function resolve(node, scope) {
+    var within = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new Set();
+
+    // note `within`:
+    // `within` is not documented, since it is for internal cycle
+    // detection only
+    if (!scope) {
+      return node;
+    }
+
+    if (!(0, _map.isMap)(scope)) {
+      scope = (0, _map.createMap)(scope);
+    }
+
+    if ((0, _is.isSymbolNode)(node)) {
+      if (within.has(node.name)) {
+        var variables = Array.from(within).join(', ');
+        throw new ReferenceError("recursive loop of variable definitions among {".concat(variables, "}"));
+      }
+
+      var value = scope.get(node.name);
+
+      if ((0, _is.isNode)(value)) {
+        var nextWithin = new Set(within);
+        nextWithin.add(node.name);
+        return resolve(value, scope, nextWithin);
+      } else if (typeof value === 'number') {
+        return parse(String(value));
+      } else if (value !== undefined) {
+        return new ConstantNode(value);
+      } else {
+        return node;
+      }
+    } else if ((0, _is.isOperatorNode)(node)) {
+      var args = node.args.map(function (arg) {
+        return resolve(arg, scope, within);
+      });
+      return new OperatorNode(node.op, node.fn, args, node.implicit);
+    } else if ((0, _is.isParenthesisNode)(node)) {
+      return new ParenthesisNode(resolve(node.content, scope, within));
+    } else if ((0, _is.isFunctionNode)(node)) {
+      var _args = node.args.map(function (arg) {
+        return resolve(arg, scope, within);
+      });
+
+      return new FunctionNode(node.name, _args);
+    } // Otherwise just recursively resolve any children (might also work
+    // for some of the above special cases)
+
+
+    return node.map(function (child) {
+      return resolve(child, scope, within);
+    });
+  }
+
+  return resolve;
+});
+exports.createResolve = createResolve;

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

@@ -17,7 +17,7 @@ var _util = require("./util.js");
 
 var _noop = require("../../../utils/noop.js");
 
-function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
 
 function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
 
@@ -348,7 +348,7 @@ var createSimplifyConstant = /* #__PURE__ */(0, _factory.factory)(name, dependen
         return node;
 
       case 'ConstantNode':
-        switch ((0, _typeof2["default"])(node.value)) {
+        switch ((0, _typeof2.default)(node.value)) {
           case 'number':
             return _toNumber(node.value, options);
 
@@ -419,13 +419,13 @@ var createSimplifyConstant = /* #__PURE__ */(0, _factory.factory)(name, dependen
             } 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(function (arg) {
               return foldFraction(arg, options);
             });
 
-            if (isCommutative(fn)) {
+            if (isCommutative(fn, options.context)) {
               // commutative binary operator
               var consts = [];
               var vars = [];

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;