mathjs 10.0.0 → 10.6.4

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

@@ -2,7 +2,7 @@ export 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']
 };

package/lib/esm/expression/embeddedDocs/function/probability/lgamma.js

@@ -0,0 +1,8 @@
+export var lgammaDocs = {
+  name: 'lgamma',
+  category: 'Probability',
+  syntax: ['lgamma(n)'],
+  description: 'Logarithm of the gamma function for real, positive numbers and complex numbers, ' + 'using Lanczos approximation for numbers and Stirling series for complex numbers.',
+  examples: ['lgamma(4)', 'lgamma(1/2)', 'lgamma(math.i)', 'lgamma(complex(1.1, 2))'],
+  seealso: ['gamma']
+};

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

@@ -0,0 +1,8 @@
+export 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']
+};

package/lib/esm/expression/node/BlockNode.js

@@ -31,8 +31,8 @@ export var createBlockNode = /* #__PURE__ */factory(name, dependencies, _ref =>
       if (!isNode(node)) throw new TypeError('Property "node" must be a Node');
       if (typeof visible !== 'boolean') throw new TypeError('Property "visible" must be a boolean');
       return {
-        node: node,
-        visible: visible
+        node,
+        visible
       };
     });
   }
@@ -101,7 +101,7 @@ export var createBlockNode = /* #__PURE__ */factory(name, dependencies, _ref =>
       var node = this._ifNode(callback(block.node, 'blocks[' + i + '].node', this));
 
       blocks[i] = {
-        node: node,
+        node,
         visible: block.visible
       };
     }

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

@@ -1,5 +1,5 @@
 import { isAccessorNode, isFunctionAssignmentNode, isIndexNode, isNode, isSymbolNode } from '../../utils/is.js';
-import { escape } from '../../utils/string.js';
+import { escape, format } from '../../utils/string.js';
 import { hasOwnProperty } from '../../utils/object.js';
 import { getSafeProperty, validateSafeMethod } from '../../utils/customs.js';
 import { createSubScope } from '../../utils/scope.js';
