mathjs 11.9.0 → 11.10.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, 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, createMode, createNumeric, createProd, createReshape, createSize, createSqueeze, createSubset, createTranspose, createXgcd, createZeros, createAsin, createCbrt, createConcat, createCount, createCtranspose, createDiag, createDivideScalar, createDotDivide, createEqual, createFlatten, createGcd, createHasNumericValue, createIdentity, createKron, createLargerEq, createLeftShift, createMatrixFromColumns, createMod, createNthRoot, createOnes, createResize, createRightArithShift, createRound, createSmaller, createTo, createUnequal, createXor, createAdd, createBitAnd, createBitXor, createCatalan, createCompare, createCompareText, createCumSum, createDeepEqual, createDot, createEqualText, createFloor, createHypot, createImmutableDenseMatrixClass, createIndexClass, createInvmod, createLarger, createLog, createMatrixFromRows, createMin, createMultiply, createNthRoots, createOr, createPartitionSelect, createQuantileSeq, createRightLogShift, createSmallerEq, createSubtract, createTrace, createUsolve, createZpk2tf, createAnd, createBitOr, createCeil, createCompareNatural, createComposition, createCross, createDet, createDiff, createDistance, createDotMultiply, createFibonacciHeapClass, createFix, createIndex, createIntersect, createLcm, createLog1p, createLsolve, createMax, createQr, createRange, createRow, createSetCartesian, createSetDistinct, createSetIsSubset, createSetPowerset, createSlu, createSort, createSum, createUsolveAll, createAtan2, createColumn, createLsolveAll, createSetDifference, createSetMultiplicity, createSetSymDifference, createSpaClass, createInv, createLup, createPinv, createPow, createSetIntersect, createSetUnion, createSqrtm, createUnitClass, createVacuumImpedance, createWienDisplacement, createAtomicMass, createBohrMagneton, createBoltzmann, createConductanceQuantum, createCreateUnit, createDeuteronMass, createDotPow, createElectricConstant, createElementaryCharge, createExpm, createFaraday, createFft, createGamma, createGravitationConstant, createHartreeEnergy, createIfft, createKlitzing, createLoschmidt, createMagneticConstant, createMolarMass, createMolarPlanckConstant, createNeutronMass, createNuclearMagneton, createPlanckCharge, createPlanckLength, createPlanckTemperature, createProtonMass, createReducedPlanckConstant, createRydberg, createSecondRadiation, createSpeedOfLight, createStefanBoltzmann, createThomsonCrossSection, createAvogadro, createBohrRadius, createCoulomb, createDivide, createElectronMass, createFactorial, createFirstRadiation, createGravity, createInverseConductanceQuantum, createLusolve, createMagneticFluxQuantum, createMolarMassC12, createMultinomial, createPermutations, createPlanckMass, createPolynomialRoot, createSetSize, createSolveODE, createStirlingS2, createUnitFunction, createBellNumbers, createEigs, createFermiCoupling, createGasConstant, createMean, createMolarVolume, createPlanckConstant, createQuantumOfCirculation, createVariance, createClassicalElectronRadius, createMedian, createKldivergence, createMad, createStd, createFreqz, createNorm, createRotationMatrix, createPlanckTime, createSchur, createRotate, createSylvester, createLyap } 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, createMode, createNumeric, createProd, createReshape, createSize, createSqueeze, createTranspose, createXgcd, createZeros, createAsin, createCbrt, createConcat, createCount, createCtranspose, createDiag, createDivideScalar, createDotDivide, createEqual, createFlatten, createGcd, createHasNumericValue, createIdentity, createKron, createLargerEq, createLeftShift, createMatrixFromColumns, createMod, createNthRoot, createOnes, createResize, createRightArithShift, createRound, createSmaller, createSubtract, createTo, createUnequal, createUsolve, createXor, createAdd, createAtan2, createBitAnd, createBitXor, createCatalan, createCompare, createCompareText, createCumSum, createDeepEqual, createDiff, createDistance, createDot, createEqualText, createFloor, createHypot, createImmutableDenseMatrixClass, createIndexClass, createInvmod, createLarger, createLog, createLsolve, createMatrixFromRows, createMin, createMultiply, createNthRoots, createOr, createPartitionSelect, createQr, createRightLogShift, createSlu, createSubset, createSum, createTrace, createUsolveAll, createZpk2tf, createBitOr, createCeil, createCompareNatural, createComposition, createCross, createDet, createDotMultiply, createFibonacciHeapClass, createFix, createIndex, createIntersect, createLcm, createLog1p, createLsolveAll, createMax, createQuantileSeq, createSetCartesian, createSetDistinct, createSetIsSubset, createSetPowerset, createSmallerEq, createSort, createAnd, createRange, createRow, createSetDifference, createSetMultiplicity, createSetSymDifference, createSpaClass, createColumn, createInv, createLup, createPinv, createPow, createSetIntersect, createSetUnion, createSqrtm, createUnitClass, createVacuumImpedance, createWienDisplacement, createAtomicMass, createBohrMagneton, createBoltzmann, createConductanceQuantum, createCreateUnit, createDeuteronMass, createDotPow, createElectricConstant, createElementaryCharge, createExpm, createFaraday, createFft, createGamma, createGravitationConstant, createHartreeEnergy, createIfft, createKlitzing, createLoschmidt, createMagneticConstant, createMolarMass, createMolarPlanckConstant, createNeutronMass, createNuclearMagneton, createPlanckCharge, createPlanckLength, createPlanckTemperature, createProtonMass, createReducedPlanckConstant, createRydberg, createSecondRadiation, createSpeedOfLight, createStefanBoltzmann, createThomsonCrossSection, createAvogadro, createBohrRadius, createCoulomb, createDivide, createElectronMass, createFactorial, createFirstRadiation, createGravity, createInverseConductanceQuantum, createLusolve, createMagneticFluxQuantum, createMolarMassC12, createMultinomial, createPermutations, createPlanckMass, createPolynomialRoot, createSetSize, createSolveODE, createStirlingS2, createUnitFunction, createBellNumbers, createEigs, createFermiCoupling, createGasConstant, createMean, createMolarVolume, createPlanckConstant, createQuantumOfCirculation, createVariance, createClassicalElectronRadius, createMedian, createKldivergence, createMad, createStd, createZeta, createFreqz, createNorm, createRotationMatrix, createPlanckTime, createSchur, createRotate, createSylvester, createLyap } from '../factoriesAny.js';
 export var BigNumber = /* #__PURE__ */createBigNumberClass({
   config
 });
