mathjs 10.0.0 → 10.6.4

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/arithmetic/invmod.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.invmodDocs = void 0;
+var invmodDocs = {
+  name: 'invmod',
+  category: 'Arithmetic',
+  syntax: ['invmod(a, b)'],
+  description: 'Calculate the (modular) multiplicative inverse of a modulo b. Solution to the equation ax ≣ 1 (mod b)',
+  examples: ['invmod(8, 12)=NaN', 'invmod(7, 13)=2', 'math.invmod(15151, 15122)=10429'],
+  seealso: ['gcd', 'xgcd']
+};
+exports.invmodDocs = invmodDocs;

package/lib/cjs/expression/embeddedDocs/function/arithmetic/pow.js

@@ -9,7 +9,7 @@ var powDocs = {
   category: 'Operators',
   syntax: ['x ^ y', 'pow(x, y)'],
   description: 'Calculates the power of x to y, x^y.',
-  examples: ['2^3', '2*2*2', '1 + e ^ (pi * i)'],
+  examples: ['2^3', '2*2*2', '1 + e ^ (pi * i)', 'math.pow([[1, 2], [4, 3]], 2)', 'math.pow([[1, 2], [4, 3]], -1)'],
   seealso: ['multiply', 'nthRoot', 'nthRoots', 'sqrt']
 };
 exports.powDocs = powDocs;

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

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.fftDocs = void 0;
+var fftDocs = {
+  name: 'fft',
+  category: 'Matrix',
+  syntax: ['fft(x)'],
+  description: 'Calculate N-dimensional fourier transform',
+  examples: ['fft([[1, 0], [1, 0]])'],
+  seealso: ['ifft']
+};
+exports.fftDocs = fftDocs;

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

@@ -9,7 +9,7 @@ var forEachDocs = {
   category: 'Matrix',
   syntax: ['forEach(x, callback)'],
   description: 'Iterates over all elements of a matrix/array, and executes the given callback function.',
-  examples: ['forEach([1, 2, 3], function(val) { console.log(val) })'],
+  examples: ['numberOfPets = {}', 'addPet(n) = numberOfPets[n] = (numberOfPets[n] ? numberOfPets[n]:0 ) + 1;', 'forEach(["Dog","Cat","Cat"], addPet)', 'numberOfPets'],
   seealso: ['map', 'sort', 'filter']
 };
 exports.forEachDocs = forEachDocs;

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

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ifftDocs = void 0;
+var ifftDocs = {
+  name: 'ifft',
+  category: 'Matrix',
+  syntax: ['ifft(x)'],
+  description: 'Calculate N-dimensional inverse fourier transform',
+  examples: ['ifft([[2, 2], [0, 0]])'],
+  seealso: ['fft']
+};
+exports.ifftDocs = ifftDocs;

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

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.pinvDocs = void 0;
+var pinvDocs = {
+  name: 'pinv',
+  category: 'Matrix',
+  syntax: ['pinv(x)'],
+  description: 'Calculate the Moore–Penrose inverse of a matrix',
+  examples: ['pinv([1, 2; 3, 4])', 'pinv([[1, 0], [0, 1], [0, 1]])', 'pinv(4)'],
+  seealso: ['inv']
+};
+exports.pinvDocs = pinvDocs;

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/probability/lgamma.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.lgammaDocs = void 0;
+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']
+};
+exports.lgammaDocs = lgammaDocs;

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

@@ -72,6 +72,13 @@ var createFunctionNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies
   FunctionNode.prototype = new Node();
   FunctionNode.prototype.type = 'FunctionNode';
   FunctionNode.prototype.isFunctionNode = true;
+  /* format to fixed length */
+
+  var strin = function strin(entity) {
+    return (0, _string.format)(entity, {
+      truncate: 78
+    });
+  };
   /**
    * Compile a node into a JavaScript function.
    * This basically pre-calculates as much as possible and only leaves open
@@ -86,6 +93,7 @@ var createFunctionNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies
    *                        evalNode(scope: Object, args: Object, context: *)
    */
 
+
   FunctionNode.prototype._compile = function (math, argNames) {
     if (!(this instanceof FunctionNode)) {
       throw new TypeError('No valid FunctionNode');
@@ -97,78 +105,106 @@ 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) {
+          var value;
 
-        return FunctionNode.onUndefinedFunction(_name);
-      };
+          if (scope.has(_name)) {
+            value = scope.get(_name);
+          } else if (_name in math) {
+            value = (0, _customs.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, (0, _scope.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(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];
+
+          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, (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) {
@@ -180,15 +216,20 @@ var createFunctionNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies
     } 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, (0, _scope.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, (0, _scope.createSubScope)(scope, args), scope); // "raw" evaluation
         } else {
           // "regular" evaluation
           var values = evalArgs.map(function (evalArg) {
@@ -270,7 +311,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 +417,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 +477,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 +508,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 +528,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

@@ -9,21 +9,20 @@ exports.createIndexNode = void 0;
 
 var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 
-var _is = require("../../utils/is.js");
-
 var _array = require("../../utils/array.js");
 
-var _string = require("../../utils/string.js");
+var _customs = require("../../utils/customs.js");
 
 var _factory = require("../../utils/factory.js");
 
-var _customs = require("../../utils/customs.js");
+var _is = require("../../utils/is.js");
+
+var _string = require("../../utils/string.js");
 
 var name = 'IndexNode';
-var dependencies = ['Range', 'Node', 'size'];
+var dependencies = ['Node', 'size'];
 var createIndexNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var Range = _ref.Range,
-      Node = _ref.Node,
+  var Node = _ref.Node,
       size = _ref.size;
 
   /**
@@ -81,61 +80,32 @@ var createIndexNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
     // TODO: Optimization: when the range values are ConstantNodes,
     //       we can beforehand resolve the zero-based value
     // optimization for a simple object property
-    var evalDimensions = (0, _array.map)(this.dimensions, function (range, i) {
-      if ((0, _is.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 ((0, _is.isSymbolNode)(range) && range.name === 'end') {
-        // SymbolNode 'end'
-        var _childArgNames = Object.create(argNames);
-
-        _childArgNames.end = true;
-
-        var evalRange = range._compile(math, _childArgNames);
+    var evalDimensions = (0, _array.map)(this.dimensions, function (dimension, i) {
+      var needsEnd = dimension.filter(function (node) {
+        return 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 (!(0, _is.isMatrix)(context) && !(0, _is.isArray)(context) && !(0, _is.isString)(context)) {
+            throw new TypeError('Cannot resolve "end": ' + 'context must be a Matrix, Array, or string but is ' + (0, _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 = (0, _customs.getSafeProperty)(math, 'index');
@@ -143,7 +113,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));
     };
   };
   /**
@@ -271,12 +241,7 @@ var createIndexNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
       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((0, _is.isBigNumber)(start) ? start.toNumber() : start, (0, _is.isBigNumber)(end) ? end.toNumber() : end, (0, _is.isBigNumber)(step) ? step.toNumber() : step);
-  }
+  };
 
   return IndexNode;
 }, {

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');
         }