@@ -54,6 +54,11 @@ export var createFunctionNode = /* #__PURE__ */factory(name, dependencies, _ref
   FunctionNode.prototype = new Node();
   FunctionNode.prototype.type = 'FunctionNode';
   FunctionNode.prototype.isFunctionNode = true;
+  /* format to fixed length */
+
+  var strin = entity => format(entity, {
+    truncate: 78
+  });
   /**
    * Compile a node into a JavaScript function.
    * This basically pre-calculates as much as possible and only leaves open
@@ -68,6 +73,7 @@ export var createFunctionNode = /* #__PURE__ */factory(name, dependencies, _ref
    *                        evalNode(scope: Object, args: Object, context: *)
    */
 
+
   FunctionNode.prototype._compile = function (math, argNames) {
     if (!(this instanceof FunctionNode)) {
       throw new TypeError('No valid FunctionNode');
@@ -77,76 +83,102 @@ export var createFunctionNode = /* #__PURE__ */factory(name, dependencies, _ref
     var evalArgs = this.args.map(arg => arg._compile(math, argNames));
 
     if (isSymbolNode(this.fn)) {
-      // we can statically determine whether the function has an rawArgs property
       var _name = this.fn.name;
-      var fn = _name in math ? getSafeProperty(math, _name) : undefined;
-      var isRaw = typeof fn === 'function' && fn.rawArgs === true;
 
-      var 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 ? getSafeProperty(math, _name) : undefined;
+        var isRaw = typeof fn === 'function' && fn.rawArgs === true;
 
-        if (_name in math) {
-          return getSafeProperty(math, _name);
-        }
+        var resolveFn = scope => {
+          var value;
 
-        return FunctionNode.onUndefinedFunction(_name);
-      };
+          if (scope.has(_name)) {
+            value = scope.get(_name);
+          } else if (_name in math) {
+            value = getSafeProperty(math, _name);
+          } else {
+            return FunctionNode.onUndefinedFunction(_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, createSubScope(scope, args), scope);
+          if (typeof value === 'function') {
+            return value;
+          }
+
+          throw new TypeError("'".concat(_name, "' is not a function; its value is:\n  ").concat(strin(value)));
         };
-      } 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(evalArg => evalArg(scope, args, context));
-              return fn(...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, 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(evalArg => evalArg(scope, args, context));
+                return fn(...values);
+              };
+          }
         }
+      } else {
+        // the function symbol is an argName
+        var _rawArgs = this.args;
+        return function evalFunctionNode(scope, args, context) {
+          var fn = args[_name];
+
+          if (typeof fn !== 'function') {
+            throw new TypeError("Argument '".concat(_name, "' was not a function; received: ").concat(strin(fn)));
+          }
+
+          if (fn.rawArgs) {
+            return fn(_rawArgs, math, createSubScope(scope, args), scope); // "raw" evaluation
+          } else {
+            var values = evalArgs.map(evalArg => evalArg(scope, args, context));
+            return fn.apply(fn, values);
+          }
+        };
       }
     } else if (isAccessorNode(this.fn) && 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);
         validateSafeMethod(object, prop);
         var isRaw = object[prop] && object[prop].rawArgs;
 
         if (isRaw) {
-          return object[prop](_rawArgs, math, createSubScope(scope, args), scope); // "raw" evaluation
+          return object[prop](_rawArgs2, math, createSubScope(scope, args), scope); // "raw" evaluation
         } else {
           // "regular" evaluation
           var values = evalArgs.map(evalArg => evalArg(scope, args, context));
@@ -156,15 +188,20 @@ export var createFunctionNode = /* #__PURE__ */factory(name, dependencies, _ref
     } else {
       // node.fn.isAccessorNode && !node.fn.index.isObjectProperty()
       // we have to dynamically determine whether the function has a rawArgs property
+      var fnExpr = this.fn.toString();
+
       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, createSubScope(scope, args), scope); // "raw" evaluation
+        if (typeof fn !== 'function') {
+          throw new TypeError("Expression '".concat(fnExpr, "' did not evaluate to a function; value is:") + "\n  ".concat(strin(fn)));
+        }
+
+        if (fn.rawArgs) {
+          return fn(_rawArgs3, math, createSubScope(scope, args), scope); // "raw" evaluation
         } else {
           // "regular" evaluation
           var values = evalArgs.map(evalArg => evalArg(scope, args, context));

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

@@ -1,13 +1,12 @@
-import { isBigNumber, isConstantNode, isNode, isRangeNode, isSymbolNode } from '../../utils/is.js';
 import { map } from '../../utils/array.js';
-import { escape } from '../../utils/string.js';
-import { factory } from '../../utils/factory.js';
 import { getSafeProperty } from '../../utils/customs.js';
+import { factory } from '../../utils/factory.js';
+import { isArray, isConstantNode, isMatrix, isNode, isString, typeOf } from '../../utils/is.js';
+import { escape } from '../../utils/string.js';
 var name = 'IndexNode';
-var dependencies = ['Range', 'Node', 'size'];
+var dependencies = ['Node', 'size'];
 export var createIndexNode = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
-    Range,
     Node,
     size
   } = _ref;
@@ -67,61 +66,30 @@ export var createIndexNode = /* #__PURE__ */factory(name, dependencies, _ref =>
     // TODO: Optimization: when the range values are ConstantNodes,
     //       we can beforehand resolve the zero-based value
     // optimization for a simple object property
-    var evalDimensions = map(this.dimensions, function (range, i) {
-      if (isRangeNode(range)) {
-        if (range.needsEnd()) {
-          // create a range containing end (like '4:end')
-          var childArgNames = Object.create(argNames);
-          childArgNames.end = true;
-
-          var evalStart = range.start._compile(math, childArgNames);
-
-          var evalEnd = range.end._compile(math, childArgNames);
-
-          var evalStep = range.step ? range.step._compile(math, childArgNames) : function () {
-            return 1;
-          };
-          return function evalDimension(scope, args, context) {
-            var s = size(context).valueOf();
-            var childArgs = Object.create(args);
-            childArgs.end = s[i];
-            return createRange(evalStart(scope, childArgs, context), evalEnd(scope, childArgs, context), evalStep(scope, childArgs, context));
-          };
-        } else {
-          // create range
-          var _evalStart = range.start._compile(math, argNames);
-
-          var _evalEnd = range.end._compile(math, argNames);
-
-          var _evalStep = range.step ? range.step._compile(math, argNames) : function () {
-            return 1;
-          };
-
-          return function evalDimension(scope, args, context) {
-            return createRange(_evalStart(scope, args, context), _evalEnd(scope, args, context), _evalStep(scope, args, context));
-          };
-        }
-      } else if (isSymbolNode(range) && range.name === 'end') {
-        // SymbolNode 'end'
-        var _childArgNames = Object.create(argNames);
-
-        _childArgNames.end = true;
-
-        var evalRange = range._compile(math, _childArgNames);
+    var evalDimensions = map(this.dimensions, function (dimension, i) {
+      var needsEnd = dimension.filter(node => node.isSymbolNode && node.name === 'end').length > 0;
+
+      if (needsEnd) {
+        // SymbolNode 'end' is used inside the index,
+        // like in `A[end]` or `A[end - 2]`
+        var childArgNames = Object.create(argNames);
+        childArgNames.end = true;
+
+        var _evalDimension = dimension._compile(math, childArgNames);
 
         return function evalDimension(scope, args, context) {
+          if (!isMatrix(context) && !isArray(context) && !isString(context)) {
+            throw new TypeError('Cannot resolve "end": ' + 'context must be a Matrix, Array, or string but is ' + typeOf(context));
+          }
+
           var s = size(context).valueOf();
           var childArgs = Object.create(args);
           childArgs.end = s[i];
-          return evalRange(scope, childArgs, context);
+          return _evalDimension(scope, childArgs, context);
         };
       } else {
-        // ConstantNode
-        var _evalRange = range._compile(math, argNames);
-
-        return function evalDimension(scope, args, context) {
-          return _evalRange(scope, args, context);
-        };
+        // SymbolNode `end` not used
+        return dimension._compile(math, argNames);
       }
     });
     var index = getSafeProperty(math, 'index');
@@ -257,12 +225,7 @@ export var createIndexNode = /* #__PURE__ */factory(name, dependencies, _ref =>
       return range.toTex(options);
     });
     return this.dotNotation ? '.' + this.getObjectProperty() + '' : '_{' + dimensions.join(',') + '}';
-  }; // helper function to create a Range from start, step and end
-
-
-  function createRange(start, end, step) {
-    return new Range(isBigNumber(start) ? start.toNumber() : start, isBigNumber(end) ? end.toNumber() : end, isBigNumber(step) ? step.toNumber() : step);
-  }
+  };
 
   return IndexNode;
 }, {

package/lib/esm/expression/parse.js

@@ -151,7 +151,7 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
     true: true,
     false: false,
     null: null,
-    undefined: undefined
+    undefined
   };
   var NUMERIC_CONSTANTS = ['NaN', 'Infinity'];
 
@@ -241,18 +241,22 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
   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
 
@@ -619,8 +623,8 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
       if (blocks.length === 0 && node) {
         visible = state.token !== ';';
         blocks.push({
-          node: node,
-          visible: visible
+          node,
+          visible
         });
       }
 
@@ -631,8 +635,8 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
         node.comment = state.comment;
         visible = state.token !== ';';
         blocks.push({
-          node: node,
-          visible: visible
+          node,
+          visible
         });
       }
     }

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

