mathjs 10.1.1 → 10.4.0

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

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.leafCountDocs = void 0;
+var leafCountDocs = {
+  name: 'leafCount',
+  category: 'Algebra',
+  syntax: ['leafCount(expr)'],
+  description: 'Computes the number of leaves in the parse tree of the given expression',
+  examples: ['leafCount("e^(i*pi)-1")', 'leafCount(parse("{a: 22/7, b: 10^(1/2)}"))'],
+  seealso: ['simplify']
+};
+exports.leafCountDocs = leafCountDocs;

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

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.resolveDocs = void 0;
+var resolveDocs = {
+  name: 'resolve',
+  category: 'Algebra',
+  syntax: ['resolve(node, scope)'],
+  description: 'Recursively substitute variables in an expression tree.',
+  examples: ['resolve(parse("1 + x"), { x: 7 })', 'resolve(parse("size(text)"), { text: "Hello World" })', 'resolve(parse("x + y"), { x: parse("3z") })', 'resolve(parse("3x"), { x: parse("y+z"), z: parse("w^y") })'],
+  seealso: ['simplify', 'evaluate'],
+  mayThrow: ['ReferenceError']
+};
+exports.resolveDocs = resolveDocs;

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

@@ -10,6 +10,6 @@ var simplifyDocs = {
   syntax: ['simplify(expr)', 'simplify(expr, rules)'],
   description: 'Simplify an expression tree.',
   examples: ['simplify("3 + 2 / 4")', 'simplify("2x + x")', 'f = parse("x * (x + 2 + x)")', 'simplified = simplify(f)', 'simplified.evaluate({x: 2})'],
-  seealso: ['derivative', 'parse', 'evaluate']
+  seealso: ['simplifyCore', 'derivative', 'evaluate', 'parse', 'rationalize', 'resolve']
 };
 exports.simplifyDocs = simplifyDocs;

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

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.simplifyCoreDocs = void 0;
+var simplifyCoreDocs = {
+  name: 'simplifyCore',
+  category: 'Algebra',
+  syntax: ['simplifyCore(node)'],
+  description: 'Perform simple one-pass simplifications on an expression tree.',
+  examples: ['simplifyCore(parse("0*x"))', 'simplifyCore(parse("(x+0)*2"))'],
+  seealso: ['simplify', 'evaluate']
+};
+exports.simplifyCoreDocs = simplifyCoreDocs;

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) {
@@ -270,7 +289,7 @@ var createFunctionNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies
     var customString;
     var name = this.fn.toString(options);
 
-    if (options && (0, _typeof2["default"])(options.handler) === 'object' && (0, _object.hasOwnProperty)(options.handler, name)) {
+    if (options && (0, _typeof2.default)(options.handler) === 'object' && (0, _object.hasOwnProperty)(options.handler, name)) {
       // callback is a map of callback functions
       customString = options.handler[name](this, options);
     }
@@ -376,7 +395,7 @@ var createFunctionNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies
 
         if (match[2] === undefined) {
           // no square brackets
-          switch ((0, _typeof2["default"])(property)) {
+          switch ((0, _typeof2.default)(property)) {
             case 'string':
               latex += property;
               break;
@@ -436,7 +455,7 @@ var createFunctionNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies
   FunctionNode.prototype.toTex = function (options) {
     var customTex;
 
-    if (options && (0, _typeof2["default"])(options.handler) === 'object' && (0, _object.hasOwnProperty)(options.handler, this.name)) {
+    if (options && (0, _typeof2.default)(options.handler) === 'object' && (0, _object.hasOwnProperty)(options.handler, this.name)) {
       // callback is a map of callback functions
       customTex = options.handler[this.name](this, options);
     }
@@ -467,14 +486,14 @@ var createFunctionNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies
     } // toTex property on the function itself
 
 
-    if (math[this.name] && (typeof math[this.name].toTex === 'function' || (0, _typeof2["default"])(math[this.name].toTex) === 'object' || typeof math[this.name].toTex === 'string')) {
+    if (math[this.name] && (typeof math[this.name].toTex === 'function' || (0, _typeof2.default)(math[this.name].toTex) === 'object' || typeof math[this.name].toTex === 'string')) {
       // .toTex is a callback function
       latexConverter = math[this.name].toTex;
     }
 
     var customToTex;
 
-    switch ((0, _typeof2["default"])(latexConverter)) {
+    switch ((0, _typeof2.default)(latexConverter)) {
       case 'function':
         // a callback function
         customToTex = latexConverter(this, options);
@@ -487,7 +506,7 @@ var createFunctionNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies
 
       case 'object':
         // an object with different "converters" for different numbers of arguments
-        switch ((0, _typeof2["default"])(latexConverter[args.length])) {
+        switch ((0, _typeof2.default)(latexConverter[args.length])) {
           case 'function':
             customToTex = latexConverter[args.length](this, options);
             break;

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

@@ -143,7 +143,7 @@ var createIndexNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
       var dimensions = (0, _array.map)(evalDimensions, function (evalDimension) {
         return evalDimension(scope, args, context);
       });
-      return index.apply(void 0, (0, _toConsumableArray2["default"])(dimensions));
+      return index.apply(void 0, (0, _toConsumableArray2.default)(dimensions));
     };
   };
   /**

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

@@ -367,8 +367,8 @@ var createNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functi
 
 
   Node.prototype._getCustomString = function (options) {
-    if (options && (0, _typeof2["default"])(options) === 'object') {
-      switch ((0, _typeof2["default"])(options.handler)) {
+    if (options && (0, _typeof2.default)(options) === 'object') {
+      switch ((0, _typeof2.default)(options.handler)) {
         case 'object':
         case 'undefined':
           return;
@@ -407,7 +407,7 @@ var createNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functi
 
 
   function _validateScope(scope) {
-    for (var _i = 0, _arr = (0, _toConsumableArray2["default"])(_keywords.keywords); _i < _arr.length; _i++) {
+    for (var _i = 0, _arr = (0, _toConsumableArray2.default)(_keywords.keywords); _i < _arr.length; _i++) {
       var symbol = _arr[_i];
 
       if (scope.has(symbol)) {

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

@@ -38,7 +38,7 @@ var createObjectNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies,
     this.properties = properties || {}; // validate input
 
     if (properties) {
-      if (!((0, _typeof2["default"])(properties) === 'object') || !Object.keys(properties).every(function (key) {
+      if (!((0, _typeof2.default)(properties) === 'object') || !Object.keys(properties).every(function (key) {
         return (0, _is.isNode)(properties[key]);
       })) {
         throw new TypeError('Object containing Nodes expected');

package/lib/cjs/expression/node/utils/access.js

@@ -37,7 +37,7 @@ function accessFactory(_ref) {
       } else if (typeof object === 'string') {
         // TODO: move getStringSubset into a separate util file, use that
         return subset(object, index);
-      } else if ((0, _typeof2["default"])(object) === 'object') {
+      } else if ((0, _typeof2.default)(object) === 'object') {
         if (!index.isObjectProperty()) {
           throw new TypeError('Cannot apply a numeric index as object property');
         }

package/lib/cjs/expression/node/utils/assign.js

@@ -42,7 +42,7 @@ function assignFactory(_ref) {
       } else if (typeof object === 'string') {
         // TODO: move setStringSubset into a separate util file, use that
         return subset(object, index, value);
-      } else if ((0, _typeof2["default"])(object) === 'object') {
+      } else if ((0, _typeof2.default)(object) === 'object') {
         if (!index.isObjectProperty()) {
           throw TypeError('Cannot apply a numeric index as object property');
         }

package/lib/cjs/expression/parse.js

@@ -153,16 +153,16 @@ var createParse = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
   var NAMED_DELIMITERS = {
     mod: true,
     to: true,
-    "in": true,
+    in: true,
     and: true,
     xor: true,
     or: true,
     not: true
   };
   var CONSTANTS = {
-    "true": true,
-    "false": false,
-    "null": null,
+    true: true,
+    false: false,
+    null: null,
     undefined: undefined
   };
   var NUMERIC_CONSTANTS = ['NaN', 'Infinity'];
@@ -584,7 +584,7 @@ var createParse = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
 
   function parseStart(expression, extraNodes) {
     var state = initialState();
-    (0, _extends2["default"])(state, {
+    (0, _extends2.default)(state, {
       expression: expression,
       extraNodes: extraNodes
     });
@@ -930,7 +930,7 @@ var createParse = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
     node = parseRange(state);
     var operators = {
       to: 'to',
-      "in": 'to' // alias of 'to'
+      in: 'to' // alias of 'to'
 
     };
 
@@ -1112,30 +1112,30 @@ var createParse = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
       // Match the "number /" part of the pattern "number / number symbol"
       if (state.token === '/' && (0, _is.isConstantNode)(last)) {
         // Look ahead to see if the next token is a number
-        tokenStates.push((0, _extends2["default"])({}, state));
+        tokenStates.push((0, _extends2.default)({}, state));
         getTokenSkipNewline(state); // Match the "number / number" part of the pattern
 
         if (state.tokenType === TOKENTYPE.NUMBER) {
           // Look ahead again
-          tokenStates.push((0, _extends2["default"])({}, state));
+          tokenStates.push((0, _extends2.default)({}, state));
           getTokenSkipNewline(state); // Match the "symbol" part of the pattern, or a left parenthesis
 
           if (state.tokenType === TOKENTYPE.SYMBOL || state.token === '(') {
             // We've matched the pattern "number / number symbol".
             // Rewind once and build the "number / number" node; the symbol will be consumed later
-            (0, _extends2["default"])(state, tokenStates.pop());
+            (0, _extends2.default)(state, tokenStates.pop());
             tokenStates.pop();
             last = parsePercentage(state);
             node = new OperatorNode('/', 'divide', [node, last]);
           } else {
             // Not a match, so rewind
             tokenStates.pop();
-            (0, _extends2["default"])(state, tokenStates.pop());
+            (0, _extends2.default)(state, tokenStates.pop());
             break;
           }
         } else {
           // Not a match, so rewind
-          (0, _extends2["default"])(state, tokenStates.pop());
+          (0, _extends2.default)(state, tokenStates.pop());
           break;
         }
       } else {
@@ -1783,7 +1783,7 @@ var createParse = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
   function createSyntaxError(state, message) {
     var c = col(state);
     var error = new SyntaxError(message + ' (char ' + c + ')');
-    error["char"] = c;
+    error.char = c;
     return error;
   }
   /**
@@ -1798,7 +1798,7 @@ var createParse = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
   function createError(state, message) {
     var c = col(state);
     var error = new SyntaxError(message + ' (char ' + c + ')');
-    error["char"] = c;
+    error.char = c;
     return error;
   }
 

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() {
@@ -987,6 +999,12 @@ Object.defineProperty(exports, "createLcm", {
     return _lcm.createLcm;
   }
 });
+Object.defineProperty(exports, "createLeafCount", {
+  enumerable: true,
+  get: function get() {
+    return _leafCount.createLeafCount;
+  }
+});
 Object.defineProperty(exports, "createLeftShift", {
   enumerable: true,
   get: function get() {
@@ -1509,6 +1527,12 @@ Object.defineProperty(exports, "createResize", {
     return _resize.createResize;
   }
 });
+Object.defineProperty(exports, "createResolve", {
+  enumerable: true,
+  get: function get() {
+    return _resolve.createResolve;
+  }
+});
 Object.defineProperty(exports, "createResultSet", {
   enumerable: true,
   get: function get() {
@@ -1677,6 +1701,12 @@ Object.defineProperty(exports, "createSimplify", {
     return _simplify.createSimplify;
   }
 });
+Object.defineProperty(exports, "createSimplifyCore", {
+  enumerable: true,
+  get: function get() {
+    return _simplifyCore.createSimplifyCore;
+  }
+});
 Object.defineProperty(exports, "createSin", {
   enumerable: true,
   get: function get() {
@@ -1839,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() {
@@ -2454,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");
@@ -2494,8 +2532,16 @@ var _catalan = require("./function/combinatorics/catalan.js");
 
 var _composition = require("./function/combinatorics/composition.js");
 
+var _leafCount = require("./function/algebra/leafCount.js");
+
 var _simplify = require("./function/algebra/simplify.js");
 
+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");
@@ -2540,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");