mathjs 14.9.1 → 15.0.0

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

@@ -5,7 +5,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, createWeakMixingAngle, createAbs, createAcos, createAcot, createAcsc, createAddScalar, createArg, createAsech, createAsinh, createAtan, createAtanh, createBigint, createBitNot, createBoolean, createClone, createCombinations, createComplex, createConj, createCos, createCot, createCsc, createCube, createEqualScalar, createErf, createExp, createExpm1, createFilter, createFlatten, 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, createSubtractScalar, createTan, createToBest, createTypeOf, createAcosh, createAcsch, createAsec, createBignumber, createCombinationsWithRep, createCosh, createCsch, createIsNaN, createIsPrime, createMapSlices, createMatrix, createMatrixFromFunction, createOnes, createRandomInt, createReshape, createSech, createSinh, createSparse, createSqrt, createSqueeze, createTanh, createTranspose, createXgcd, createZeros, createAcoth, createAsin, createBin, createConcat, createCoth, createCtranspose, createDiag, createDotMultiply, createEqual, createFraction, createIdentity, createIsNumeric, createKron, createLargerEq, createLeftShift, createMode, createNthRoot, createNumeric, createProd, createResize, createRightArithShift, createRound, createSize, createSmaller, createTo, createUnaryMinus, createUnequal, createXor, createAdd, createAtan2, createBitAnd, createBitOr, createBitXor, createCbrt, createCompare, createCompareText, createCount, createDeepEqual, createDivideScalar, createDotDivide, createEqualText, createFloor, createGcd, createHasNumericValue, createHypot, createImmutableDenseMatrixClass, createIndexClass, createLarger, createLog, createLsolve, createMatrixFromColumns, createMax, createMin, createMod, createNthRoots, createNullish, createOr, createPartitionSelect, createQr, createRightLogShift, createSmallerEq, createSubset, createSubtract, createTrace, createUsolve, createCatalan, createCompareNatural, createComposition, createDiff, createDistance, createDot, createFibonacciHeapClass, createIndex, createInvmod, createLcm, createLog1p, createLsolveAll, createMatrixFromRows, createMultiply, createRange, createRow, createSetCartesian, createSetDistinct, createSetIsSubset, createSetPowerset, createSlu, createSort, createUnaryPlus, createUsolveAll, createZpk2tf, createAnd, createCeil, createColumn, createCross, createDet, createFix, createInv, createPinv, createPow, createSetDifference, createSetMultiplicity, createSetSymDifference, createSpaClass, createSqrtm, createSum, createUnitClass, createVacuumImpedance, createWienDisplacement, createAtomicMass, createBohrMagneton, createBoltzmann, createConductanceQuantum, createCoulomb, createCreateUnit, createDeuteronMass, createDotPow, createElectricConstant, createElementaryCharge, createExpm, createFaraday, createFft, createGamma, createGravitationConstant, createHartreeEnergy, createIfft, createInverseConductanceQuantum, createKlitzing, createLoschmidt, createMagneticConstant, createMolarMass, createMolarPlanckConstant, createNeutronMass, createNuclearMagneton, createPlanckCharge, createPlanckLength, createPlanckTemperature, createProtonMass, createQuantumOfCirculation, createReducedPlanckConstant, createRydberg, createSecondRadiation, createSetSize, createSpeedOfLight, createStefanBoltzmann, createThomsonCrossSection, createAvogadro, createBohrRadius, createCoulombConstant, createDivide, createElectronMass, createFactorial, createFirstRadiation, createGravity, createIntersect, createLup, createMagneticFluxQuantum, createMolarMassC12, createMultinomial, createPermutations, createPlanckMass, createPolynomialRoot, createSetIntersect, createSolveODE, createStirlingS2, createUnitFunction, createBellNumbers, createCumSum, createEigs, createFermiCoupling, createGasConstant, createKldivergence, createLusolve, createMean, createMolarVolume, createPlanckConstant, createQuantileSeq, createSetUnion, createVariance, createClassicalElectronRadius, createMedian, createCorr, createFreqz, createMad, createStd, createZeta, createNorm, createRotationMatrix, createPlanckTime, createSchur, createRotate, createSylvester, createLyap } from '../factoriesAny.js';
+createSackurTetrode, createTau, createTrue, createVersion, createDenseMatrixClass, createEfimovFactor, createLN2, createPi, createReplacer, createSQRT2, createTyped, createWeakMixingAngle, createAbs, createAcos, createAcot, createAcsc, createAddScalar, createArg, createAsech, createAsinh, createAtan, createAtanh, createBigint, createBitNot, createBoolean, createClone, createCombinations, createComplex, createConj, createCos, createCot, createCsc, createCube, createEqualScalar, createErf, createExp, createExpm1, createFilter, createFlatten, 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, createSize, createSparseMatrixClass, createSplitUnit, createSquare, createString, createSubtractScalar, createTan, createToBest, createTypeOf, createAcosh, createAcsch, createAsec, createBignumber, createCombinationsWithRep, createCosh, createCsch, createDot, createIsNaN, createIsPrime, createMapSlices, createMatrix, createMatrixFromFunction, createMultiply, createOnes, createRandomInt, createReshape, createSech, createSinh, createSparse, createSqrt, createSqueeze, createTanh, createTranspose, createXgcd, createZeros, createAcoth, createAsin, createBin, createConcat, createCoth, createCtranspose, createDiag, createDotMultiply, createEqual, createFraction, createIdentity, createIsNumeric, createKron, createLargerEq, createLeftShift, createMatrixFromRows, createMode, createNthRoot, createNumeric, createProd, createResize, createRightArithShift, createRound, createSmaller, createTo, createUnaryMinus, createUnequal, createXor, createAdd, createAtan2, createBitAnd, createBitOr, createBitXor, createCbrt, createCompare, createCompareText, createCount, createDeepEqual, createDivideScalar, createEqualText, createFloor, createGcd, createHasNumericValue, createHypot, createImmutableDenseMatrixClass, createIndexClass, createLarger, createLog, createLsolve, createMatrixFromColumns, createMin, createMod, createNthRoots, createNullish, createOr, createPartitionSelect, createQr, createRightLogShift, createSmallerEq, createSubset, createSubtract, createTrace, createUsolve, createZpk2tf, createCatalan, createCompareNatural, createComposition, createCross, createDet, createDiff, createDistance, createDotDivide, createFibonacciHeapClass, createIndex, createIntersect, createInvmod, createLcm, createLog1p, createLsolveAll, createMax, createRange, createRow, createSetCartesian, createSetDistinct, createSetIsSubset, createSetPowerset, createSlu, createSort, createUnaryPlus, createUsolveAll, createAnd, createCeil, createColumn, createCumSum, createFix, createSetDifference, createSetMultiplicity, createSetSymDifference, createSpaClass, createSum, createInv, createLup, createPinv, createPow, createSetIntersect, createSetUnion, createSqrtm, createUnitClass, createVacuumImpedance, createWienDisplacement, createAtomicMass, createBohrMagneton, createBoltzmann, createConductanceQuantum, createCoulomb, createCreateUnit, createDeuteronMass, createDotPow, createElectricConstant, createElementaryCharge, createExpm, createFaraday, createFft, createGamma, createGravitationConstant, createHartreeEnergy, createIfft, createKlitzing, createLoschmidt, createMagneticConstant, createMolarMass, createMolarPlanckConstant, createNeutronMass, createNuclearMagneton, createPlanckCharge, createPlanckLength, createPlanckTemperature, createProtonMass, createQuantumOfCirculation, createReducedPlanckConstant, createRydberg, createSecondRadiation, createSpeedOfLight, createStefanBoltzmann, createThomsonCrossSection, createAvogadro, createBohrRadius, createCoulombConstant, createDivide, createElectronMass, createFactorial, createFirstRadiation, createGravity, createInverseConductanceQuantum, createLusolve, createMagneticFluxQuantum, createMolarMassC12, createMultinomial, createPermutations, createPlanckMass, createPolynomialRoot, createSetSize, createSolveODE, createStirlingS2, createUnitFunction, createBellNumbers, createEigs, createFermiCoupling, createGasConstant, createKldivergence, createMean, createMolarVolume, createPlanckConstant, createQuantileSeq, createVariance, createClassicalElectronRadius, createMedian, createCorr, createFreqz, createMad, createStd, createZeta, createNorm, createRotationMatrix, createPlanckTime, createSchur, createRotate, createSylvester, createLyap } from '../factoriesAny.js';
 export var BigNumber = /* #__PURE__ */createBigNumberClass({
   config
 });
