mathjs 13.0.2 → 13.1.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, 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, createTypeOf, createAcosh, createAcsch, createApply, createAsec, createBignumber, createCombinationsWithRep, createCosh, createCsch, createIsNaN, createIsPrime, createRandomInt, createSech, createSinh, createSparse, createSqrt, createTanh, createUnaryMinus, createAcoth, createBin, createCoth, createFraction, createIsNumeric, createMatrix, createMatrixFromFunction, createMode, createNumeric, createProd, createReshape, createSize, createSqueeze, createTranspose, createXgcd, createZeros, createAsin, createCbrt, createConcat, createCount, createCtranspose, createDiag, createDivideScalar, createDotDivide, createEqual, createFlatten, createHasNumericValue, createIdentity, createKron, createLargerEq, createLeftShift, createLsolve, createMatrixFromColumns, createNthRoot, createOnes, createQr, createResize, createRightArithShift, createRound, createSmaller, createSubtract, createTo, createUnaryPlus, createUsolve, createXor, createAdd, createAtan2, createBitAnd, createBitOr, createBitXor, createCatalan, createCompare, createCompareText, createCumSum, createDeepEqual, createDiff, createDistance, createDot, createEqualText, createFloor, createGcd, createHypot, createImmutableDenseMatrixClass, createIndexClass, createLarger, createLog, createLsolveAll, createMatrixFromRows, createMin, createMod, createMultiply, createNthRoots, createOr, createPartitionSelect, createRightLogShift, createSlu, createSubset, createSum, createTrace, createUsolveAll, createZpk2tf, createCeil, createCompareNatural, createComposition, createCross, createDet, createDotMultiply, createFibonacciHeapClass, createFix, createIndex, createIntersect, createInvmod, createLcm, createLog1p, createMax, createSetCartesian, createSetDistinct, createSetIsSubset, createSetPowerset, createSmallerEq, createSort, createUnequal, createAnd, createRange, createRow, createSetDifference, createSetMultiplicity, createSetSymDifference, createSpaClass, createColumn, createInv, createLup, createPinv, createPow, createSetIntersect, createSetUnion, createSqrtm, createUnitClass, createVacuumImpedance, createWienDisplacement, createAtomicMass, createBohrMagneton, createBoltzmann, createConductanceQuantum, createCoulomb, 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, createCreateUnit, 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';
+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, createTypeOf, createAcosh, createAcsch, createApply, createAsec, createBignumber, createCombinationsWithRep, createCosh, createCsch, createIsNaN, createIsPrime, createRandomInt, createSech, createSinh, createSparse, createSqrt, createSqueeze, createTanh, createUnaryMinus, createAcoth, createBin, createCoth, createFraction, createIsNumeric, createMatrix, createMatrixFromFunction, createMode, createNumeric, createProd, createReshape, createSize, createTranspose, createXgcd, createZeros, createAsin, createCbrt, createConcat, createCount, createCtranspose, createDiag, createDivideScalar, createDotDivide, createEqual, createHasNumericValue, createIdentity, createKron, createLargerEq, createLeftShift, createLsolve, createMatrixFromColumns, createNthRoot, createOnes, createQr, createResize, createRightArithShift, createRound, createSmaller, createSubtract, createTo, createUnaryPlus, createUsolve, createXor, createAdd, createAtan2, createBitAnd, createBitOr, createBitXor, createCatalan, createCompare, createCompareText, createCumSum, createDeepEqual, createDiff, createDistance, createDot, createEqualText, createFloor, createGcd, createHypot, createImmutableDenseMatrixClass, createIndexClass, createLarger, createLog, createLsolveAll, createMatrixFromRows, createMin, createMod, createMultiply, createNthRoots, createOr, createPartitionSelect, createRightLogShift, createSlu, createSubset, createSum, createTrace, createUsolveAll, createZpk2tf, createCeil, createCompareNatural, createComposition, createCross, createDet, createDotMultiply, createFibonacciHeapClass, createFix, createIndex, createIntersect, createInvmod, createLcm, createLog1p, createMax, createSetCartesian, createSetDistinct, createSetIsSubset, createSetPowerset, createSmallerEq, createSort, createUnequal, createAnd, createRange, createRow, createSetDifference, createSetMultiplicity, createSetSymDifference, createSpaClass, createColumn, createInv, createLup, createPinv, createPow, createSetIntersect, createSetUnion, createSqrtm, createUnitClass, createVacuumImpedance, createWienDisplacement, createAtomicMass, createBohrMagneton, createBoltzmann, createConductanceQuantum, createCoulomb, 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, createCreateUnit, 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
 });