@@ -0,0 +1,48 @@
+import { isBigNumber, isCollection, isNumber } from '../../utils/is.js';
+import { factory } from '../../utils/factory.js';
+import { errorTransform } from './utils/errorTransform.js';
+import { createCumSum } from '../../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'];
+export var createCumSumTransform = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    add,
+    unaryPlus
+  } = _ref;
+  var cumsum = createCumSum({
+    typed,
+    add,
+    unaryPlus
+  });
+  return typed(name, {
+    '...any': function any(args) {
+      // change last argument dim from one-based to zero-based
+      if (args.length === 2 && isCollection(args[0])) {
+        var dim = args[1];
+
+        if (isNumber(dim)) {
+          args[1] = dim - 1;
+        } else if (isBigNumber(dim)) {
+          args[1] = dim.minus(1);
+        }
+      }
+
+      try {
+        return cumsum.apply(null, args);
+      } catch (err) {
+        throw errorTransform(err);
+      }
+    }
+  });
+}, {
+  isTransformFunction: true
+});

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

@@ -6,7 +6,7 @@ import { lastDimToZeroBase } from './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
  */
 

package/lib/esm/factoriesAny.js

@@ -53,6 +53,7 @@ export { createSqrt } from './function/arithmetic/sqrt.js';
 export { createSquare } from './function/arithmetic/square.js';
 export { createSubtract } from './function/arithmetic/subtract.js';
 export { createXgcd } from './function/arithmetic/xgcd.js';
