mathjs 10.6.4 → 11.1.0

package/lib/esm/entry/pureFunctionsAny.generated.js

@@ -4,7 +4,7 @@
  */
 import { config } from './configReadonly.js';
 import { createBigNumberClass, createComplexClass, createE, createFalse, createFineStructure, createFractionClass, createI, createInfinity, createLN10, createLOG10E, createMatrixClass, createNaN, createNull, createPhi, createRangeClass, createResultSet, createSQRT1_2, // eslint-disable-line camelcase
-createSackurTetrode, createTau, createTrue, createVersion, createDenseMatrixClass, createEfimovFactor, createLN2, createPi, createReplacer, createSQRT2, createTyped, createUnaryPlus, createWeakMixingAngle, createAbs, createAcos, createAcot, createAcsc, createAddScalar, createArg, createAsech, createAsinh, createAtan, createAtanh, createBignumber, createBitNot, createBoolean, createClone, createCombinations, createComplex, createConj, createCosh, createCoth, createCsc, createCube, createEqualScalar, createErf, createExp, createExpm1, createFilter, createForEach, createFormat, createGetMatrixDataType, createHex, createIm, createIsInteger, createIsNegative, createIsPositive, createIsZero, createLOG2E, createLgamma, createLog10, createLog2, createMap, createMultiplyScalar, createNot, createNumber, createOct, createPickRandom, createPrint, createRandom, createRe, createSec, createSign, createSin, createSparseMatrixClass, createSplitUnit, createSquare, createString, createTan, createTypeOf, createAcosh, createAcsch, createApply, createAsec, createBin, createCombinationsWithRep, createCos, createCsch, createIsNaN, createIsPrime, createRandomInt, createSech, createSinh, createSparse, createSqrt, createTanh, createUnaryMinus, createAcoth, createCot, createFraction, createIsNumeric, createMatrix, createMatrixFromFunction, createMod, createNthRoot, createNumeric, createOr, createProd, createReshape, createSize, createSmaller, createSqueeze, createSubset, createSubtract, createTo, createTranspose, createXgcd, createZeros, createAnd, createBitAnd, createBitXor, createCbrt, createCompare, createCompareText, createConcat, createCount, createCtranspose, createDiag, createDivideScalar, createDotDivide, createEqual, createFft, createFlatten, createGcd, createHasNumericValue, createHypot, createIfft, createKron, createLargerEq, createLeftShift, createLsolve, createMatrixFromColumns, createMin, createMode, createNthRoots, createOnes, createPartitionSelect, createResize, createRightArithShift, createRound, createSmallerEq, createUnequal, createUsolve, createXor, createAdd, createAtan2, createBitOr, createCatalan, createCompareNatural, createCumSum, createDeepEqual, createDiff, createDot, createEqualText, createFloor, createIdentity, createInvmod, createLarger, createLog, createLsolveAll, createMatrixFromRows, createMultiply, createQr, createRange, createRightLogShift, createSetSize, createSlu, createSum, createTrace, createUsolveAll, createAsin, createCeil, createComposition, createCross, createDet, createDistance, createDotMultiply, createFibonacciHeapClass, createFix, createImmutableDenseMatrixClass, createIndexClass, createIntersect, createLcm, createLog1p, createMax, createQuantileSeq, createRow, createSetCartesian, createSetDistinct, createSetIsSubset, createSetPowerset, createSort, createColumn, createIndex, createInv, createPinv, createPow, createSetDifference, createSetMultiplicity, createSpaClass, createSqrtm, createUnitClass, createVacuumImpedance, createWienDisplacement, createAtomicMass, createBohrMagneton, createBoltzmann, createConductanceQuantum, createCreateUnit, createDeuteronMass, createDotPow, createElectricConstant, createElementaryCharge, createExpm, createFaraday, createFirstRadiation, createGamma, createGravitationConstant, createHartreeEnergy, createKlitzing, createLoschmidt, createMagneticConstant, createMolarMass, createMolarPlanckConstant, createNeutronMass, createNuclearMagneton, createPlanckCharge, createPlanckLength, createPlanckTemperature, createProtonMass, createReducedPlanckConstant, createRydberg, createSetIntersect, createSpeedOfLight, createStefanBoltzmann, createThomsonCrossSection, createAvogadro, createBohrRadius, createCoulomb, createDivide, createElectronMass, createFactorial, createGravity, createInverseConductanceQuantum, createLup, createMagneticFluxQuantum, createMolarMassC12, createMultinomial, createPermutations, createPlanckMass, createQuantumOfCirculation, createSecondRadiation, createStirlingS2, createUnitFunction, createBellNumbers, createEigs, createFermiCoupling, createMean, createMolarVolume, createPlanckConstant, createSetSymDifference, createClassicalElectronRadius, createLusolve, createMedian, createSetUnion, createVariance, createKldivergence, createNorm, createPlanckTime, createRotationMatrix, createGasConstant, createStd, createMad, createRotate } from '../factoriesAny.js';
+createSackurTetrode, createTau, createTrue, createVersion, createDenseMatrixClass, createEfimovFactor, createLN2, createPi, createReplacer, createSQRT2, createTyped, createUnaryPlus, createWeakMixingAngle, createAbs, createAcos, createAcot, createAcsc, createAddScalar, createArg, createAsech, createAsinh, createAtan, createAtanh, createBignumber, createBitNot, createBoolean, createClone, createCombinations, createComplex, createConj, createCosh, createCoth, createCsc, createCube, createEqualScalar, createErf, createExp, createExpm1, createFilter, createForEach, createFormat, createGetMatrixDataType, createHex, createIm, createIsInteger, createIsNegative, createIsPositive, createIsZero, createLOG2E, createLgamma, createLog10, createLog2, createMap, createMultiplyScalar, createNot, createNumber, createOct, createPickRandom, createPrint, createRandom, createRe, createSec, createSign, createSin, createSparseMatrixClass, createSplitUnit, createSquare, createString, createTan, createTypeOf, createAcosh, createAcsch, createApply, createAsec, createBin, createCombinationsWithRep, createCos, createCsch, createIsNaN, createIsPrime, createRandomInt, createSech, createSinh, createSparse, createSqrt, createTanh, createUnaryMinus, createAcoth, createCot, createFraction, createIsNumeric, createMatrix, createMatrixFromFunction, createMod, createNthRoot, createNumeric, createOr, createProd, createReshape, createSize, createSmaller, createSqueeze, createSubset, createSubtract, createTo, createTranspose, createXgcd, createZeros, createAnd, createBitAnd, createBitXor, createCbrt, createCompare, createCompareText, createConcat, createCount, createCtranspose, createDiag, createDivideScalar, createDotDivide, createEqual, createFft, createFlatten, createGcd, createHasNumericValue, createHypot, createIfft, createKron, createLargerEq, createLeftShift, createLsolve, createMatrixFromColumns, createMin, createMode, createNthRoots, createOnes, createPartitionSelect, createResize, createRightArithShift, createRound, createSmallerEq, createUnequal, createUsolve, createXor, createAdd, createAtan2, createBitOr, createCatalan, createCompareNatural, createCumSum, createDeepEqual, createDiff, createDot, createEqualText, createFloor, createIdentity, createInvmod, createLarger, createLog, createLsolveAll, createMatrixFromRows, createMultiply, createQr, createRange, createRightLogShift, createSetSize, createSlu, createSum, createTrace, createUsolveAll, createAsin, createCeil, createComposition, createCross, createDet, createDistance, createDotMultiply, createFibonacciHeapClass, createFix, createImmutableDenseMatrixClass, createIndexClass, createIntersect, createLcm, createLog1p, createMax, createQuantileSeq, createRow, createSetCartesian, createSetDistinct, createSetIsSubset, createSetPowerset, createSort, createColumn, createIndex, createInv, createPinv, createPow, createSetDifference, createSetMultiplicity, createSpaClass, createSqrtm, createUnitClass, createVacuumImpedance, createWienDisplacement, createAtomicMass, createBohrMagneton, createBoltzmann, createConductanceQuantum, createCreateUnit, createDeuteronMass, createDotPow, createElectricConstant, createElementaryCharge, createExpm, createFaraday, createFirstRadiation, createGamma, createGravitationConstant, createHartreeEnergy, createKlitzing, createLoschmidt, createMagneticConstant, createMolarMass, createMolarPlanckConstant, createNeutronMass, createNuclearMagneton, createPlanckCharge, createPlanckLength, createPlanckTemperature, createProtonMass, createReducedPlanckConstant, createRydberg, createSetIntersect, createSpeedOfLight, createStefanBoltzmann, createThomsonCrossSection, createAvogadro, createBohrRadius, createCoulomb, createDivide, createElectronMass, createFactorial, createGravity, createInverseConductanceQuantum, createLup, createMagneticFluxQuantum, createMolarMassC12, createMultinomial, createPermutations, createPlanckMass, createQuantumOfCirculation, createSecondRadiation, createStirlingS2, createUnitFunction, createBellNumbers, createEigs, createFermiCoupling, createMean, createMolarVolume, createPlanckConstant, createSetSymDifference, createVariance, createClassicalElectronRadius, createLusolve, createMedian, createSetUnion, createStd, createGasConstant, createMad, createNorm, createRotationMatrix, createKldivergence, createRotate, createPlanckTime } from '../factoriesAny.js';
 export var BigNumber = /* #__PURE__ */createBigNumberClass({
   config
 });
