mathjs 10.2.0 → 10.4.1

package/lib/cjs/expression/embeddedDocs/function/algebra/symbolicEqual.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.symbolicEqualDocs = void 0;
+var symbolicEqualDocs = {
+  name: 'symbolicEqual',
+  category: 'Algebra',
+  syntax: ['symbolicEqual(expr1, expr2)', 'symbolicEqual(expr1, expr2, options)'],
+  description: 'Returns true if the difference of the expressions simplifies to 0',
+  examples: ['symbolicEqual("x*y","y*x")', 'symbolicEqual("abs(x^2)", "x^2")', 'symbolicEqual("abs(x)", "x", {context: {abs: {trivial: true}}})'],
+  seealso: ['simplify', 'evaluate']
+};
+exports.symbolicEqualDocs = symbolicEqualDocs;

package/lib/cjs/expression/embeddedDocs/function/matrix/subset.js

@@ -8,8 +8,8 @@ var subsetDocs = {
   name: 'subset',
   category: 'Matrix',
   syntax: ['value(index)', 'value(index) = replacement', 'subset(value, [index])', 'subset(value, [index], replacement)'],
-  description: 'Get or set a subset of a matrix or string. ' + 'Indexes are one-based. ' + 'Both the ranges lower-bound and upper-bound are included.',
-  examples: ['d = [1, 2; 3, 4]', 'e = []', 'e[1, 1:2] = [5, 6]', 'e[2, :] = [7, 8]', 'f = d * e', 'f[2, 1]', 'f[:, 1]'],
+  description: 'Get or set a subset of the entries of a matrix or ' + 'characters of a string. ' + 'Indexes are one-based. There should be one index specification for ' + 'each dimension of the target. Each specification can be a single ' + 'index, a list of indices, or a range in colon notation `l:u`. ' + 'In a range, both the lower bound l and upper bound u are included; ' + 'and if a bound is omitted it defaults to the most extreme valid value. ' + 'The cartesian product of the indices specified in each dimension ' + 'determines the target of the operation.',
+  examples: ['d = [1, 2; 3, 4]', 'e = []', 'e[1, 1:2] = [5, 6]', 'e[2, :] = [7, 8]', 'f = d * e', 'f[2, 1]', 'f[:, 1]', 'f[[1,2], [1,3]] = [9, 10; 11, 12]', 'f'],
   seealso: ['concat', 'det', 'diag', 'identity', 'inv', 'ones', 'range', 'size', 'squeeze', 'trace', 'transpose', 'zeros']
 };
 exports.subsetDocs = subsetDocs;

package/lib/cjs/expression/embeddedDocs/function/statistics/cumsum.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cumSumDocs = void 0;
+var cumSumDocs = {
+  name: 'cumsum',
+  category: 'Statistics',
+  syntax: ['cumsum(a, b, c, ...)', 'cumsum(A)'],
+  description: 'Compute the cumulative sum of all values.',
+  examples: ['cumsum(2, 3, 4, 1)', 'cumsum([2, 3, 4, 1])', 'cumsum([1, 2; 3, 4])', 'cumsum([1, 2; 3, 4], 1)', 'cumsum([1, 2; 3, 4], 2)'],
+  seealso: ['max', 'mean', 'median', 'min', 'prod', 'std', 'sum', 'variance']
+};
+exports.cumSumDocs = cumSumDocs;

package/lib/cjs/expression/node/FunctionNode.js