@@ -185,6 +185,9 @@ export var expm1 = /* #__PURE__ */createExpm1({
 export var filter = /* #__PURE__ */createFilter({
   typed
 });
+export var flatten = /* #__PURE__ */createFlatten({
+  typed
+});
 export var forEach = /* #__PURE__ */createForEach({
   typed
 });
@@ -359,6 +362,9 @@ export var sqrt = /* #__PURE__ */createSqrt({
   config,
   typed
 });
+export var squeeze = /* #__PURE__ */createSqueeze({
+  typed
+});
 export var tanh = /* #__PURE__ */createTanh({
   typed
 });
@@ -423,10 +429,6 @@ export var size = /* #__PURE__ */createSize({
   config,
   typed
 });
-export var squeeze = /* #__PURE__ */createSqueeze({
-  matrix,
-  typed
-});
 export var transpose = /* #__PURE__ */createTranspose({
   matrix,
   typed
@@ -498,10 +500,6 @@ export var equal = /* #__PURE__ */createEqual({
   matrix,
   typed
 });
-export var flatten = /* #__PURE__ */createFlatten({
-  matrix,
-  typed
-});
 export var hasNumericValue = /* #__PURE__ */createHasNumericValue({
   isNumeric,
   typed

package/lib/esm/entry/typeChecks.js

@@ -1,2 +1,2 @@
 // util functions
-export { isAccessorNode, isArray, isArrayNode, isAssignmentNode, isBigNumber, isBigInt, isBlockNode, isBoolean, isChain, isCollection, isComplex, isConditionalNode, isConstantNode, isDate, isDenseMatrix, isFraction, isFunction, isFunctionAssignmentNode, isFunctionNode, isHelp, isIndex, isIndexNode, isMatrix, isNode, isNull, isNumber, isString, isUndefined, isObject, isObjectNode, isOperatorNode, isParenthesisNode, isRange, isRangeNode, isRelationalNode, isRegExp, isResultSet, isSparseMatrix, isSymbolNode, isUnit } from '../utils/is.js';
+export { isAccessorNode, isArray, isArrayNode, isAssignmentNode, isBigNumber, isBigInt, isBlockNode, isBoolean, isChain, isCollection, isComplex, isConditionalNode, isConstantNode, isDate, isDenseMatrix, isFraction, isFunction, isFunctionAssignmentNode, isFunctionNode, isHelp, isIndex, isIndexNode, isMatrix, isNode, isNull, isNumber, isString, isUndefined, isObject, isMap, isPartitionedMap, isObjectWrappingMap, isObjectNode, isOperatorNode, isParenthesisNode, isRange, isRangeNode, isRelationalNode, isRegExp, isResultSet, isSparseMatrix, isSymbolNode, isUnit } from '../utils/is.js';

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

@@ -316,7 +316,7 @@ export var embeddedDocs = {
     examples: ['elementaryCharge']
   },
   bohrMagneton: {
-    description: 'Borh magneton',
+    description: 'Bohr magneton',
     examples: ['bohrMagneton']
   },
   conductanceQuantum: {
@@ -341,7 +341,7 @@ export var embeddedDocs = {
     examples: ['klitzing']
   },
   bohrRadius: {
-    description: 'Borh radius',
+    description: 'Bohr radius',
     examples: ['bohrRadius']
   },
   classicalElectronRadius: {

package/lib/esm/expression/embeddedDocs/function/arithmetic/hypot.js

@@ -2,7 +2,7 @@ export var hypotDocs = {
   name: 'hypot',
   category: 'Arithmetic',
   syntax: ['hypot(a, b, c, ...)', 'hypot([a, b, c, ...])'],
-  description: 'Calculate the hypotenusa of a list with values. ',
+  description: 'Calculate the hypotenuse of a list with values.',
   examples: ['hypot(3, 4)', 'sqrt(3^2 + 4^2)', 'hypot(-2)', 'hypot([3, 4, 5])'],
   seealso: ['abs', 'norm']
 };

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

@@ -2,7 +2,7 @@ export var diffDocs = {
   name: 'diff',
   category: 'Matrix',
   syntax: ['diff(arr)', 'diff(arr, dim)'],
-  description: ['Create a new matrix or array with the difference of the passed matrix or array.', 'Dim parameter is optional and used to indicant the dimension of the array/matrix to apply the difference', 'If no dimension parameter is passed it is assumed as dimension 0', 'Dimension is zero-based in javascript and one-based in the parser', 'Arrays must be \'rectangular\' meaning arrays like [1, 2]', 'If something is passed as a matrix it will be returned as a matrix but other than that all matrices are converted to arrays'],
+  description: ['Create a new matrix or array with the difference of the passed matrix or array.', 'Dim parameter is optional and used to indicate the dimension of the array/matrix to apply the difference', 'If no dimension parameter is passed it is assumed as dimension 0', 'Dimension is zero-based in javascript and one-based in the parser', 'Arrays must be \'rectangular\' meaning arrays like [1, 2]', 'If something is passed as a matrix it will be returned as a matrix but other than that all matrices are converted to arrays'],
   examples: ['A = [1, 2, 4, 7, 0]', 'diff(A)', 'diff(A, 1)', 'B = [[1, 2], [3, 4]]', 'diff(B)', 'diff(B, 1)', 'diff(B, 2)', 'diff(B, bignumber(2))', 'diff([[1, 2], matrix([3, 4])], 2)'],
   seealso: ['subtract', 'partitionSelect']
 };

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

@@ -2,7 +2,7 @@ export var fftDocs = {
   name: 'fft',
   category: 'Matrix',
   syntax: ['fft(x)'],
-  description: 'Calculate N-dimensional fourier transform',
+  description: 'Calculate N-dimensional Fourier transform',
   examples: ['fft([[1, 0], [1, 0]])'],
   seealso: ['ifft']
 };

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

@@ -2,7 +2,7 @@ export var ifftDocs = {
   name: 'ifft',
   category: 'Matrix',
   syntax: ['ifft(x)'],
-  description: 'Calculate N-dimensional inverse fourier transform',
+  description: 'Calculate N-dimensional inverse Fourier transform',
   examples: ['ifft([[2, 2], [0, 0]])'],
   seealso: ['fft']
 };

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

@@ -2,7 +2,7 @@ export var kronDocs = {
   name: 'kron',
   category: 'Matrix',
   syntax: ['kron(x, y)'],
-  description: 'Calculates the kronecker product of 2 matrices or vectors.',
+  description: 'Calculates the Kronecker product of 2 matrices or vectors.',
   examples: ['kron([[1, 0], [0, 1]], [[1, 2], [3, 4]])', 'kron([1,1], [2,3,4])'],
   seealso: ['multiply', 'dot', 'cross']
 };

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

@@ -1,8 +1,8 @@
 export var mapDocs = {
   name: 'map',
   category: 'Matrix',
-  syntax: ['map(x, callback)'],
-  description: 'Create a new matrix or array with the results of the callback function executed on each entry of the matrix/array.',
-  examples: ['map([1, 2, 3], square)'],
+  syntax: ['map(x, callback)', 'map(x, y, ..., callback)'],
+  description: 'Create a new matrix or array with the results of the callback function executed on each entry of the matrix/array or the matrices/arrays.',
+  examples: ['map([1, 2, 3], square)', 'map([1, 2], [3, 4], f(a,b) = a + b)'],
   seealso: ['filter', 'forEach']
 };

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

@@ -2,7 +2,7 @@ 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',
+  description: 'Compute the Riemann Zeta Function using an infinite series and Riemann\'s Functional Equation for the entire complex plane',
   examples: ['zeta(0.2)', 'zeta(-0.5)', 'zeta(4)'],
   seealso: []
 };

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

@@ -2,7 +2,7 @@ export var quantileSeqDocs = {
   name: 'quantileSeq',
   category: 'Statistics',
   syntax: ['quantileSeq(A, prob[, sorted])', 'quantileSeq(A, [prob1, prob2, ...][, sorted])', 'quantileSeq(A, N[, sorted])'],
-  description: 'Compute the prob order quantile of a matrix or a list with values. The sequence is sorted and the middle value is returned. Supported types of sequence values are: Number, BigNumber, Unit Supported types of probablity are: Number, BigNumber. \n\nIn case of a (multi dimensional) array or matrix, the prob order quantile of all elements will be calculated.',
+  description: 'Compute the prob order quantile of a matrix or a list with values. The sequence is sorted and the middle value is returned. Supported types of sequence values are: Number, BigNumber, Unit Supported types of probability are: Number, BigNumber. \n\nIn case of a (multi dimensional) array or matrix, the prob order quantile of all elements will be calculated.',
   examples: ['quantileSeq([3, -1, 5, 7], 0.5)', 'quantileSeq([3, -1, 5, 7], [1/3, 2/3])', 'quantileSeq([3, -1, 5, 7], 2)', 'quantileSeq([-1, 3, 5, 7], 0.5, true)'],
   seealso: ['mean', 'median', 'min', 'max', 'prod', 'std', 'sum', 'variance']
 };

package/lib/esm/expression/embeddedDocs/function/trigonometry/acoth.js

@@ -2,7 +2,7 @@ export var acothDocs = {
   name: 'acoth',
   category: 'Trigonometry',
   syntax: ['acoth(x)'],
-  description: 'Calculate the hyperbolic arccotangent of a value, defined as `acoth(x) = (ln((x+1)/x) + ln(x/(x-1))) / 2`.',
+  description: 'Calculate the inverse hyperbolic tangent of a value, defined as `acoth(x) = (ln((x+1)/x) + ln(x/(x-1))) / 2`.',
   examples: ['acoth(2)', 'acoth(0.5)'],
   seealso: ['acsch', 'asech']
 };

package/lib/esm/expression/embeddedDocs/function/trigonometry/acsch.js

@@ -2,7 +2,7 @@ export var acschDocs = {
   name: 'acsch',
   category: 'Trigonometry',
   syntax: ['acsch(x)'],
-  description: 'Calculate the hyperbolic arccosecant of a value, defined as `acsch(x) = ln(1/x + sqrt(1/x^2 + 1))`.',
+  description: 'Calculate the inverse hyperbolic cosecant of a value, defined as `acsch(x) = ln(1/x + sqrt(1/x^2 + 1))`.',
   examples: ['acsch(0.5)'],
   seealso: ['asech', 'acoth']
 };

package/lib/esm/expression/embeddedDocs/function/utils/clone.js

@@ -2,7 +2,7 @@ export var cloneDocs = {
   name: 'clone',
   category: 'Utils',
   syntax: ['clone(x)'],
-  description: 'Clone a variable. Creates a copy of primitive variables,and a deep copy of matrices',
+  description: 'Clone a variable. Creates a copy of primitive variables, and a deep copy of matrices',
   examples: ['clone(3.5)', 'clone(2 - 4i)', 'clone(45 deg)', 'clone([1, 2; 3, 4])', 'clone("hello world")'],
   seealso: []
 };

package/lib/esm/expression/function/compile.js

@@ -45,7 +45,7 @@ export var createCompile = /* #__PURE__ */factory(name, dependencies, _ref => {
     string: function string(expr) {
       return parse(expr).compile();
     },
-    'Array | Matrix': function ArrayMatrix(expr) {
+    'Array | Matrix': function Array__Matrix(expr) {
       return deepMap(expr, function (entry) {
         return parse(entry).compile();
       });

package/lib/esm/expression/function/evaluate.js

@@ -11,6 +11,11 @@ export var createEvaluate = /* #__PURE__ */factory(name, dependencies, _ref => {
   /**
    * Evaluate an expression.
    *
+   * The expression parser does not use JavaScript. Its syntax is close
+   * to JavaScript but more suited for mathematical expressions.
+   * See [https://mathjs.org/docs/expressions/syntax.html](https://mathjs.org/docs/expressions/syntax.html) to learn
+   * the syntax and get an overview of the exact differences from JavaScript.
+   *
    * Note the evaluating arbitrary expressions may involve security risks,
    * see [https://mathjs.org/docs/expressions/security.html](https://mathjs.org/docs/expressions/security.html) for more information.
    *
@@ -45,16 +50,16 @@ export var createEvaluate = /* #__PURE__ */factory(name, dependencies, _ref => {
       var scope = createEmptyMap();
       return parse(expr).compile().evaluate(scope);
     },
-    'string, Map | Object': function stringMapObject(expr, scope) {
+    'string, Map | Object': function string_Map__Object(expr, scope) {
       return parse(expr).compile().evaluate(scope);
     },
-    'Array | Matrix': function ArrayMatrix(expr) {
+    'Array | Matrix': function Array__Matrix(expr) {
       var scope = createEmptyMap();
       return deepMap(expr, function (entry) {
         return parse(entry).compile().evaluate(scope);
       });
     },
-    'Array | Matrix, Map | Object': function ArrayMatrixMapObject(expr, scope) {
+    'Array | Matrix, Map | Object': function Array__Matrix_Map__Object(expr, scope) {
       return deepMap(expr, function (entry) {
         return parse(entry).compile().evaluate(scope);
       });

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

@@ -97,7 +97,7 @@ export var createFunctionNode = /* #__PURE__ */factory(name, dependencies, _ref
      * invoke a list with arguments on a node
      * @param {./Node | string} fn
      *     Item resolving to a function on which to invoke
-     *     the arguments, typically a SymboNode or AccessorNode
+     *     the arguments, typically a SymbolNode or AccessorNode
      * @param {./Node[]} args
      */
     constructor(fn, args) {

package/lib/esm/expression/parse.js

@@ -70,10 +70,10 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
     string: function string(expression) {
       return parseStart(expression, {});
     },
-    'Array | Matrix': function ArrayMatrix(expressions) {
+    'Array | Matrix': function Array__Matrix(expressions) {
       return parseMultiple(expressions, {});
     },
-    'string, Object': function stringObject(expression, options) {
+    'string, Object': function string_Object(expression, options) {
       var extraNodes = options.nodes !== undefined ? options.nodes : {};
       return parseStart(expression, extraNodes);
     },

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

@@ -37,12 +37,12 @@ export var createFilterTransform = /* #__PURE__ */factory(name, dependencies, _r
   // one based version of function filter
   var filter = typed('filter', {
     'Array, function': _filter,
-    'Matrix, function': function MatrixFunction(x, test) {
-      return x.create(_filter(x.toArray(), test));
+    'Matrix, function': function Matrix_function(x, test) {
+      return x.create(_filter(x.toArray(), test), x.datatype());
     },
     'Array, RegExp': filterRegExp,
-    'Matrix, RegExp': function MatrixRegExp(x, test) {
-      return x.create(filterRegExp(x.toArray(), test));
+    'Matrix, RegExp': function Matrix_RegExp(x, test) {
+      return x.create(filterRegExp(x.toArray(), test), x.datatype());
     }
   });
   return filterTransform;

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

@@ -35,19 +35,19 @@ export var createForEachTransform = /* #__PURE__ */factory(name, dependencies, _
 
   // one-based version of forEach
   var _forEach = typed('forEach', {
-    'Array | Matrix, function': function ArrayMatrixFunction(array, callback) {
-      var recurse = function recurse(value, index) {
+    'Array | Matrix, function': function Array__Matrix_function(array, callback) {
+      var _recurse = function recurse(value, index) {
         if (Array.isArray(value)) {
           forEach(value, function (child, i) {
             // we create a copy of the index array and append the new index value
-            recurse(child, index.concat(i + 1)); // one based index, hence i+1
+            _recurse(child, index.concat(i + 1)); // one based index, hence i+1
           });
         } else {
           // invoke the callback function with the right number of arguments
           return applyCallback(callback, value, index, array, 'forEach');
         }
       };
-      recurse(array.valueOf(), []); // pass Array
+      _recurse(array.valueOf(), []); // pass Array
     }
   });
   return forEachTransform;

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

@@ -1,7 +1,6 @@
-import { applyCallback } from '../../utils/applyCallback.js';
-import { map } from '../../utils/array.js';
 import { factory } from '../../utils/factory.js';
 import { isFunctionAssignmentNode, isSymbolNode } from '../../utils/is.js';
+import { createMap } from '../../function/matrix/map.js';
 import { compileInlineExpression } from './utils/compileInlineExpression.js';
 var name = 'map';
 var dependencies = ['typed'];
@@ -15,57 +14,125 @@ export var createMapTransform = /* #__PURE__ */factory(name, dependencies, _ref
    *
    * This transform creates a one-based index instead of a zero-based index
    */
+  var map = createMap({
+    typed
+  });
   function mapTransform(args, math, scope) {
-    var x, callback;
-    if (args[0]) {
-      x = args[0].compile().evaluate(scope);
+    if (args.length === 0) {
+      return map();
     }
-    if (args[1]) {
-      if (isSymbolNode(args[1]) || isFunctionAssignmentNode(args[1])) {
+    if (args.length === 1) {
+      return map(args[0]);
+    }
+    var N = args.length - 1;
+    var X, callback;
+    callback = args[N];
+    X = args.slice(0, N);
+    X = X.map(arg => _compileAndEvaluate(arg, scope));
+    if (callback) {
+      if (isSymbolNode(callback) || isFunctionAssignmentNode(callback)) {
         // a function pointer, like filter([3, -2, 5], myTestFunction)
-        callback = args[1].compile().evaluate(scope);
+        callback = _compileAndEvaluate(callback, scope);
       } else {
         // an expression like filter([3, -2, 5], x > 0)
-        callback = compileInlineExpression(args[1], math, scope);
+        callback = compileInlineExpression(callback, math, scope);
       }
     }
-    return map(x, callback);
+    return map(...X, _transformCallback(callback, N));
+    function _compileAndEvaluate(arg, scope) {
+      return arg.compile().evaluate(scope);
+    }
   }
   mapTransform.rawArgs = true;
+  return mapTransform;
 
-  // one-based version of map function
-  var map = typed('map', {
-    'Array, function': function ArrayFunction(x, callback) {
-      return _map(x, callback, x);
-    },
-    'Matrix, function': function MatrixFunction(x, callback) {
-      return x.create(_map(x.valueOf(), callback, x));
+  /**
+   * Transforms the given callback function based on its type and number of arrays.
+   *
+   * @param {Function} callback - The callback function to transform.
+   * @param {number} numberOfArrays - The number of arrays to pass to the callback function.
+   * @returns {*} - The transformed callback function.
+   */
+  function _transformCallback(callback, numberOfArrays) {
+    if (typed.isTypedFunction(callback)) {
+      return _transformTypedCallbackFunction(callback, numberOfArrays);
+    } else {
+      return _transformCallbackFunction(callback, callback.length, numberOfArrays);
     }
-  });
-  return mapTransform;
+  }
+
+  /**
+   * Transforms the given typed callback function based on the number of arrays.
+   *
+   * @param {Function} typedFunction - The typed callback function to transform.
+   * @param {number} numberOfArrays - The number of arrays to pass to the callback function.
+   * @returns {*} - The transformed typed callback function.
+   */
+  function _transformTypedCallbackFunction(typedFunction, numberOfArrays) {
+    var signatures = Object.fromEntries(Object.entries(typedFunction.signatures).map(_ref2 => {
+      var [signature, callbackFunction] = _ref2;
+      var numberOfCallbackInputs = signature.split(',').length;
+      if (typed.isTypedFunction(callbackFunction)) {
+        return [signature, _transformTypedCallbackFunction(callbackFunction, numberOfArrays)];
+      } else {
+        return [signature, _transformCallbackFunction(callbackFunction, numberOfCallbackInputs, numberOfArrays)];
+      }
+    }));
+    if (typeof typedFunction.name === 'string') {
+      return typed(typedFunction.name, signatures);
+    } else {
+      return typed(signatures);
+    }
+  }
 }, {
   isTransformFunction: true
 });
 
 /**
- * Map for a multidimensional array. One-based indexes
- * @param {Array} array
- * @param {function} callback
- * @param {Array} orig
- * @return {Array}
- * @private
+ * Transforms the callback function based on the number of callback inputs and arrays.
+ * There are three cases:
+ * 1. The callback function has N arguments.
+ * 2. The callback function has N+1 arguments.
+ * 3. The callback function has 2N+1 arguments.
+ *
+ * @param {Function} callbackFunction - The callback function to transform.
+ * @param {number} numberOfCallbackInputs - The number of callback inputs.
+ * @param {number} numberOfArrays - The number of arrays.
+ * @returns {Function} The transformed callback function.
  */
-function _map(array, callback, orig) {
-  function recurse(value, index) {
-    if (Array.isArray(value)) {
-      return map(value, function (child, i) {
-        // we create a copy of the index array and append the new index value
-        return recurse(child, index.concat(i + 1)); // one based index, hence i + 1
-      });
-    } else {
-      // invoke the (typed) callback function with the right number of arguments
-      return applyCallback(callback, value, index, orig, 'map');
-    }
+function _transformCallbackFunction(callbackFunction, numberOfCallbackInputs, numberOfArrays) {
+  if (numberOfCallbackInputs === numberOfArrays) {
+    return callbackFunction;
+  } else if (numberOfCallbackInputs === numberOfArrays + 1) {
+    return function () {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      var vals = args.slice(0, numberOfArrays);
+      var idx = _transformDims(args[numberOfArrays]);
+      return callbackFunction(...vals, idx);
+    };
+  } else if (numberOfCallbackInputs > numberOfArrays + 1) {
+    return function () {
+      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        args[_key2] = arguments[_key2];
+      }
+      var vals = args.slice(0, numberOfArrays);
+      var idx = _transformDims(args[numberOfArrays]);
+      var rest = args.slice(numberOfArrays + 1);
+      return callbackFunction(...vals, idx, ...rest);
+    };
+  } else {
+    return callbackFunction;
   }
-  return recurse(array, []);
+}
+
+/**
+ * Transforms the dimensions by adding 1 to each dimension.
+ *
+ * @param {Array} dims - The dimensions to transform.
+ * @returns {Array} The transformed dimensions.
+ */
+function _transformDims(dims) {
+  return dims.map(dim => dim.isBigNumber ? dim.plus(1) : dim + 1);
 }

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

@@ -17,10 +17,10 @@ export var createPrintTransform = /* #__PURE__ */factory(name, dependencies, _re
     add
   });
   return typed(name, {
-    'string, Object | Array': function stringObjectArray(template, values) {
+    'string, Object | Array': function string_Object__Array(template, values) {
       return print(_convertTemplateToZeroBasedIndex(template), values);
     },
-    'string, Object | Array, number | Object': function stringObjectArrayNumberObject(template, values, options) {
+    'string, Object | Array, number | Object': function string_Object__Array_number__Object(template, values, options) {
       return print(_convertTemplateToZeroBasedIndex(template), values, options);
     }
   });

package/lib/esm/expression/transform/utils/dimToZeroBase.js

@@ -0,0 +1,16 @@
+import { isNumber, isBigNumber } from '../../../utils/is.js';
+/**
+ * Change last argument dim from one-based to zero-based.
+ */
+export function dimToZeroBase(dim) {
+  if (isNumber(dim)) {
+    return dim - 1;
+  } else if (isBigNumber(dim)) {
+    return dim.minus(1);
+  } else {
+    return dim;
+  }
+}
+export function isNumberOrBigNumber(n) {
+  return isNumber(n) || isBigNumber(n);
+}

package/lib/esm/expression/transform/utils/lastDimToZeroBase.js

@@ -1,5 +1,5 @@
-import { isBigNumber, isCollection, isNumber } from '../../../utils/is.js';
-
+import { isCollection } from '../../../utils/is.js';
+import { dimToZeroBase, isNumberOrBigNumber } from './dimToZeroBase.js';
 /**
  * Change last argument dim from one-based to zero-based.
  */
@@ -7,10 +7,8 @@ export function lastDimToZeroBase(args) {
   if (args.length === 2 && isCollection(args[0])) {
     args = args.slice();
     var dim = args[1];
-    if (isNumber(dim)) {
-      args[1] = dim - 1;
-    } else if (isBigNumber(dim)) {
-      args[1] = dim.minus(1);
+    if (isNumberOrBigNumber(dim)) {
+      args[1] = dimToZeroBase(dim);
     }
   }
   return args;

package/lib/esm/function/algebra/decomposition/slu.js

@@ -70,7 +70,7 @@ export var createSlu = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @return {Object} The lower triangular matrix, the upper triangular matrix and the permutation vectors.
    */
   return typed(name, {
-    'SparseMatrix, number, number': function SparseMatrixNumberNumber(a, order, threshold) {
+    'SparseMatrix, number, number': function SparseMatrix_number_number(a, order, threshold) {
       // verify order
       if (!isInteger(order) || order < 0 || order > 3) {
         throw new Error('Symbolic Ordering and Analysis order must be an integer number in the interval [0, 3]');