@@ -62,7 +62,8 @@ export var tau = /* #__PURE__ */createTau({
 export var _true = /* #__PURE__ */createTrue({});
 export var version = /* #__PURE__ */createVersion({});
 export var DenseMatrix = /* #__PURE__ */createDenseMatrixClass({
-  Matrix
+  Matrix,
+  config
 });
 export var efimovFactor = /* #__PURE__ */createEfimovFactor({
   BigNumber,
@@ -280,6 +281,9 @@ export var sign = /* #__PURE__ */createSign({
 export var sin = /* #__PURE__ */createSin({
   typed
 });
+export var size = /* #__PURE__ */createSize({
+  typed
+});
 export var SparseMatrix = /* #__PURE__ */createSparseMatrixClass({
   Matrix,
   equalScalar,
@@ -335,6 +339,13 @@ export var csch = /* #__PURE__ */createCsch({
   BigNumber,
   typed
 });
+export var dot = /* #__PURE__ */createDot({
+  addScalar,
+  conj,
+  multiplyScalar,
+  size,
+  typed
+});
 export var isNaN = /* #__PURE__ */createIsNaN({
   typed
 });
@@ -357,6 +368,14 @@ export var matrixFromFunction = /* #__PURE__ */createMatrixFromFunction({
   matrix,
   typed
 });
+export var multiply = /* #__PURE__ */createMultiply({
+  addScalar,
+  dot,
+  equalScalar,
+  matrix,
+  multiplyScalar,
+  typed
+});
 export var ones = /* #__PURE__ */createOnes({
   BigNumber,
   config,
@@ -497,6 +516,12 @@ export var leftShift = /* #__PURE__ */createLeftShift({
   typed,
   zeros
 });
+export var matrixFromRows = /* #__PURE__ */createMatrixFromRows({
+  flatten,
+  matrix,
+  size,
+  typed
+});
 export var mode = /* #__PURE__ */createMode({
   isNaN,
   isNumeric,
@@ -541,11 +566,6 @@ export var round = /* #__PURE__ */createRound({
   typed,
   zeros
 });
-export var size = /* #__PURE__ */createSize({
-  matrix,
-  config,
-  typed
-});
 export var smaller = /* #__PURE__ */createSmaller({
   DenseMatrix,
   SparseMatrix,
@@ -654,15 +674,6 @@ export var divideScalar = /* #__PURE__ */createDivideScalar({
   numeric,
   typed
 });
-export var dotDivide = /* #__PURE__ */createDotDivide({
-  DenseMatrix,
-  SparseMatrix,
-  concat,
-  divideScalar,
-  equalScalar,
-  matrix,
-  typed
-});
 export var equalText = /* #__PURE__ */createEqualText({
   compareText,
   isZero,
@@ -741,13 +752,6 @@ export var matrixFromColumns = /* #__PURE__ */createMatrixFromColumns({
   size,
   typed
 });
-export var max = /* #__PURE__ */createMax({
-  config,
-  isNaN,
-  larger,
-  numeric,
-  typed
-});
 export var min = /* #__PURE__ */createMin({
   config,
   isNaN,
@@ -853,6 +857,13 @@ export var usolve = /* #__PURE__ */createUsolve({
   subtractScalar,
   typed
 });
+export var zpk2tf = /* #__PURE__ */createZpk2tf({
+  Complex,
+  add,
+  multiply,
+  number,
+  typed
+});
 export var catalan = /* #__PURE__ */createCatalan({
   addScalar,
   combinations,
@@ -875,6 +886,21 @@ export var composition = /* #__PURE__ */createComposition({
   larger,
   typed
 });
+export var cross = /* #__PURE__ */createCross({
+  matrix,
+  multiply,
+  subtract,
+  typed
+});
+export var det = /* #__PURE__ */createDet({
+  divideScalar,
+  isZero,
+  matrix,
+  multiply,
+  subtractScalar,
+  typed,
+  unaryMinus
+});
 export var diff = /* #__PURE__ */createDiff({
   matrix,
   number,
@@ -891,11 +917,13 @@ export var distance = /* #__PURE__ */createDistance({
   subtractScalar,
   typed
 });
-export var dot = /* #__PURE__ */createDot({
-  addScalar,
-  conj,
-  multiplyScalar,
-  size,
+export var dotDivide = /* #__PURE__ */createDotDivide({
+  DenseMatrix,
+  SparseMatrix,
+  concat,
+  divideScalar,
+  equalScalar,
+  matrix,
   typed
 });
 export var FibonacciHeap = /* #__PURE__ */createFibonacciHeapClass({
@@ -906,6 +934,23 @@ export var index = /* #__PURE__ */createIndex({
   Index,
   typed
 });
+export var intersect = /* #__PURE__ */createIntersect({
+  abs,
+  add,
+  addScalar,
+  config,
+  divideScalar,
+  equalScalar,
+  flatten,
+  isNumeric,
+  isZero,
+  matrix,
+  multiply,
+  multiplyScalar,
+  smaller,
+  subtract,
+  typed
+});
 export var invmod = /* #__PURE__ */createInvmod({
   BigNumber,
   add,
@@ -939,18 +984,11 @@ export var lsolveAll = /* #__PURE__ */createLsolveAll({
   subtractScalar,
   typed
 });
-export var matrixFromRows = /* #__PURE__ */createMatrixFromRows({
-  flatten,
-  matrix,
-  size,
-  typed
-});
-export var multiply = /* #__PURE__ */createMultiply({
-  addScalar,
-  dot,
-  equalScalar,
-  matrix,
-  multiplyScalar,
+export var max = /* #__PURE__ */createMax({
+  config,
+  isNaN,
+  larger,
+  numeric,
   typed
 });
 export var range = /* #__PURE__ */createRange({
@@ -1035,13 +1073,6 @@ export var usolveAll = /* #__PURE__ */createUsolveAll({
   subtractScalar,
   typed
 });
-export var zpk2tf = /* #__PURE__ */createZpk2tf({
-  Complex,
-  add,
-  multiply,
-  number,
-  typed
-});
 export var and = /* #__PURE__ */createAnd({
   concat,
   equalScalar,
@@ -1065,20 +1096,10 @@ export var column = /* #__PURE__ */createColumn({
   range,
   typed
 });
-export var cross = /* #__PURE__ */createCross({
-  matrix,
-  multiply,
-  subtract,
-  typed
-});
-export var det = /* #__PURE__ */createDet({
-  divideScalar,
-  isZero,
-  matrix,
-  multiply,
-  subtractScalar,
+export var cumsum = /* #__PURE__ */createCumSum({
+  add,
   typed,
-  unaryMinus
+  unaryPlus
 });
 export var fix = /* #__PURE__ */createFix({
   Complex,
@@ -1090,6 +1111,40 @@ export var fix = /* #__PURE__ */createFix({
   typed,
   zeros
 });
+export var setDifference = /* #__PURE__ */createSetDifference({
+  DenseMatrix,
+  Index,
+  compareNatural,
+  size,
+  subset,
+  typed
+});
+export var setMultiplicity = /* #__PURE__ */createSetMultiplicity({
+  Index,
+  compareNatural,
+  size,
+  subset,
+  typed
+});
+export var setSymDifference = /* #__PURE__ */createSetSymDifference({
+  Index,
+  concat,
+  setDifference,
+  size,
+  subset,
+  typed
+});
+export var Spa = /* #__PURE__ */createSpaClass({
+  FibonacciHeap,
+  addScalar,
+  equalScalar
+});
+export var sum = /* #__PURE__ */createSum({
+  add,
+  config,
+  numeric,
+  typed
+});
 export var inv = /* #__PURE__ */createInv({
   abs,
   addScalar,
@@ -1101,6 +1156,21 @@ export var inv = /* #__PURE__ */createInv({
   typed,
   unaryMinus
 });
+export var lup = /* #__PURE__ */createLup({
+  DenseMatrix,
+  Spa,
+  SparseMatrix,
+  abs,
+  addScalar,
+  divideScalar,
+  equalScalar,
+  larger,
+  matrix,
+  multiplyScalar,
+  subtractScalar,
+  typed,
+  unaryMinus
+});
 export var pinv = /* #__PURE__ */createPinv({
   Complex,
   add,
@@ -1126,7 +1196,7 @@ export var pow = /* #__PURE__ */createPow({
   number,
   typed
 });
-export var setDifference = /* #__PURE__ */createSetDifference({
+export var setIntersect = /* #__PURE__ */createSetIntersect({
   DenseMatrix,
   Index,
   compareNatural,
@@ -1134,26 +1204,15 @@ export var setDifference = /* #__PURE__ */createSetDifference({
   subset,
   typed
 });
-export var setMultiplicity = /* #__PURE__ */createSetMultiplicity({
-  Index,
-  compareNatural,
-  size,
-  subset,
-  typed
-});
-export var setSymDifference = /* #__PURE__ */createSetSymDifference({
+export var setUnion = /* #__PURE__ */createSetUnion({
   Index,
   concat,
-  setDifference,
+  setIntersect,
+  setSymDifference,
   size,
   subset,
   typed
 });
-export var Spa = /* #__PURE__ */createSpaClass({
-  FibonacciHeap,
-  addScalar,
-  equalScalar
-});
 export var sqrtm = /* #__PURE__ */createSqrtm({
   abs,
   add,
@@ -1167,12 +1226,6 @@ export var sqrtm = /* #__PURE__ */createSqrtm({
   subtract,
   typed
 });
-export var sum = /* #__PURE__ */createSum({
-  add,
-  config,
-  numeric,
-  typed
-});
 export var Unit = /* #__PURE__ */createUnitClass({
   BigNumber,
   Complex,
@@ -1307,11 +1360,6 @@ export var ifft = /* #__PURE__ */createIfft({
   fft,
   typed
 });
-export var inverseConductanceQuantum = /* #__PURE__ */createInverseConductanceQuantum({
-  BigNumber,
-  Unit,
-  config
-});
 export var klitzing = /* #__PURE__ */createKlitzing({
   BigNumber,
   Unit,
@@ -1387,10 +1435,6 @@ export var secondRadiation = /* #__PURE__ */createSecondRadiation({
   Unit,
   config
 });
-export var setSize = /* #__PURE__ */createSetSize({
-  compareNatural,
-  typed
-});
 export var speedOfLight = /* #__PURE__ */createSpeedOfLight({
   BigNumber,
   Unit,
@@ -1448,37 +1492,19 @@ export var gravity = /* #__PURE__ */createGravity({
   Unit,
   config
 });
-export var intersect = /* #__PURE__ */createIntersect({
-  abs,
-  add,
-  addScalar,
-  config,
-  divideScalar,
-  equalScalar,
-  flatten,
-  isNumeric,
-  isZero,
-  matrix,
-  multiply,
-  multiplyScalar,
-  smaller,
-  subtract,
-  typed
+export var inverseConductanceQuantum = /* #__PURE__ */createInverseConductanceQuantum({
+  BigNumber,
+  Unit,
+  config
 });
-export var lup = /* #__PURE__ */createLup({
+export var lusolve = /* #__PURE__ */createLusolve({
   DenseMatrix,
-  Spa,
-  SparseMatrix,
-  abs,
-  addScalar,
-  divideScalar,
-  equalScalar,
-  larger,
+  lsolve,
+  lup,
   matrix,
-  multiplyScalar,
-  subtractScalar,
+  slu,
   typed,
-  unaryMinus
+  usolve
 });
 export var magneticFluxQuantum = /* #__PURE__ */createMagneticFluxQuantum({
   BigNumber,
@@ -1523,12 +1549,8 @@ export var polynomialRoot = /* #__PURE__ */createPolynomialRoot({
   typed,
   unaryMinus
 });
-export var setIntersect = /* #__PURE__ */createSetIntersect({
-  DenseMatrix,
-  Index,
+export var setSize = /* #__PURE__ */createSetSize({
   compareNatural,
-  size,
-  subset,
   typed
 });
 export var solveODE = /* #__PURE__ */createSolveODE({
@@ -1574,11 +1596,6 @@ export var bellNumbers = /* #__PURE__ */createBellNumbers({
   stirlingS2,
   typed
 });
-export var cumsum = /* #__PURE__ */createCumSum({
-  add,
-  typed,
-  unaryPlus
-});
 export var eigs = /* #__PURE__ */createEigs({
   abs,
   add,
@@ -1635,15 +1652,6 @@ export var kldivergence = /* #__PURE__ */createKldivergence({
   sum,
   typed
 });
-export var lusolve = /* #__PURE__ */createLusolve({
-  DenseMatrix,
-  lsolve,
-  lup,
-  matrix,
-  slu,
-  typed,
-  usolve
-});
 export var mean = /* #__PURE__ */createMean({
   add,
   divide,
@@ -1674,15 +1682,6 @@ export var quantileSeq = /* #__PURE__ */createQuantileSeq({
   subtract,
   typed
 });
-export var setUnion = /* #__PURE__ */createSetUnion({
-  Index,
-  concat,
-  setIntersect,
-  setSymDifference,
-  size,
-  subset,
-  typed
-});
 export var variance = /* #__PURE__ */createVariance({
   add,
   divide,

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

@@ -212,8 +212,6 @@ export var sin = /* #__PURE__ */createSin({
   typed
 });
 export var size = /* #__PURE__ */createSize({
-  matrix,
-  config,
   typed
 });
 export var smallerEq = /* #__PURE__ */createSmallerEq({

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

@@ -79,7 +79,7 @@ export var createIndexNode = /* #__PURE__ */factory(name, dependencies, _ref =>
             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 s = size(context);
             var childArgs = Object.create(args);
             childArgs.end = s[i];
             return _evalDimension(scope, childArgs, context);

package/lib/esm/expression/parse.js

@@ -322,7 +322,7 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
         next(state);
         state.token += currentCharacter(state);
         next(state);
-        while (parse.isHexDigit(currentCharacter(state))) {
+        while (parse.isAlpha(currentCharacter(state), prevCharacter(state), nextCharacter(state)) || parse.isDigit(currentCharacter(state))) {
           state.token += currentCharacter(state);
           next(state);
         }
@@ -331,7 +331,7 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
           state.token += '.';
           next(state);
           // get the digits after the radix
-          while (parse.isHexDigit(currentCharacter(state))) {
+          while (parse.isAlpha(currentCharacter(state), prevCharacter(state), nextCharacter(state)) || parse.isDigit(currentCharacter(state))) {
             state.token += currentCharacter(state);
             next(state);
           }
@@ -537,15 +537,6 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
     return c >= '0' && c <= '9';
   };
 
-  /**
-   * checks if the given char c is a hex digit
-   * @param {string} c   a string with one character
-   * @return {boolean}
-   */
-  parse.isHexDigit = function isHexDigit(c) {
-    return c >= '0' && c <= '9' || c >= 'a' && c <= 'f' || c >= 'A' && c <= 'F';
-  };
-
   /**
    * Start of the parse levels below, in order of precedence
    * @return {Node} node
@@ -934,7 +925,7 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
    */
   function parseAddSubtract(state) {
     var node, name, fn, params;
-    node = parseMultiplyDivideModulusPercentage(state);
+    node = parseMultiplyDivideModulus(state);
     var operators = {
       '+': 'add',
       '-': 'subtract'
@@ -943,7 +934,7 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
       name = state.token;
       fn = operators[name];
       getTokenSkipNewline(state);
-      var rightNode = parseMultiplyDivideModulusPercentage(state);
+      var rightNode = parseMultiplyDivideModulus(state);
       if (rightNode.isPercentage) {
         params = [node, new OperatorNode('*', 'multiply', [node, rightNode])];
       } else {
@@ -955,11 +946,11 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
   }
 
   /**
-   * multiply, divide, modulus, percentage
+   * multiply, divide, modulus
    * @return {Node} node
    * @private
    */
-  function parseMultiplyDivideModulusPercentage(state) {
+  function parseMultiplyDivideModulus(state) {
     var node, last, name, fn;
     node = parseImplicitMultiplication(state);
     last = node;
@@ -977,23 +968,8 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
         name = state.token;
         fn = operators[name];
         getTokenSkipNewline(state);
-        if (name === '%' && state.tokenType === TOKENTYPE.DELIMITER && state.token !== '(') {
-          // If the expression contains only %, then treat that as /100
-          if (state.token !== '' && operators[state.token]) {
-            var left = new OperatorNode('/', 'divide', [node, new ConstantNode(100)], false, true);
-            name = state.token;
-            fn = operators[name];
-            getTokenSkipNewline(state);
-            last = parseImplicitMultiplication(state);
-            node = new OperatorNode(name, fn, [left, last]);
-          } else {
-            node = new OperatorNode('/', 'divide', [node, new ConstantNode(100)], false, true);
-          }
-          // return node
-        } else {
-          last = parseImplicitMultiplication(state);
-          node = new OperatorNode(name, fn, [node, last]);
-        }
+        last = parseImplicitMultiplication(state);
+        node = new OperatorNode(name, fn, [node, last]);
       } else {
         break;
       }
@@ -1036,7 +1012,7 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @private
    */
   function parseRule2(state) {
-    var node = parseUnary(state);
+    var node = parseUnaryPercentage(state);
     var last = node;
     var tokenStates = [];
     while (true) {
@@ -1058,7 +1034,7 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
             // Rewind once and build the "number / number" node; the symbol will be consumed later
             _extends(state, tokenStates.pop());
             tokenStates.pop();
-            last = parseUnary(state);
+            last = parseUnaryPercentage(state);
             node = new OperatorNode('/', 'divide', [node, last]);
           } else {
             // Not a match, so rewind
@@ -1078,6 +1054,34 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
     return node;
   }
 
+  /**
+   * Unary percentage operator (treated as `value / 100`)
+   * @return {Node} node
+   * @private
+   */
+  function parseUnaryPercentage(state) {
+    var node = parseUnary(state);
+    if (state.token === '%') {
+      var previousState = _extends({}, state);
+      getTokenSkipNewline(state);
+      // We need to decide if this is a unary percentage % or binary modulo %
+      // So we attempt to parse a unary expression at this point.
+      // If it fails, then the only possibility is that this is a unary percentage.
+      // If it succeeds, then we presume that this must be binary modulo, since the
+      // only things that parseUnary can handle are _higher_ precedence than unary %.
+      try {
+        parseUnary(state);
+        // Not sure if we could somehow use the result of that parseUnary? Without
+        // further analysis/testing, safer just to discard and let the parse proceed
+        _extends(state, previousState);
+      } catch (_unused) {
+        // Not seeing a term at this point, so was a unary %
+        node = new OperatorNode('/', 'divide', [node, new ConstantNode(100)], false, true);
+      }
+    }
+    return node;
+  }
+
   /**
    * Unary plus and minus, and logical and bitwise not
    * @return {Node} node

package/lib/esm/function/algebra/sylvester.js

@@ -17,7 +17,8 @@ export var createSylvester = /* #__PURE__ */factory(name, dependencies, _ref =>
     subtract,
     identity,
     lusolve,
-    abs
+    abs,
+    config
   } = _ref;
   /**
    *
@@ -88,7 +89,7 @@ export var createSylvester = /* #__PURE__ */factory(name, dependencies, _ref =>
     var vc = (a, b) => concat(a, b, 0);
     for (var k = 0; k < n; k++) {
       if (k < n - 1 && abs(subset(G, index(k + 1, k))) > 1e-5) {
-        var RHS = vc(subset(D, index(all, k)), subset(D, index(all, k + 1)));
+        var RHS = vc(subset(D, index(all, [k])), subset(D, index(all, [k + 1])));
         for (var j = 0; j < k; j++) {
           RHS = add(RHS, vc(multiply(y[j], subset(G, index(j, k))), multiply(y[j], subset(G, index(j, k + 1)))));
         }
@@ -98,11 +99,11 @@ export var createSylvester = /* #__PURE__ */factory(name, dependencies, _ref =>
         var gmm = multiply(identity(m), multiply(-1, subset(G, index(k + 1, k + 1))));
         var LHS = vc(hc(add(F, gkk), gmk), hc(gkm, add(F, gmm)));
         var yAux = lusolve(LHS, RHS);
-        y[k] = yAux.subset(index(range(0, m), 0));
-        y[k + 1] = yAux.subset(index(range(m, 2 * m), 0));
+        y[k] = yAux.subset(index(range(0, m), [0]));
+        y[k + 1] = yAux.subset(index(range(m, 2 * m), [0]));
         k++;
       } else {
-        var _RHS = subset(D, index(all, k));
+        var _RHS = subset(D, index(all, [k]));
         for (var _j = 0; _j < k; _j++) {
           _RHS = add(_RHS, multiply(y[_j], subset(G, index(_j, k))));
         }