@@ -97,78 +97,97 @@ var createFunctionNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies
     });
 
     if ((0, _is.isSymbolNode)(this.fn)) {
-      // we can statically determine whether the function has an rawArgs property
       var _name = this.fn.name;
-      var fn = _name in math ? (0, _customs.getSafeProperty)(math, _name) : undefined;
-      var isRaw = typeof fn === 'function' && fn.rawArgs === true;
 
-      var resolveFn = function resolveFn(scope) {
-        if (scope.has(_name)) {
-          return scope.get(_name);
-        }
+      if (!argNames[_name]) {
+        // we can statically determine whether the function has an rawArgs property
+        var fn = _name in math ? (0, _customs.getSafeProperty)(math, _name) : undefined;
+        var isRaw = typeof fn === 'function' && fn.rawArgs === true;
 
-        if (_name in math) {
-          return (0, _customs.getSafeProperty)(math, _name);
-        }
+        var resolveFn = function resolveFn(scope) {
+          if (scope.has(_name)) {
+            return scope.get(_name);
+          }
 
-        return FunctionNode.onUndefinedFunction(_name);
-      };
+          if (_name in math) {
+            return (0, _customs.getSafeProperty)(math, _name);
+          }
 
-      if (isRaw) {
-        // pass unevaluated parameters (nodes) to the function
-        // "raw" evaluation
-        var rawArgs = this.args;
-        return function evalFunctionNode(scope, args, context) {
-          var fn = resolveFn(scope);
-          return fn(rawArgs, math, (0, _scope.createSubScope)(scope, args), scope);
+          return FunctionNode.onUndefinedFunction(_name);
         };
-      } else {
-        // "regular" evaluation
-        switch (evalArgs.length) {
-          case 0:
-            return function evalFunctionNode(scope, args, context) {
-              var fn = resolveFn(scope);
-              return fn();
-            };
-
-          case 1:
-            return function evalFunctionNode(scope, args, context) {
-              var fn = resolveFn(scope);
-              var evalArg0 = evalArgs[0];
-              return fn(evalArg0(scope, args, context));
-            };
-
-          case 2:
-            return function evalFunctionNode(scope, args, context) {
-              var fn = resolveFn(scope);
-              var evalArg0 = evalArgs[0];
-              var evalArg1 = evalArgs[1];
-              return fn(evalArg0(scope, args, context), evalArg1(scope, args, context));
-            };
-
-          default:
-            return function evalFunctionNode(scope, args, context) {
-              var fn = resolveFn(scope);
-              var values = evalArgs.map(function (evalArg) {
-                return evalArg(scope, args, context);
-              });
-              return fn.apply(void 0, (0, _toConsumableArray2.default)(values));
-            };
+
+        if (isRaw) {
+          // pass unevaluated parameters (nodes) to the function
+          // "raw" evaluation
+          var rawArgs = this.args;
+          return function evalFunctionNode(scope, args, context) {
+            var fn = resolveFn(scope);
+            return fn(rawArgs, math, (0, _scope.createSubScope)(scope, args), scope);
+          };
+        } else {
+          // "regular" evaluation
+          switch (evalArgs.length) {
+            case 0:
+              return function evalFunctionNode(scope, args, context) {
+                var fn = resolveFn(scope);
+                return fn();
+              };
+
+            case 1:
+              return function evalFunctionNode(scope, args, context) {
+                var fn = resolveFn(scope);
+                var evalArg0 = evalArgs[0];
+                return fn(evalArg0(scope, args, context));
+              };
+
+            case 2:
+              return function evalFunctionNode(scope, args, context) {
+                var fn = resolveFn(scope);
+                var evalArg0 = evalArgs[0];
+                var evalArg1 = evalArgs[1];
+                return fn(evalArg0(scope, args, context), evalArg1(scope, args, context));
+              };
+
+            default:
+              return function evalFunctionNode(scope, args, context) {
+                var fn = resolveFn(scope);
+                var values = evalArgs.map(function (evalArg) {
+                  return evalArg(scope, args, context);
+                });
+                return fn.apply(void 0, (0, _toConsumableArray2.default)(values));
+              };
+          }
         }
+      } else {
+        // the function symbol is an argName
+        var _rawArgs = this.args;
+        return function evalFunctionNode(scope, args, context) {
+          var fn = args[_name];
+          var isRaw = fn && fn.rawArgs;
+
+          if (isRaw) {
+            return fn(_rawArgs, math, (0, _scope.createSubScope)(scope, args), scope); // "raw" evaluation
+          } else {
+            var values = evalArgs.map(function (evalArg) {
+              return evalArg(scope, args, context);
+            });
+            return fn.apply(fn, values);
+          }
+        };
       }
     } else if ((0, _is.isAccessorNode)(this.fn) && (0, _is.isIndexNode)(this.fn.index) && this.fn.index.isObjectProperty()) {
       // execute the function with the right context: the object of the AccessorNode
       var evalObject = this.fn.object._compile(math, argNames);
 
       var prop = this.fn.index.getObjectProperty();
-      var _rawArgs = this.args;
+      var _rawArgs2 = this.args;
       return function evalFunctionNode(scope, args, context) {
         var object = evalObject(scope, args, context);
         (0, _customs.validateSafeMethod)(object, prop);
         var isRaw = object[prop] && object[prop].rawArgs;
 
         if (isRaw) {
-          return object[prop](_rawArgs, math, (0, _scope.createSubScope)(scope, args), scope); // "raw" evaluation
+          return object[prop](_rawArgs2, math, (0, _scope.createSubScope)(scope, args), scope); // "raw" evaluation
         } else {
           // "regular" evaluation
           var values = evalArgs.map(function (evalArg) {
@@ -182,13 +201,13 @@ var createFunctionNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies
       // we have to dynamically determine whether the function has a rawArgs property
       var evalFn = this.fn._compile(math, argNames);
 
-      var _rawArgs2 = this.args;
+      var _rawArgs3 = this.args;
       return function evalFunctionNode(scope, args, context) {
         var fn = evalFn(scope, args, context);
         var isRaw = fn && fn.rawArgs;
 
         if (isRaw) {
-          return fn(_rawArgs2, math, (0, _scope.createSubScope)(scope, args), scope); // "raw" evaluation
+          return fn(_rawArgs3, math, (0, _scope.createSubScope)(scope, args), scope); // "raw" evaluation
         } else {
           // "regular" evaluation
           var values = evalArgs.map(function (evalArg) {

package/lib/cjs/expression/parse.js

@@ -253,18 +253,22 @@ var createParse = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
   function getToken(state) {
     state.tokenType = TOKENTYPE.NULL;
     state.token = '';
-    state.comment = ''; // skip over whitespaces
-    // space, tab, and newline when inside parameters
+    state.comment = ''; // skip over ignored characters:
 
-    while (parse.isWhitespace(currentCharacter(state), state.nestingLevel)) {
-      next(state);
-    } // skip comment
+    while (true) {
+      // comments:
+      if (currentCharacter(state) === '#') {
+        while (currentCharacter(state) !== '\n' && currentCharacter(state) !== '') {
+          state.comment += currentCharacter(state);
+          next(state);
+        }
+      } // whitespace: space, tab, and newline when inside parameters
 
 
-    if (currentCharacter(state) === '#') {
-      while (currentCharacter(state) !== '\n' && currentCharacter(state) !== '') {
-        state.comment += currentCharacter(state);
+      if (parse.isWhitespace(currentCharacter(state), state.nestingLevel)) {
         next(state);
+      } else {
+        break;
       }
     } // check for end of expression
 

package/lib/cjs/expression/transform/cumsum.transform.js

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createCumSumTransform = void 0;
+
+var _is = require("../../utils/is.js");
+
+var _factory = require("../../utils/factory.js");
+
+var _errorTransform = require("./utils/errorTransform.js");
+
+var _cumsum = require("../../function/statistics/cumsum.js");
+
+/**
+ * Attach a transform function to math.sum
+ * Adds a property transform containing the transform function.
+ *
+ * This transform changed the last `dim` parameter of function sum
+ * from one-based to zero based
+ */
+var name = 'cumsum';
+var dependencies = ['typed', 'add', 'unaryPlus'];
+var createCumSumTransform = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+      add = _ref.add,
+      unaryPlus = _ref.unaryPlus;
+  var cumsum = (0, _cumsum.createCumSum)({
+    typed: typed,
+    add: add,
+    unaryPlus: unaryPlus
+  });
+  return typed(name, {
+    '...any': function any(args) {
+      // change last argument dim from one-based to zero-based
+      if (args.length === 2 && (0, _is.isCollection)(args[0])) {
+        var dim = args[1];
+
+        if ((0, _is.isNumber)(dim)) {
+          args[1] = dim - 1;
+        } else if ((0, _is.isBigNumber)(dim)) {
+          args[1] = dim.minus(1);
+        }
+      }
+
+      try {
+        return cumsum.apply(null, args);
+      } catch (err) {
+        throw (0, _errorTransform.errorTransform)(err);
+      }
+    }
+  });
+}, {
+  isTransformFunction: true
+});
+exports.createCumSumTransform = createCumSumTransform;

package/lib/cjs/expression/transform/sum.transform.js

@@ -17,7 +17,7 @@ var _lastDimToZeroBase = require("./utils/lastDimToZeroBase.js");
  * Attach a transform function to math.sum
  * Adds a property transform containing the transform function.
  *
- * This transform changed the last `dim` parameter of function mean
+ * This transform changed the last `dim` parameter of function sum
  * from one-based to zero based
  */
 var name = 'sum';

package/lib/cjs/factoriesAny.js

@@ -447,6 +447,18 @@ Object.defineProperty(exports, "createCube", {
     return _cube.createCube;
   }
 });
+Object.defineProperty(exports, "createCumSum", {
+  enumerable: true,
+  get: function get() {
+    return _cumsum.createCumSum;
+  }
+});
+Object.defineProperty(exports, "createCumSumTransform", {
+  enumerable: true,
+  get: function get() {
+    return _cumsumTransform.createCumSumTransform;
+  }
+});
 Object.defineProperty(exports, "createDeepEqual", {
   enumerable: true,
   get: function get() {
@@ -1857,6 +1869,12 @@ Object.defineProperty(exports, "createSymbolNode", {
     return _SymbolNode.createSymbolNode;
   }
 });
+Object.defineProperty(exports, "createSymbolicEqual", {
+  enumerable: true,
+  get: function get() {
+    return _symbolicEqual.createSymbolicEqual;
+  }
+});
 Object.defineProperty(exports, "createTan", {
   enumerable: true,
   get: function get() {
@@ -2472,6 +2490,8 @@ var _intersect = require("./function/geometry/intersect.js");
 
 var _sum = require("./function/statistics/sum.js");
 
+var _cumsum = require("./function/statistics/cumsum.js");
+
 var _mean = require("./function/statistics/mean.js");
 
 var _median = require("./function/statistics/median.js");
@@ -2520,6 +2540,8 @@ var _simplifyCore = require("./function/algebra/simplifyCore.js");
 
 var _resolve = require("./function/algebra/resolve.js");
 
+var _symbolicEqual = require("./function/algebra/symbolicEqual.js");
+
 var _derivative = require("./function/algebra/derivative.js");
 
 var _rationalize = require("./function/algebra/rationalize.js");
@@ -2564,4 +2586,6 @@ var _stdTransform = require("./expression/transform/std.transform.js");
 
 var _sumTransform = require("./expression/transform/sum.transform.js");
 
+var _cumsumTransform = require("./expression/transform/cumsum.transform.js");
+
 var _varianceTransform = require("./expression/transform/variance.transform.js");

package/lib/cjs/factoriesNumber.js

@@ -131,6 +131,18 @@ Object.defineProperty(exports, "createConstantNode", {
   }
 });
 exports.createCube = exports.createCsch = exports.createCsc = exports.createCoth = exports.createCot = exports.createCosh = exports.createCos = void 0;
+Object.defineProperty(exports, "createCumSum", {
+  enumerable: true,
+  get: function get() {
+    return _cumsum.createCumSum;
+  }
+});
+Object.defineProperty(exports, "createCumSumTransform", {
+  enumerable: true,
+  get: function get() {
+    return _cumsumTransform.createCumSumTransform;
+  }
+});
 Object.defineProperty(exports, "createDeepEqual", {
   enumerable: true,
   get: function get() {
@@ -325,8 +337,8 @@ Object.defineProperty(exports, "createLargerEq", {
     return _largerEq.createLargerEqNumber;
   }
 });
-exports.createLog10 = exports.createLog = exports.createLeftShift = exports.createLcm = void 0;
-exports.createLog2 = exports.createLog1p = exports.createLog10 = exports.createLog = exports.createLeftShift = exports.createLcm = void 0;
+exports.createLeftShift = exports.createLcm = void 0;
+exports.createLog2 = exports.createLog1p = exports.createLog10 = exports.createLog = void 0;
 Object.defineProperty(exports, "createMad", {
   enumerable: true,
   get: function get() {
@@ -914,6 +926,8 @@ var _min = require("./function/statistics/min.js");
 
 var _sum = require("./function/statistics/sum.js");
 
+var _cumsum = require("./function/statistics/cumsum.js");
+
 var _mean = require("./function/statistics/mean.js");
 
 var _median = require("./function/statistics/median.js");
@@ -950,6 +964,8 @@ var _stdTransform = require("./expression/transform/std.transform.js");
 
 var _sumTransform = require("./expression/transform/sum.transform.js");
 
+var _cumsumTransform = require("./expression/transform/cumsum.transform.js");
+
 var _varianceTransform = require("./expression/transform/variance.transform.js");
 
 var _clone = require("./function/utils/clone.js");

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

@@ -343,6 +343,14 @@ var createSimplify = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
         total: true
       }
     }
+  }, {
+    s: 'n-n -> 0',
+    // partial alternative when we can't always subtract
+    assuming: {
+      subtract: {
+        total: false
+      }
+    }
   }, {
     s: '-(c*v) -> v * (-c)',
     // make non-constant terms positive

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

@@ -215,9 +215,9 @@ var createSimplifyCore = /* #__PURE__ */(0, _factory.factory)(name, dependencies
             }
           }
         }
-
-        return new OperatorNode(node.op, node.fn, [_a, a1]);
       }
+
+      return new OperatorNode(node.op, node.fn, [_a, a1]);
     } else if ((0, _is.isFunctionNode)(node)) {
       return new FunctionNode(simplifyCore(node.fn), node.args.map(function (n) {
         return simplifyCore(n, options);

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

@@ -0,0 +1,88 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createSymbolicEqual = void 0;
+
+var _is = require("../../utils/is.js");
+
+var _factory = require("../../utils/factory.js");
+
+var name = 'symbolicEqual';
+var dependencies = ['parse', 'simplify', 'typed', 'OperatorNode'];
+var createSymbolicEqual = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var parse = _ref.parse,
+      simplify = _ref.simplify,
+      typed = _ref.typed,
+      OperatorNode = _ref.OperatorNode;
+
+  /**
+   * Attempts to determine if two expressions are symbolically equal, i.e.
+   * one is the result of valid algebraic manipulations on the other.
+   * Currently, this simply checks if the difference of the two expressions
+   * simplifies down to 0. So there are two important caveats:
+   * 1. whether two expressions are symbolically equal depends on the
+   *     manipulations allowed. Therefore, this function takes an optional
+   *     third argument, which are the options that control the behavior
+   *     as documented for the `simplify()` function.
+   * 2. it is in general intractable to find the minimal simplification of
+   *     an arbitrarily complicated expression. So while a `true` value
+   *     of `symbolicEqual` ensures that the two expressions can be manipulated
+   *     to match each other, a `false` value does not absolutely rule this out.
+   *
+   * Syntax:
+   *
+   *    symbolicEqual(expr1, expr2)
+   *    symbolicEqual(expr1, expr2, options)
+   *
+   * Examples:
+   *
+   *    symbolicEqual('x*y', 'y*x') // true
+   *    symbolicEqual('x*y', 'y*x', {context: {multiply: {commutative: false}}})
+   *        //false
+   *    symbolicEqual('x/y', '(y*x^(-1))^(-1)') // true
+   *    symbolicEqual('abs(x)','x') // false
+   *    symbolicEqual('abs(x)','x', simplify.positiveContext) // true
+   *
+   * See also:
+   *
+   *    simplify, evaluate
+   *
+   * @param {Node|string} expr1  The first expression to compare
+   * @param {Node|string} expr2  The second expression to compare
+   * @param {Object} [options] Optional option object, passed to simplify
+   * @returns {boolean}
+   *     Returns true if a valid manipulation making the expressions equal
+   *     is found.
+   */
+  return typed(name, {
+    'string, string': function stringString(s1, s2) {
+      return this(parse(s1), parse(s2), {});
+    },
+    'string, string, Object': function stringStringObject(s1, s2, options) {
+      return this(parse(s1), parse(s2), options);
+    },
+    'Node, string': function NodeString(e1, s2) {
+      return this(e1, parse(s2), {});
+    },
+    'Node, string, Object': function NodeStringObject(e1, s2, options) {
+      return this(e1, parse(s2), options);
+    },
+    'string, Node': function stringNode(s1, e2) {
+      return this(parse(s1), e2, {});
+    },
+    'string, Node, Object': function stringNodeObject(s1, e2, options) {
+      return this(parse(s1), e2, options);
+    },
+    'Node, Node': function NodeNode(e1, e2) {
+      return this(e1, e2, {});
+    },
+    'Node, Node, Object': function NodeNodeObject(e1, e2, options) {
+      var diff = new OperatorNode('-', 'subtract', [e1, e2]);
+      var simplified = simplify(diff, {}, options);
+      return (0, _is.isConstantNode)(simplified) && !simplified.value;
+    }
+  });
+});
+exports.createSymbolicEqual = createSymbolicEqual;