@@ -423,10 +423,6 @@ export var squeeze = /* #__PURE__ */createSqueeze({
   matrix,
   typed
 });
-export var subset = /* #__PURE__ */createSubset({
-  matrix,
-  typed
-});
 export var transpose = /* #__PURE__ */createTranspose({
   matrix,
   typed
@@ -595,6 +591,15 @@ export var smaller = /* #__PURE__ */createSmaller({
   matrix,
   typed
 });
+export var subtract = /* #__PURE__ */createSubtract({
+  DenseMatrix,
+  addScalar,
+  concat,
+  equalScalar,
+  matrix,
+  typed,
+  unaryMinus
+});
 export var to = /* #__PURE__ */createTo({
   concat,
   matrix,
@@ -608,6 +613,15 @@ export var unequal = /* #__PURE__ */createUnequal({
   matrix,
   typed
 });
+export var usolve = /* #__PURE__ */createUsolve({
+  DenseMatrix,
+  divideScalar,
+  equalScalar,
+  matrix,
+  multiplyScalar,
+  subtract,
+  typed
+});
 export var xor = /* #__PURE__ */createXor({
   DenseMatrix,
   concat,
@@ -623,6 +637,14 @@ export var add = /* #__PURE__ */createAdd({
   matrix,
   typed
 });
+export var atan2 = /* #__PURE__ */createAtan2({
+  BigNumber,
+  DenseMatrix,
+  concat,
+  equalScalar,
+  matrix,
+  typed
+});
 export var bitAnd = /* #__PURE__ */createBitAnd({
   concat,
   equalScalar,
@@ -668,6 +690,22 @@ export var deepEqual = /* #__PURE__ */createDeepEqual({
   equal,
   typed
 });
+export var diff = /* #__PURE__ */createDiff({
+  matrix,
+  number,
+  subtract,
+  typed
+});
+export var distance = /* #__PURE__ */createDistance({
+  abs,
+  addScalar,
+  deepEqual,
+  divideScalar,
+  multiplyScalar,
+  sqrt,
+  subtract,
+  typed
+});
 export var dot = /* #__PURE__ */createDot({
   addScalar,
   conj,
@@ -704,7 +742,8 @@ export var ImmutableDenseMatrix = /* #__PURE__ */createImmutableDenseMatrixClass
   smaller
 });
 export var Index = /* #__PURE__ */createIndexClass({
-  ImmutableDenseMatrix
+  ImmutableDenseMatrix,
+  getMatrixDataType
 });
 export var invmod = /* #__PURE__ */createInvmod({
   BigNumber,
@@ -730,6 +769,15 @@ export var log = /* #__PURE__ */createLog({
   divideScalar,
   typed
 });
+export var lsolve = /* #__PURE__ */createLsolve({
+  DenseMatrix,
+  divideScalar,
+  equalScalar,
+  matrix,
+  multiplyScalar,
+  subtract,
+  typed
+});
 export var matrixFromRows = /* #__PURE__ */createMatrixFromRows({
   flatten,
   matrix,
@@ -769,12 +817,22 @@ export var partitionSelect = /* #__PURE__ */createPartitionSelect({
   isNumeric,
   typed
 });
-export var quantileSeq = /* #__PURE__ */createQuantileSeq({
-  add,
-  compare,
-  multiply,
-  partitionSelect,
-  typed
+export var qr = /* #__PURE__ */createQr({
+  addScalar,
+  complex,
+  conj,
+  divideScalar,
+  equal,
+  identity,
+  isZero,
+  matrix,
+  multiplyScalar,
+  sign,
+  sqrt,
+  subtract,
+  typed,
+  unaryMinus,
+  zeros
 });
 export var rightLogShift = /* #__PURE__ */createRightLogShift({
   DenseMatrix,
@@ -784,28 +842,36 @@ export var rightLogShift = /* #__PURE__ */createRightLogShift({
   typed,
   zeros
 });
-export var smallerEq = /* #__PURE__ */createSmallerEq({
-  DenseMatrix,
-  concat,
-  config,
-  matrix,
+export var slu = /* #__PURE__ */createSlu({
+  SparseMatrix,
+  abs,
+  add,
+  divideScalar,
+  larger,
+  largerEq,
+  multiply,
+  subtract,
+  transpose,
   typed
 });
-export var subtract = /* #__PURE__ */createSubtract({
-  DenseMatrix,
-  addScalar,
-  concat,
-  equalScalar,
+export var subset = /* #__PURE__ */createSubset({
+  add,
   matrix,
   typed,
-  unaryMinus
+  zeros
+});
+export var sum = /* #__PURE__ */createSum({
+  add,
+  config,
+  numeric,
+  typed
 });
 export var trace = /* #__PURE__ */createTrace({
   add,
   matrix,
   typed
 });
-export var usolve = /* #__PURE__ */createUsolve({
+export var usolveAll = /* #__PURE__ */createUsolveAll({
   DenseMatrix,
   divideScalar,
   equalScalar,
@@ -821,14 +887,6 @@ export var zpk2tf = /* #__PURE__ */createZpk2tf({
   number,
   typed
 });
-export var and = /* #__PURE__ */createAnd({
-  concat,
-  equalScalar,
-  matrix,
-  not,
-  typed,
-  zeros
-});
 export var bitOr = /* #__PURE__ */createBitOr({
   DenseMatrix,
   concat,
@@ -873,22 +931,6 @@ export var det = /* #__PURE__ */createDet({
   typed,
   unaryMinus
 });
-export var diff = /* #__PURE__ */createDiff({
-  matrix,
-  number,
-  subtract,
-  typed
-});
-export var distance = /* #__PURE__ */createDistance({
-  abs,
-  addScalar,
-  deepEqual,
-  divideScalar,
-  multiplyScalar,
-  sqrt,
-  subtract,
-  typed
-});
 export var dotMultiply = /* #__PURE__ */createDotMultiply({
   concat,
   equalScalar,
@@ -944,7 +986,7 @@ export var log1p = /* #__PURE__ */createLog1p({
   log,
   typed
 });
-export var lsolve = /* #__PURE__ */createLsolve({
+export var lsolveAll = /* #__PURE__ */createLsolveAll({
   DenseMatrix,
   divideScalar,
   equalScalar,
@@ -959,39 +1001,12 @@ export var max = /* #__PURE__ */createMax({
   numeric,
   typed
 });
-export var qr = /* #__PURE__ */createQr({
-  addScalar,
-  complex,
-  conj,
-  divideScalar,
-  equal,
-  identity,
-  isZero,
-  matrix,
-  multiplyScalar,
-  sign,
-  sqrt,
-  subtract,
-  typed,
-  unaryMinus,
-  zeros
-});
-export var range = /* #__PURE__ */createRange({
-  bignumber,
-  matrix,
+export var quantileSeq = /* #__PURE__ */createQuantileSeq({
   add,
-  config,
-  isPositive,
-  larger,
-  largerEq,
-  smaller,
-  smallerEq,
-  typed
-});
-export var row = /* #__PURE__ */createRow({
-  Index,
-  matrix,
-  range,
+  compare,
+  isInteger,
+  multiply,
+  partitionSelect,
   typed
 });
 export var setCartesian = /* #__PURE__ */createSetCartesian({
@@ -1024,16 +1039,11 @@ export var setPowerset = /* #__PURE__ */createSetPowerset({
   subset,
   typed
 });
-export var slu = /* #__PURE__ */createSlu({
-  SparseMatrix,
-  abs,
-  add,
-  divideScalar,
-  larger,
-  largerEq,
-  multiply,
-  subtract,
-  transpose,
+export var smallerEq = /* #__PURE__ */createSmallerEq({
+  DenseMatrix,
+  concat,
+  config,
+  matrix,
   typed
 });
 export var sort = /* #__PURE__ */createSort({
@@ -1042,44 +1052,32 @@ export var sort = /* #__PURE__ */createSort({
   matrix,
   typed
 });
-export var sum = /* #__PURE__ */createSum({
-  add,
-  config,
-  numeric,
-  typed
-});
-export var usolveAll = /* #__PURE__ */createUsolveAll({
-  DenseMatrix,
-  divideScalar,
+export var and = /* #__PURE__ */createAnd({
+  concat,
   equalScalar,
   matrix,
-  multiplyScalar,
-  subtract,
-  typed
+  not,
+  typed,
+  zeros
 });
-export var atan2 = /* #__PURE__ */createAtan2({
-  BigNumber,
-  DenseMatrix,
-  concat,
-  equalScalar,
+export var range = /* #__PURE__ */createRange({
+  bignumber,
   matrix,
+  add,
+  config,
+  isPositive,
+  larger,
+  largerEq,
+  smaller,
+  smallerEq,
   typed
 });
-export var column = /* #__PURE__ */createColumn({
+export var row = /* #__PURE__ */createRow({
   Index,
   matrix,
   range,
   typed
 });
-export var lsolveAll = /* #__PURE__ */createLsolveAll({
-  DenseMatrix,
-  divideScalar,
-  equalScalar,
-  matrix,
-  multiplyScalar,
-  subtract,
-  typed
-});
 export var setDifference = /* #__PURE__ */createSetDifference({
   DenseMatrix,
   Index,
@@ -1108,6 +1106,12 @@ export var Spa = /* #__PURE__ */createSpaClass({
   addScalar,
   equalScalar
 });
+export var column = /* #__PURE__ */createColumn({
+  Index,
+  matrix,
+  range,
+  typed
+});
 export var inv = /* #__PURE__ */createInv({
   abs,
   addScalar,
@@ -1655,6 +1659,24 @@ export var std = /* #__PURE__ */createStd({
   typed,
   variance
 });
+export var zeta = /* #__PURE__ */createZeta({
+  BigNumber,
+  Complex,
+  add,
+  config,
+  divide,
+  equal,
+  factorial,
+  gamma,
+  isNegative,
+  multiply,
+  pi,
+  pow,
+  sin,
+  smallerEq,
+  subtract,
+  typed
+});
 export var freqz = /* #__PURE__ */createFreqz({
   Complex,
   add,

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

@@ -5,7 +5,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, 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';
+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, createZeta, 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
 });
@@ -378,6 +378,7 @@ export var print = /* #__PURE__ */createPrint({
 export var quantileSeq = /* #__PURE__ */createQuantileSeq({
   add,
   compare,
+  isInteger,
   multiply,
   partitionSelect,
   typed
@@ -413,6 +414,22 @@ export var variance = /* #__PURE__ */createVariance({
   subtract,
   typed
 });
+export var zeta = /* #__PURE__ */createZeta({
+  add,
+  config,
+  divide,
+  equal,
+  factorial,
+  gamma,
+  isNegative,
+  multiply,
+  pi,
+  pow,
+  sin,
+  smallerEq,
+  subtract,
+  typed
+});
 export var acsch = /* #__PURE__ */createAcsch({
   typed
 });

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[1:2, 1:2] = ones(2, 2)'],
+  examples: ['A = [1, 2, 3; 4, 5, 6]', 'A[1, :]', 'A[1, 2] = 50', 'A[1:2, 1:2] = 1', 'B = [1, 2, 3]', 'B[B>1 and B<3]'],
   seealso: ['bignumber', 'boolean', 'complex', 'matrix,', 'number', 'range', 'string', 'unit']
 };

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

@@ -184,6 +184,7 @@ import { setUnionDocs } from './function/set/setUnion.js';
 import { zpk2tfDocs } from './function/signal/zpk2tf.js';
 import { freqzDocs } from './function/signal/freqz.js';
 import { erfDocs } from './function/special/erf.js';
+import { zetaDocs } from './function/special/zeta.js';
 import { madDocs } from './function/statistics/mad.js';
 import { maxDocs } from './function/statistics/max.js';
 import { meanDocs } from './function/statistics/mean.js';
@@ -653,6 +654,7 @@ export var embeddedDocs = {
   freqz: freqzDocs,
   // functions - special
   erf: erfDocs,
+  zeta: zetaDocs,
   // functions - statistics
   cumsum: cumSumDocs,
   mad: madDocs,

package/lib/esm/expression/embeddedDocs/function/special/zeta.js

@@ -0,0 +1,8 @@
+export var zetaDocs = {
+  name: 'zeta',
+  category: 'Special',
+  syntax: ['zeta(s)'],
+  description: 'Compute the Riemann Zeta Function using an infinite series and Riemanns Functional Equation for the entire complex plane',
+  examples: ['zeta(0.2)', 'zeta(-0.5)', 'zeta(4)'],
+  seealso: []
+};

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

@@ -2,7 +2,7 @@ import _defineProperty from "@babel/runtime/helpers/defineProperty";
 import { isAccessorNode, isFunctionAssignmentNode, isIndexNode, isNode, isSymbolNode } from '../../utils/is.js';
 import { escape, format } from '../../utils/string.js';
 import { hasOwnProperty } from '../../utils/object.js';
-import { getSafeProperty, validateSafeMethod } from '../../utils/customs.js';
+import { getSafeProperty, getSafeMethod } from '../../utils/customs.js';
 import { createSubScope } from '../../utils/scope.js';
 import { factory } from '../../utils/factory.js';
 import { defaultTemplate, latexFunctions } from '../../utils/latex.js';
@@ -203,7 +203,7 @@ export var createFunctionNode = /* #__PURE__ */factory(name, dependencies, _ref
           // the function symbol is an argName
           var _rawArgs = this.args;
           return function evalFunctionNode(scope, args, context) {
-            var fn = args[_name];
+            var fn = getSafeProperty(args, _name);
             if (typeof fn !== 'function') {
               throw new TypeError("Argument '".concat(_name, "' was not a function; received: ").concat(strin(fn)));
             }
@@ -225,15 +225,14 @@ export var createFunctionNode = /* #__PURE__ */factory(name, dependencies, _ref
         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) {
+          var fn = getSafeMethod(object, prop);
+          if (fn !== null && fn !== void 0 && fn.rawArgs) {
             // "Raw" evaluation
-            return object[prop](_rawArgs2, math, createSubScope(scope, args), scope);
+            return fn(_rawArgs2, math, createSubScope(scope, args), scope);
           } else {
             // "regular" evaluation
             var values = evalArgs.map(evalArg => evalArg(scope, args, context));
-            return object[prop].apply(object, values);
+            return fn.apply(object, values);
           }
         };
       } else {

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

@@ -1,9 +1,9 @@
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import { getSafeProperty } from '../../utils/customs.js';
+import { factory } from '../../utils/factory.js';
 import { isNode } from '../../utils/is.js';
-import { escape, stringify } from '../../utils/string.js';
-import { isSafeProperty } from '../../utils/customs.js';
 import { hasOwnProperty } from '../../utils/object.js';
-import { factory } from '../../utils/factory.js';
+import { escape, stringify } from '../../utils/string.js';
 var name = 'ObjectNode';
 var dependencies = ['Node'];
 export var createObjectNode = /* #__PURE__ */factory(name, dependencies, _ref => {
@@ -58,10 +58,8 @@ export var createObjectNode = /* #__PURE__ */factory(name, dependencies, _ref =>
           // so you cannot create a key like {"co\\u006Estructor": null}
           var stringifiedKey = stringify(key);
           var parsedKey = JSON.parse(stringifiedKey);
-          if (!isSafeProperty(this.properties, parsedKey)) {
-            throw new Error('No access to property "' + parsedKey + '"');
-          }
-          evalEntries[parsedKey] = this.properties[key]._compile(math, argNames);
+          var prop = getSafeProperty(this.properties, key);
+          evalEntries[parsedKey] = prop._compile(math, argNames);
         }
       }
       return function evalObjectNode(scope, args, context) {

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

@@ -61,7 +61,7 @@ export var createSymbolNode = /* #__PURE__ */factory(name, dependencies, _ref =>
         // (like an x when inside the expression of a function
         // assignment `f(x) = ...`)
         return function (scope, args, context) {
-          return args[name];
+          return getSafeProperty(args, name);
         };
       } else if (name in math) {
         return function (scope, args, context) {

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

@@ -22,8 +22,13 @@ export function assignFactory(_ref) {
   return function assign(object, index, value) {
     try {
       if (Array.isArray(object)) {
-        // we use matrix.subset here instead of the function subset because we must not clone the contents
-        return matrix(object).subset(index, value).valueOf();
+        var result = matrix(object).subset(index, value).valueOf();
+
+        // shallow copy all (updated) items into the original array
+        result.forEach((item, index) => {
+          object[index] = item;
+        });
+        return object;
       } else if (object && typeof object.subset === 'function') {
         // Matrix
         return object.subset(index, value);

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

@@ -1,10 +1,11 @@
 import { isArray, isBigNumber, isMatrix, isNumber, isRange } from '../../utils/is.js';
 import { factory } from '../../utils/factory.js';
 var name = 'index';
-var dependencies = ['Index'];
+var dependencies = ['Index', 'getMatrixDataType'];
 export var createIndexTransform = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
-    Index
+    Index,
+    getMatrixDataType
   } = _ref;
   /**
    * Attach a transform function to math.index
@@ -17,7 +18,7 @@ export var createIndexTransform = /* #__PURE__ */factory(name, dependencies, _re
     for (var i = 0, ii = arguments.length; i < ii; i++) {
       var arg = arguments[i];
 
-      // change from one-based to zero based, and convert BigNumber to number
+      // change from one-based to zero based, convert BigNumber to number and leave Array of Booleans as is
       if (isRange(arg)) {
         arg.start--;
         arg.end -= arg.step > 0 ? 0 : 2;
@@ -26,9 +27,11 @@ export var createIndexTransform = /* #__PURE__ */factory(name, dependencies, _re
           return v - 1;
         });
       } else if (isArray(arg) || isMatrix(arg)) {
-        arg = arg.map(function (v) {
-          return v - 1;
-        });
+        if (getMatrixDataType(arg) !== 'boolean') {
+          arg = arg.map(function (v) {
+            return v - 1;
+          });
+        }
       } else if (isNumber(arg)) {
         arg--;
       } else if (isBigNumber(arg)) {

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

@@ -0,0 +1,41 @@
+import { factory } from '../../utils/factory.js';
+import { createQuantileSeq } from '../../function/statistics/quantileSeq.js';
+import { lastDimToZeroBase } from './utils/lastDimToZeroBase.js';
+var name = 'quantileSeq';
+var dependencies = ['typed', 'add', 'multiply', 'partitionSelect', 'compare', 'isInteger'];
+
+/**
+ * Attach a transform function to math.quantileSeq
+ * Adds a property transform containing the transform function.
+ *
+ * This transform changed the `dim` parameter of function std
+ * from one-based to zero based
+ */
+export var createQuantileSeqTransform = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    add,
+    multiply,
+    partitionSelect,
+    compare,
+    isInteger
+  } = _ref;
+  var quantileSeq = createQuantileSeq({
+    typed,
+    add,
+    multiply,
+    partitionSelect,
+    compare,
+    isInteger
+  });
+  return typed('quantileSeq', {
+    'Array|Matrix, number|BigNumber|Array, number': (arr, prob, dim) => quantileSeq(arr, prob, dimToZeroBase(dim)),
+    'Array|Matrix, number|BigNumber|Array, boolean, number': (arr, prob, sorted, dim) => quantileSeq(arr, prob, sorted, dimToZeroBase(dim))
+  });
+  function dimToZeroBase(dim) {
+    // TODO: find a better way, maybe lastDimToZeroBase could apply to more cases.
+    return lastDimToZeroBase([[], dim])[1];
+  }
+}, {
+  isTransformFunction: true
+});