@@ -1124,6 +1124,7 @@ export var sqrtm = /* #__PURE__ */createSqrtm({
   add,
   identity,
   inv,
+  map,
   max,
   multiply,
   size,
@@ -1511,6 +1512,15 @@ export var setSymDifference = /* #__PURE__ */createSetSymDifference({
   subset,
   typed
 });
+export var variance = /* #__PURE__ */createVariance({
+  add,
+  apply,
+  divide,
+  isNaN,
+  multiply,
+  subtract,
+  typed
+});
 export var classicalElectronRadius = /* #__PURE__ */createClassicalElectronRadius({
   BigNumber,
   Unit,
@@ -1541,23 +1551,22 @@ export var setUnion = /* #__PURE__ */createSetUnion({
   subset,
   typed
 });
-export var variance = /* #__PURE__ */createVariance({
-  add,
-  apply,
-  divide,
-  isNaN,
-  multiply,
-  subtract,
-  typed
+export var std = /* #__PURE__ */createStd({
+  map,
+  sqrt,
+  typed,
+  variance
 });
-export var kldivergence = /* #__PURE__ */createKldivergence({
-  divide,
-  dotDivide,
-  isNumeric,
-  log,
-  matrix,
-  multiply,
-  sum,
+export var gasConstant = /* #__PURE__ */createGasConstant({
+  BigNumber,
+  Unit,
+  config
+});
+export var mad = /* #__PURE__ */createMad({
+  abs,
+  map,
+  median,
+  subtract,
   typed
 });
 export var norm = /* #__PURE__ */createNorm({
@@ -1575,11 +1584,6 @@ export var norm = /* #__PURE__ */createNorm({
   sqrt,
   typed
 });
-export var planckTime = /* #__PURE__ */createPlanckTime({
-  BigNumber,
-  Unit,
-  config
-});
 export var rotationMatrix = /* #__PURE__ */createRotationMatrix({
   BigNumber,
   DenseMatrix,
@@ -1594,25 +1598,24 @@ export var rotationMatrix = /* #__PURE__ */createRotationMatrix({
   typed,
   unaryMinus
 });
-export var gasConstant = /* #__PURE__ */createGasConstant({
-  BigNumber,
-  Unit,
-  config
-});
-export var std = /* #__PURE__ */createStd({
-  sqrt,
-  typed,
-  variance
-});
-export var mad = /* #__PURE__ */createMad({
-  abs,
+export var kldivergence = /* #__PURE__ */createKldivergence({
+  divide,
+  dotDivide,
+  isNumeric,
+  log,
   map,
-  median,
-  subtract,
+  matrix,
+  multiply,
+  sum,
   typed
 });
 export var rotate = /* #__PURE__ */createRotate({
   multiply,
   rotationMatrix,
   typed
+});
+export var planckTime = /* #__PURE__ */createPlanckTime({
+  BigNumber,
+  Unit,
+  config
 });

package/lib/esm/entry/pureFunctionsNumber.generated.js

@@ -4,7 +4,7 @@
  */
 import { config } from './configReadonly.js';
 import { createE, createFalse, createIndex, createInfinity, createLN10, createLOG10E, createMatrix, createNaN, createNull, createPhi, createRangeClass, createReplacer, createResultSet, createSQRT1_2, // eslint-disable-line camelcase
-createSubset, createTau, createTyped, createUnaryPlus, createVersion, createXor, createAbs, createAcos, createAcot, createAcsc, createAdd, createAnd, createAsec, createAsin, createAtan, createAtanh, createBitAnd, createBitOr, createBoolean, createCbrt, createCombinations, createCompare, createCompareText, createCos, createCot, createCsc, createCube, createDivide, createEqualScalar, createErf, createExp, createFilter, createForEach, createFormat, createGamma, createIsInteger, createIsNegative, createIsPositive, createIsZero, createLOG2E, createLargerEq, createLeftShift, createLog, createLog1p, createMap, createMean, createMod, createMultiply, createNot, createNumber, createOr, createPi, createPow, createRandom, createRightLogShift, createSQRT2, createSech, createSin, createSize, createSmallerEq, createSquare, createString, createSubtract, createTanh, createTypeOf, createUnequal, createXgcd, createAcoth, createAddScalar, createAsech, createBitNot, createClone, createCompareNatural, createCosh, createCsch, createDivideScalar, createEqualText, createExpm1, createIsNumeric, createLN2, createLcm, createLog10, createMultiplyScalar, createNthRoot, createPickRandom, createRandomInt, createRightArithShift, createSec, createSinh, createSqrt, createTan, createUnaryMinus, createAcosh, createApply, createAsinh, createBitXor, createCombinationsWithRep, createCumSum, createEqual, createFactorial, createHasNumericValue, createIsNaN, createLarger, createLog2, createMode, createNorm, createPartitionSelect, createPrint, createQuantileSeq, createRound, createSmaller, createStirlingS2, createTrue, createVariance, createAcsch, createAtan2, createCatalan, createComposition, createDeepEqual, createFloor, createHypot, createLgamma, createMedian, createMultinomial, createPermutations, createRange, createSign, createStd, createCeil, createCoth, createFix, createIsPrime, createNumeric, createProd, createSum, createBellNumbers, createGcd, createMad, createMax, createMin } from '../factoriesNumber.js';
+createSubset, createTau, createTyped, createUnaryPlus, createVersion, createXor, createAbs, createAcos, createAcot, createAcsc, createAdd, createAnd, createAsec, createAsin, createAtan, createAtanh, createBitAnd, createBitOr, createBoolean, createCbrt, createCombinations, createCompare, createCompareText, createCos, createCot, createCsc, createCube, createDivide, createEqualScalar, createErf, createExp, createFilter, createForEach, createFormat, createGamma, createIsInteger, createIsNegative, createIsPositive, createIsZero, createLOG2E, createLargerEq, createLeftShift, createLog, createLog1p, createMap, createMean, createMod, createMultiply, createNot, createNumber, createOr, createPi, createPow, createRandom, createRightLogShift, createSQRT2, createSech, createSin, createSize, createSmallerEq, createSquare, createString, createSubtract, createTanh, createTypeOf, createUnequal, createXgcd, createAcoth, createAddScalar, createAsech, createBitNot, createCombinationsWithRep, createCosh, createCsch, createDivideScalar, createEqualText, createExpm1, createIsNumeric, createLN2, createLcm, createLog10, createMultiplyScalar, createNthRoot, createPickRandom, createRandomInt, createRightArithShift, createSec, createSinh, createSqrt, createTan, createUnaryMinus, createAcosh, createApply, createAsinh, createBitXor, createClone, createCumSum, createEqual, createFactorial, createHasNumericValue, createIsNaN, createLarger, createLog2, createMode, createNorm, createPartitionSelect, createPrint, createQuantileSeq, createRound, createSmaller, createStirlingS2, createTrue, createVariance, createAcsch, createAtan2, createCatalan, createCompareNatural, createComposition, createDeepEqual, createFloor, createHypot, createLgamma, createMedian, createMultinomial, createPermutations, createRange, createSign, createStd, createCeil, createCoth, createFix, createIsPrime, createNumeric, createProd, createBellNumbers, createGcd, createMad, createSum, createMax, createMin } from '../factoriesNumber.js';
 export var e = /* #__PURE__ */createE({
   config
 });
@@ -250,11 +250,7 @@ export var asech = /* #__PURE__ */createAsech({
 export var bitNot = /* #__PURE__ */createBitNot({
   typed
 });
-export var clone = /* #__PURE__ */createClone({
-  typed
-});
-export var compareNatural = /* #__PURE__ */createCompareNatural({
-  compare,
+export var combinationsWithRep = /* #__PURE__ */createCombinationsWithRep({
   typed
 });
 export var cosh = /* #__PURE__ */createCosh({
@@ -331,7 +327,7 @@ export var asinh = /* #__PURE__ */createAsinh({
 export var bitXor = /* #__PURE__ */createBitXor({
   typed
 });
-export var combinationsWithRep = /* #__PURE__ */createCombinationsWithRep({
+export var clone = /* #__PURE__ */createClone({
   typed
 });
 export var cumsum = /* #__PURE__ */createCumSum({
@@ -431,6 +427,10 @@ export var catalan = /* #__PURE__ */createCatalan({
   multiplyScalar,
   typed
 });
+export var compareNatural = /* #__PURE__ */createCompareNatural({
+  compare,
+  typed
+});
 export var composition = /* #__PURE__ */createComposition({
   addScalar,
   combinations,
@@ -495,6 +495,7 @@ export var sign = /* #__PURE__ */createSign({
   typed
 });
 export var std = /* #__PURE__ */createStd({
+  map,
   sqrt,
   typed,
   variance
@@ -524,12 +525,6 @@ export var prod = /* #__PURE__ */createProd({
   numeric,
   typed
 });
-export var sum = /* #__PURE__ */createSum({
-  add,
-  config,
-  numeric,
-  typed
-});
 export var bellNumbers = /* #__PURE__ */createBellNumbers({
   addScalar,
   isInteger,
@@ -547,6 +542,12 @@ export var mad = /* #__PURE__ */createMad({
   subtract,
   typed
 });
+export var sum = /* #__PURE__ */createSum({
+  add,
+  config,
+  numeric,
+  typed
+});
 export var max = /* #__PURE__ */createMax({
   config,
   larger,

package/lib/esm/expression/embeddedDocs/construction/index.js

@@ -3,6 +3,6 @@ export var indexDocs = {
   category: 'Construction',
   syntax: ['[start]', '[start:end]', '[start:step:end]', '[start1, start 2, ...]', '[start1:end1, start2:end2, ...]', '[start1:step1:end1, start2:step2:end2, ...]'],
   description: 'Create an index to get or replace a subset of a matrix',
-  examples: ['[]', '[1, 2, 3]', 'A = [1, 2, 3; 4, 5, 6]', 'A[1, :]', 'A[1, 2] = 50', 'A[0:2, 0:2] = ones(2, 2)'],
+  examples: ['[1, 2, 3]', 'A = [1, 2, 3; 4, 5, 6]', 'A[1, :]', 'A[1, 2] = 50', 'A[1:2, 1:2] = ones(2, 2)'],
   seealso: ['bignumber', 'boolean', 'complex', 'matrix,', 'number', 'range', 'string', 'unit']
 };

package/lib/esm/expression/embeddedDocs/embeddedDocs.js

@@ -40,6 +40,7 @@ import { qrDocs } from './function/algebra/qr.js';
 import { rationalizeDocs } from './function/algebra/rationalize.js';
 import { resolveDocs } from './function/algebra/resolve.js';
 import { simplifyDocs } from './function/algebra/simplify.js';
+import { simplifyConstantDocs } from './function/algebra/simplifyConstant.js';
 import { simplifyCoreDocs } from './function/algebra/simplifyCore.js';
 import { sluDocs } from './function/algebra/slu.js';
 import { symbolicEqualDocs } from './function/algebra/symbolicEqual.js';
@@ -478,6 +479,7 @@ export var embeddedDocs = {
   leafCount: leafCountDocs,
   resolve: resolveDocs,
   simplify: simplifyDocs,
+  simplifyConstant: simplifyConstantDocs,
   simplifyCore: simplifyCoreDocs,
   symbolicEqual: symbolicEqualDocs,
   rationalize: rationalizeDocs,

package/lib/esm/expression/embeddedDocs/function/algebra/simplifyConstant.js

@@ -0,0 +1,8 @@
+export var simplifyConstantDocs = {
+  name: 'simplifyConstant',
+  category: 'Algebra',
+  syntax: ['simplifyConstant(expr)', 'simplifyConstant(expr, options)'],
+  description: 'Replace constant subexpressions of node with their values.',
+  examples: ['simplifyConatant("(3-3)*x")', 'simplifyConstant(parse("z-cos(tau/8)"))'],
+  seealso: ['simplify', 'simplifyCore', 'evaluate']
+};

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

@@ -4,5 +4,5 @@ export var simplifyCoreDocs = {
   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']
+  seealso: ['simplify', 'simplifyConstant', 'evaluate']
 };

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

@@ -1,3 +1,4 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
 import { isAccessorNode, isArrayNode, isConstantNode, isFunctionNode, isIndexNode, isNode, isObjectNode, isParenthesisNode, isSymbolNode } from '../../utils/is.js';
 import { getSafeProperty } from '../../utils/customs.js';
 import { factory } from '../../utils/factory.js';
@@ -13,196 +14,200 @@ export var createAccessorNode = /* #__PURE__ */factory(name, dependencies, _ref
     subset
   });
   /**
-   * @constructor AccessorNode
-   * @extends {Node}
-   * Access an object property or get a matrix subset
-   *
-   * @param {Node} object                 The object from which to retrieve
-   *                                      a property or subset.
-   * @param {IndexNode} index             IndexNode containing ranges
+   * Are parenthesis needed?
+   * @private
    */
 
-  function AccessorNode(object, index) {
-    if (!(this instanceof AccessorNode)) {
-      throw new SyntaxError('Constructor must be called with the new operator');
-    }
-
-    if (!isNode(object)) {
-      throw new TypeError('Node expected for parameter "object"');
-    }
-
-    if (!isIndexNode(index)) {
-      throw new TypeError('IndexNode expected for parameter "index"');
-    }
-
-    this.object = object || null;
-    this.index = index; // readonly property name
-
-    Object.defineProperty(this, 'name', {
-      get: function () {
-        if (this.index) {
-          return this.index.isObjectProperty() ? this.index.getObjectProperty() : '';
-        } else {
-          return this.object.name || '';
-        }
-      }.bind(this),
-      set: function set() {
-        throw new Error('Cannot assign a new name, name is read-only');
-      }
-    });
+  function needParenthesis(node) {
+    // TODO: maybe make a method on the nodes which tells whether they need parenthesis?
+    return !(isAccessorNode(node) || isArrayNode(node) || isConstantNode(node) || isFunctionNode(node) || isObjectNode(node) || isParenthesisNode(node) || isSymbolNode(node));
   }
 
-  AccessorNode.prototype = new Node();
-  AccessorNode.prototype.type = 'AccessorNode';
-  AccessorNode.prototype.isAccessorNode = true;
-  /**
-   * Compile a node into a JavaScript function.
-   * This basically pre-calculates as much as possible and only leaves open
-   * calculations which depend on a dynamic scope with variables.
-   * @param {Object} math     Math.js namespace with functions and constants.
-   * @param {Object} argNames An object with argument names as key and `true`
-   *                          as value. Used in the SymbolNode to optimize
-   *                          for arguments from user assigned functions
-   *                          (see FunctionAssignmentNode) or special symbols
-   *                          like `end` (see IndexNode).
-   * @return {function} Returns a function which can be called like:
-   *                        evalNode(scope: Object, args: Object, context: *)
-   */
+  class AccessorNode extends Node {
+    /**
+     * @constructor AccessorNode
+     * @extends {Node}
+     * Access an object property or get a matrix subset
+     *
+     * @param {Node} object                 The object from which to retrieve
+     *                                      a property or subset.
+     * @param {IndexNode} index             IndexNode containing ranges
+     */
+    constructor(object, index) {
+      super();
+
+      if (!isNode(object)) {
+        throw new TypeError('Node expected for parameter "object"');
+      }
 
-  AccessorNode.prototype._compile = function (math, argNames) {
-    var evalObject = this.object._compile(math, argNames);
+      if (!isIndexNode(index)) {
+        throw new TypeError('IndexNode expected for parameter "index"');
+      }
 
-    var evalIndex = this.index._compile(math, argNames);
+      this.object = object;
+      this.index = index;
+    } // readonly property name
 
-    if (this.index.isObjectProperty()) {
-      var prop = this.index.getObjectProperty();
-      return function evalAccessorNode(scope, args, context) {
-        // get a property from an object evaluated using the scope.
-        return getSafeProperty(evalObject(scope, args, context), prop);
-      };
-    } else {
-      return function evalAccessorNode(scope, args, context) {
-        var object = evalObject(scope, args, context);
-        var index = evalIndex(scope, args, object); // we pass object here instead of context
 
-        return access(object, index);
-      };
+    get name() {
+      if (this.index) {
+        return this.index.isObjectProperty() ? this.index.getObjectProperty() : '';
+      } else {
+        return this.object.name || '';
+      }
     }
-  };
-  /**
-   * Execute a callback for each of the child nodes of this node
-   * @param {function(child: Node, path: string, parent: Node)} callback
-   */
 
+    get type() {
+      return name;
+    }
 
-  AccessorNode.prototype.forEach = function (callback) {
-    callback(this.object, 'object', this);
-    callback(this.index, 'index', this);
-  };
-  /**
-   * Create a new AccessorNode having it's childs be the results of calling
-   * the provided callback function for each of the childs of the original node.
-   * @param {function(child: Node, path: string, parent: Node): Node} callback
-   * @returns {AccessorNode} Returns a transformed copy of the node
-   */
+    get isAccessorNode() {
+      return true;
+    }
+    /**
+     * Compile a node into a JavaScript function.
+     * This basically pre-calculates as much as possible and only leaves open
+     * calculations which depend on a dynamic scope with variables.
+     * @param {Object} math     Math.js namespace with functions and constants.
+     * @param {Object} argNames An object with argument names as key and `true`
+     *                          as value. Used in the SymbolNode to optimize
+     *                          for arguments from user assigned functions
+     *                          (see FunctionAssignmentNode) or special symbols
+     *                          like `end` (see IndexNode).
+     * @return {function} Returns a function which can be called like:
+     *                        evalNode(scope: Object, args: Object, context: *)
+     */
+
+
+    _compile(math, argNames) {
+      var evalObject = this.object._compile(math, argNames);
+
+      var evalIndex = this.index._compile(math, argNames);
+
+      if (this.index.isObjectProperty()) {
+        var prop = this.index.getObjectProperty();
+        return function evalAccessorNode(scope, args, context) {
+          // get a property from an object evaluated using the scope.
+          return getSafeProperty(evalObject(scope, args, context), prop);
+        };
+      } else {
+        return function evalAccessorNode(scope, args, context) {
+          var object = evalObject(scope, args, context); // we pass just object here instead of context:
+
+          var index = evalIndex(scope, args, object);
+          return access(object, index);
+        };
+      }
+    }
+    /**
+     * Execute a callback for each of the child nodes of this node
+     * @param {function(child: Node, path: string, parent: Node)} callback
+     */
 
 
-  AccessorNode.prototype.map = function (callback) {
-    return new AccessorNode(this._ifNode(callback(this.object, 'object', this)), this._ifNode(callback(this.index, 'index', this)));
-  };
-  /**
-   * Create a clone of this node, a shallow copy
-   * @return {AccessorNode}
-   */
-
+    forEach(callback) {
+      callback(this.object, 'object', this);
+      callback(this.index, 'index', this);
+    }
+    /**
+     * Create a new AccessorNode whose children are the results of calling
+     * the provided callback function for each child of the original node.
+     * @param {function(child: Node, path: string, parent: Node): Node} callback
+     * @returns {AccessorNode} Returns a transformed copy of the node
+     */
 
-  AccessorNode.prototype.clone = function () {
-    return new AccessorNode(this.object, this.index);
-  };
-  /**
-   * Get string representation
-   * @param {Object} options
-   * @return {string}
-   */
 
+    map(callback) {
+      return new AccessorNode(this._ifNode(callback(this.object, 'object', this)), this._ifNode(callback(this.index, 'index', this)));
+    }
+    /**
+     * Create a clone of this node, a shallow copy
+     * @return {AccessorNode}
+     */
 
-  AccessorNode.prototype._toString = function (options) {
-    var object = this.object.toString(options);
 
-    if (needParenthesis(this.object)) {
-      object = '(' + object + ')';
+    clone() {
+      return new AccessorNode(this.object, this.index);
     }
+    /**
+     * Get string representation
+     * @param {Object} options
+     * @return {string}
+     */
 
-    return object + this.index.toString(options);
-  };
-  /**
-   * Get HTML representation
-   * @param {Object} options
-   * @return {string}
-   */
 
+    _toString(options) {
+      var object = this.object.toString(options);
 
-  AccessorNode.prototype.toHTML = function (options) {
-    var object = this.object.toHTML(options);
+      if (needParenthesis(this.object)) {
+        object = '(' + object + ')';
+      }
 
-    if (needParenthesis(this.object)) {
-      object = '<span class="math-parenthesis math-round-parenthesis">(</span>' + object + '<span class="math-parenthesis math-round-parenthesis">)</span>';
+      return object + this.index.toString(options);
     }
+    /**
+     * Get HTML representation
+     * @param {Object} options
+     * @return {string}
+     */
 
-    return object + this.index.toHTML(options);
-  };
-  /**
-   * Get LaTeX representation
-   * @param {Object} options
-   * @return {string}
-   */
 
+    toHTML(options) {
+      var object = this.object.toHTML(options);
 
-  AccessorNode.prototype._toTex = function (options) {
-    var object = this.object.toTex(options);
+      if (needParenthesis(this.object)) {
+        object = '<span class="math-parenthesis math-round-parenthesis">(</span>' + object + '<span class="math-parenthesis math-round-parenthesis">)</span>';
+      }
 
-    if (needParenthesis(this.object)) {
-      object = '\\left(\' + object + \'\\right)';
+      return object + this.index.toHTML(options);
     }
+    /**
+     * Get LaTeX representation
+     * @param {Object} options
+     * @return {string}
+     */
 
-    return object + this.index.toTex(options);
-  };
-  /**
-   * Get a JSON representation of the node
-   * @returns {Object}
-   */
 
+    _toTex(options) {
+      var object = this.object.toTex(options);
 
-  AccessorNode.prototype.toJSON = function () {
-    return {
-      mathjs: 'AccessorNode',
-      object: this.object,
-      index: this.index
-    };
-  };
-  /**
-   * Instantiate an AccessorNode from its JSON representation
-   * @param {Object} json  An object structured like
-   *                       `{"mathjs": "AccessorNode", object: ..., index: ...}`,
-   *                       where mathjs is optional
-   * @returns {AccessorNode}
-   */
+      if (needParenthesis(this.object)) {
+        object = '\\left(\' + object + \'\\right)';
+      }
 
+      return object + this.index.toTex(options);
+    }
+    /**
+     * Get a JSON representation of the node
+     * @returns {Object}
+     */
 
-  AccessorNode.fromJSON = function (json) {
-    return new AccessorNode(json.object, json.index);
-  };
-  /**
-   * Are parenthesis needed?
-   * @private
-   */
 
+    toJSON() {
+      return {
+        mathjs: name,
+        object: this.object,
+        index: this.index
+      };
+    }
+    /**
+     * Instantiate an AccessorNode from its JSON representation
+     * @param {Object} json
+     *     An object structured like
+     *     `{"mathjs": "AccessorNode", object: ..., index: ...}`,
+     *     where mathjs is optional
+     * @returns {AccessorNode}
+     */
+
+
+    static fromJSON(json) {
+      return new AccessorNode(json.object, json.index);
+    }
 
-  function needParenthesis(node) {
-    // TODO: maybe make a method on the nodes which tells whether they need parenthesis?
-    return !(isAccessorNode(node) || isArrayNode(node) || isConstantNode(node) || isFunctionNode(node) || isObjectNode(node) || isParenthesisNode(node) || isSymbolNode(node));
   }
 
+  _defineProperty(AccessorNode, "name", name);
+
   return AccessorNode;
 }, {
   isClass: true,