+export { createInvmod } from './function/arithmetic/invmod.js';
 export { createDotMultiply } from './function/arithmetic/dotMultiply.js';
 export { createBitAnd } from './function/bitwise/bitAnd.js';
 export { createBitNot } from './function/bitwise/bitNot.js';
@@ -91,6 +92,8 @@ export { createSubset } from './function/matrix/subset.js';
 export { createTranspose } from './function/matrix/transpose.js';
 export { createCtranspose } from './function/matrix/ctranspose.js';
 export { createZeros } from './function/matrix/zeros.js';
+export { createFft } from './function/matrix/fft.js';
+export { createIfft } from './function/matrix/ifft.js';
 export { createErf } from './function/special/erf.js';
 export { createMode } from './function/statistics/mode.js';
 export { createProd } from './function/statistics/prod.js';
@@ -213,6 +216,7 @@ export { createHelp } from './expression/function/help.js';
 export { createChain } from './type/chain/function/chain.js';
 export { createDet } from './function/matrix/det.js';
 export { createInv } from './function/matrix/inv.js';
+export { createPinv } from './function/matrix/pinv.js';
 export { createEigs } from './function/matrix/eigs.js';
 export { createExpm } from './function/matrix/expm.js';
 export { createSqrtm } from './function/matrix/sqrtm.js';
@@ -220,6 +224,7 @@ export { createDivide } from './function/arithmetic/divide.js';
 export { createDistance } from './function/geometry/distance.js';
 export { createIntersect } from './function/geometry/intersect.js';
 export { createSum } from './function/statistics/sum.js';
+export { createCumSum } from './function/statistics/cumsum.js';
 export { createMean } from './function/statistics/mean.js';
 export { createMedian } from './function/statistics/median.js';
 export { createMad } from './function/statistics/mad.js';
@@ -229,6 +234,7 @@ export { createStd } from './function/statistics/std.js';
 export { createCombinations } from './function/probability/combinations.js';
 export { createCombinationsWithRep } from './function/probability/combinationsWithRep.js';
 export { createGamma } from './function/probability/gamma.js';
+export { createLgamma } from './function/probability/lgamma.js';
 export { createFactorial } from './function/probability/factorial.js';
 export { createKldivergence } from './function/probability/kldivergence.js';
 export { createMultinomial } from './function/probability/multinomial.js';
@@ -240,7 +246,11 @@ export { createStirlingS2 } from './function/combinatorics/stirlingS2.js';
 export { createBellNumbers } from './function/combinatorics/bellNumbers.js';
 export { createCatalan } from './function/combinatorics/catalan.js';
 export { createComposition } from './function/combinatorics/composition.js';
+export { createLeafCount } from './function/algebra/leafCount.js';
 export { createSimplify } from './function/algebra/simplify.js';
+export { createSimplifyCore } from './function/algebra/simplifyCore.js';
+export { createResolve } from './function/algebra/resolve.js';
+export { createSymbolicEqual } from './function/algebra/symbolicEqual.js';
 export { createDerivative } from './function/algebra/derivative.js';
 export { createRationalize } from './function/algebra/rationalize.js';
 export { createReviver } from './json/reviver.js';
@@ -264,4 +274,5 @@ export { createConcatTransform } from './expression/transform/concat.transform.j
 export { createDiffTransform } from './expression/transform/diff.transform.js';
 export { createStdTransform } from './expression/transform/std.transform.js';
 export { createSumTransform } from './expression/transform/sum.transform.js';
+export { createCumSumTransform } from './expression/transform/cumsum.transform.js';
 export { createVarianceTransform } from './expression/transform/variance.transform.js';