mathjs 13.0.2 → 13.1.0

package/lib/cjs/core/create.js

@@ -7,16 +7,16 @@ Object.defineProperty(exports, "__esModule", {
 exports.create = create;
 var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
 var _typedFunction = _interopRequireDefault(require("typed-function"));
-var _object = require("../utils/object.js");
-var emitter = _interopRequireWildcard(require("./../utils/emitter.js"));
-var _import = require("./function/import.js");
-var _config = require("./function/config.js");
-var _factory = require("../utils/factory.js");
-var _is = require("../utils/is.js");
 var _ArgumentsError = require("../error/ArgumentsError.js");
 var _DimensionError = require("../error/DimensionError.js");
 var _IndexError = require("../error/IndexError.js");
-var _config2 = require("./config.js");
+var _factory = require("../utils/factory.js");
+var _is = require("../utils/is.js");
+var _object = require("../utils/object.js");
+var emitter = _interopRequireWildcard(require("./../utils/emitter.js"));
+var _config = require("./config.js");
+var _config2 = require("./function/config.js");
+var _import = require("./function/import.js");
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
 /**
@@ -62,7 +62,7 @@ function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e;
  *                   - `on`, `off`, `once`, `emit` for events
  */
 function create(factories, config) {
-  const configInternal = (0, _extends2.default)({}, _config2.DEFAULT_CONFIG, config);
+  const configInternal = (0, _extends2.default)({}, _config.DEFAULT_CONFIG, config);
 
   // simple test for ES5 support
   if (typeof Object.create !== 'function') {
@@ -93,6 +93,9 @@ function create(factories, config) {
     isDate: _is.isDate,
     isRegExp: _is.isRegExp,
     isObject: _is.isObject,
+    isMap: _is.isMap,
+    isPartitionedMap: _is.isPartitionedMap,
+    isObjectWrappingMap: _is.isObjectWrappingMap,
     isNull: _is.isNull,
     isUndefined: _is.isUndefined,
     isAccessorNode: _is.isAccessorNode,
@@ -115,7 +118,7 @@ function create(factories, config) {
   });
 
   // load config function and apply provided config
-  math.config = (0, _config.configFactory)(configInternal, math.emit);
+  math.config = (0, _config2.configFactory)(configInternal, math.emit);
   math.expression = {
     transform: {},
     mathWithTransform: {

package/lib/cjs/core/function/import.js

@@ -225,7 +225,7 @@ function importFactory(typed, load, math, importedFactories) {
       throw new Error('Factory name should not contain a nested path. ' + 'Name: ' + JSON.stringify(name));
     }
     const namespace = isTransformFunctionFactory(factory) ? math.expression.transform : math;
-    const existingTransform = (name in math.expression.transform);
+    const existingTransform = name in math.expression.transform;
     const existing = (0, _object.hasOwnProperty)(namespace, name) ? namespace[name] : undefined;
     const resolver = function () {
       // collect all dependencies, handle finding both functions and classes and other special cases

package/lib/cjs/core/function/typed.js

@@ -5,11 +5,10 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createTyped = void 0;
-var _is = require("../../utils/is.js");
 var _typedFunction = _interopRequireDefault(require("typed-function"));
-var _number = require("../../utils/number.js");
 var _factory = require("../../utils/factory.js");
-var _map = require("../../utils/map.js");
+var _is = require("../../utils/is.js");
+var _number = require("../../utils/number.js");
 /**
  * Create a typed-function which checks the types of the arguments and
  * can match them against multiple provided signatures. The typed-function
@@ -202,7 +201,7 @@ const createTyped = exports.createTyped = /* #__PURE__ */(0, _factory.factory)('
     test: _is.isSymbolNode
   }, {
     name: 'Map',
-    test: _map.isMap
+    test: _is.isMap
   }, {
     name: 'Object',
     test: _is.isObject

package/lib/cjs/entry/dependenciesAny/dependenciesFlatten.generated.js

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.flattenDependencies = void 0;
-var _dependenciesMatrixGenerated = require("./dependenciesMatrix.generated.js");
 var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
 var _factoriesAny = require("../../factoriesAny.js");
 /**
@@ -13,7 +12,6 @@ var _factoriesAny = require("../../factoriesAny.js");
  */
 
 const flattenDependencies = exports.flattenDependencies = {
-  matrixDependencies: _dependenciesMatrixGenerated.matrixDependencies,
   typedDependencies: _dependenciesTypedGenerated.typedDependencies,
   createFlatten: _factoriesAny.createFlatten
 };

package/lib/cjs/entry/dependenciesAny/dependenciesSqueeze.generated.js

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.squeezeDependencies = void 0;
-var _dependenciesMatrixGenerated = require("./dependenciesMatrix.generated.js");
 var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
 var _factoriesAny = require("../../factoriesAny.js");
 /**
@@ -13,7 +12,6 @@ var _factoriesAny = require("../../factoriesAny.js");
  */
 
 const squeezeDependencies = exports.squeezeDependencies = {
-  matrixDependencies: _dependenciesMatrixGenerated.matrixDependencies,
   typedDependencies: _dependenciesTypedGenerated.typedDependencies,
   createSqueeze: _factoriesAny.createSqueeze
 };

package/lib/cjs/entry/impureFunctionsAny.generated.js

@@ -314,6 +314,7 @@ const help = exports.help = (0, _factoriesAny.createHelp)({
   exp: _pureFunctionsAnyGenerated.exp,
   expm1: _pureFunctionsAnyGenerated.expm1,
   filter: _pureFunctionsAnyGenerated.filter,
+  flatten: _pureFunctionsAnyGenerated.flatten,
   forEach: _pureFunctionsAnyGenerated.forEach,
   format: _pureFunctionsAnyGenerated.format,
   getMatrixDataType: _pureFunctionsAnyGenerated.getMatrixDataType,
@@ -361,6 +362,7 @@ const help = exports.help = (0, _factoriesAny.createHelp)({
   sinh: _pureFunctionsAnyGenerated.sinh,
   sparse: _pureFunctionsAnyGenerated.sparse,
   sqrt: _pureFunctionsAnyGenerated.sqrt,
+  squeeze: _pureFunctionsAnyGenerated.squeeze,
   tanh: _pureFunctionsAnyGenerated.tanh,
   unaryMinus: _pureFunctionsAnyGenerated.unaryMinus,
   acoth: _pureFunctionsAnyGenerated.acoth,
@@ -375,7 +377,6 @@ const help = exports.help = (0, _factoriesAny.createHelp)({
   prod: _pureFunctionsAnyGenerated.prod,
   reshape: _pureFunctionsAnyGenerated.reshape,
   size: _pureFunctionsAnyGenerated.size,
-  squeeze: _pureFunctionsAnyGenerated.squeeze,
   transpose: _pureFunctionsAnyGenerated.transpose,
   xgcd: _pureFunctionsAnyGenerated.xgcd,
   zeros: _pureFunctionsAnyGenerated.zeros,
@@ -388,7 +389,6 @@ const help = exports.help = (0, _factoriesAny.createHelp)({
   divideScalar: _pureFunctionsAnyGenerated.divideScalar,
   dotDivide: _pureFunctionsAnyGenerated.dotDivide,
   equal: _pureFunctionsAnyGenerated.equal,
-  flatten: _pureFunctionsAnyGenerated.flatten,
   hasNumericValue: _pureFunctionsAnyGenerated.hasNumericValue,
   identity: _pureFunctionsAnyGenerated.identity,
   kron: _pureFunctionsAnyGenerated.kron,

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

@@ -193,6 +193,9 @@ const expm1 = exports.expm1 = /* #__PURE__ */(0, _factoriesAny.createExpm1)({
 const filter = exports.filter = /* #__PURE__ */(0, _factoriesAny.createFilter)({
   typed
 });
+const flatten = exports.flatten = /* #__PURE__ */(0, _factoriesAny.createFlatten)({
+  typed
+});
 const forEach = exports.forEach = /* #__PURE__ */(0, _factoriesAny.createForEach)({
   typed
 });
@@ -367,6 +370,9 @@ const sqrt = exports.sqrt = /* #__PURE__ */(0, _factoriesAny.createSqrt)({
   config: _configReadonly.config,
   typed
 });
+const squeeze = exports.squeeze = /* #__PURE__ */(0, _factoriesAny.createSqueeze)({
+  typed
+});
 const tanh = exports.tanh = /* #__PURE__ */(0, _factoriesAny.createTanh)({
   typed
 });
@@ -431,10 +437,6 @@ const size = exports.size = /* #__PURE__ */(0, _factoriesAny.createSize)({
   config: _configReadonly.config,
   typed
 });
-const squeeze = exports.squeeze = /* #__PURE__ */(0, _factoriesAny.createSqueeze)({
-  matrix,
-  typed
-});
 const transpose = exports.transpose = /* #__PURE__ */(0, _factoriesAny.createTranspose)({
   matrix,
   typed
@@ -506,10 +508,6 @@ const equal = exports.equal = /* #__PURE__ */(0, _factoriesAny.createEqual)({
   matrix,
   typed
 });
-const flatten = exports.flatten = /* #__PURE__ */(0, _factoriesAny.createFlatten)({
-  matrix,
-  typed
-});
 const hasNumericValue = exports.hasNumericValue = /* #__PURE__ */(0, _factoriesAny.createHasNumericValue)({
   isNumeric,
   typed

package/lib/cjs/entry/typeChecks.js

@@ -135,6 +135,12 @@ Object.defineProperty(exports, "isIndexNode", {
     return _is.isIndexNode;
   }
 });
+Object.defineProperty(exports, "isMap", {
+  enumerable: true,
+  get: function () {
+    return _is.isMap;
+  }
+});
 Object.defineProperty(exports, "isMatrix", {
   enumerable: true,
   get: function () {
@@ -171,6 +177,12 @@ Object.defineProperty(exports, "isObjectNode", {
     return _is.isObjectNode;
   }
 });
+Object.defineProperty(exports, "isObjectWrappingMap", {
+  enumerable: true,
+  get: function () {
+    return _is.isObjectWrappingMap;
+  }
+});
 Object.defineProperty(exports, "isOperatorNode", {
   enumerable: true,
   get: function () {
@@ -183,6 +195,12 @@ Object.defineProperty(exports, "isParenthesisNode", {
     return _is.isParenthesisNode;
   }
 });
+Object.defineProperty(exports, "isPartitionedMap", {
+  enumerable: true,
+  get: function () {
+    return _is.isPartitionedMap;
+  }
+});
 Object.defineProperty(exports, "isRange", {
   enumerable: true,
   get: function () {

package/lib/cjs/expression/embeddedDocs/embeddedDocs.js

@@ -322,7 +322,7 @@ const embeddedDocs = exports.embeddedDocs = {
     examples: ['elementaryCharge']
   },
   bohrMagneton: {
-    description: 'Borh magneton',
+    description: 'Bohr magneton',
     examples: ['bohrMagneton']
   },
   conductanceQuantum: {
@@ -347,7 +347,7 @@ const embeddedDocs = exports.embeddedDocs = {
     examples: ['klitzing']
   },
   bohrRadius: {
-    description: 'Borh radius',
+    description: 'Bohr radius',
     examples: ['bohrRadius']
   },
   classicalElectronRadius: {

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

@@ -8,7 +8,7 @@ const hypotDocs = exports.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/cjs/expression/embeddedDocs/function/matrix/diff.js

@@ -8,7 +8,7 @@ const diffDocs = exports.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/cjs/expression/embeddedDocs/function/matrix/fft.js

@@ -8,7 +8,7 @@ const fftDocs = exports.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/cjs/expression/embeddedDocs/function/matrix/ifft.js

@@ -8,7 +8,7 @@ const ifftDocs = exports.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/cjs/expression/embeddedDocs/function/matrix/kron.js

@@ -8,7 +8,7 @@ const kronDocs = exports.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/cjs/expression/embeddedDocs/function/matrix/map.js

@@ -7,8 +7,8 @@ exports.mapDocs = void 0;
 const mapDocs = exports.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/cjs/expression/embeddedDocs/function/special/zeta.js

@@ -8,7 +8,7 @@ const zetaDocs = exports.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/cjs/expression/embeddedDocs/function/statistics/quantileSeq.js

@@ -8,7 +8,7 @@ const quantileSeqDocs = exports.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/cjs/expression/embeddedDocs/function/trigonometry/acoth.js

@@ -8,7 +8,7 @@ const acothDocs = exports.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/cjs/expression/embeddedDocs/function/trigonometry/acsch.js

@@ -8,7 +8,7 @@ const acschDocs = exports.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/cjs/expression/embeddedDocs/function/utils/clone.js

@@ -8,7 +8,7 @@ const cloneDocs = exports.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/cjs/expression/function/evaluate.js

@@ -17,6 +17,11 @@ const createEvaluate = exports.createEvaluate = /* #__PURE__ */(0, _factory.fact
   /**
    * 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.
    *

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

@@ -104,7 +104,7 @@ const createFunctionNode = exports.createFunctionNode = /* #__PURE__ */(0, _fact
      * 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/cjs/expression/transform/filter.transform.js

@@ -44,11 +44,11 @@ const createFilterTransform = exports.createFilterTransform = /* #__PURE__ */(0,
   const filter = typed('filter', {
     'Array, function': _filter,
     'Matrix, function': function (x, test) {
-      return x.create(_filter(x.toArray(), test));
+      return x.create(_filter(x.toArray(), test), x.datatype());
     },
     'Array, RegExp': _array.filterRegExp,
     'Matrix, RegExp': function (x, test) {
-      return x.create((0, _array.filterRegExp)(x.toArray(), test));
+      return x.create((0, _array.filterRegExp)(x.toArray(), test), x.datatype());
     }
   });
   return filterTransform;

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

@@ -4,10 +4,9 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createMapTransform = void 0;
-var _applyCallback = require("../../utils/applyCallback.js");
-var _array = require("../../utils/array.js");
 var _factory = require("../../utils/factory.js");
 var _is = require("../../utils/is.js");
+var _map = require("../../function/matrix/map.js");
 var _compileInlineExpression = require("./utils/compileInlineExpression.js");
 const name = 'map';
 const dependencies = ['typed'];
@@ -21,57 +20,125 @@ const createMapTransform = exports.createMapTransform = /* #__PURE__ */(0, _fact
    *
    * This transform creates a one-based index instead of a zero-based index
    */
+  const map = (0, _map.createMap)({
+    typed
+  });
   function mapTransform(args, math, scope) {
-    let x, callback;
-    if (args[0]) {
-      x = args[0].compile().evaluate(scope);
+    if (args.length === 0) {
+      return map();
     }
-    if (args[1]) {
-      if ((0, _is.isSymbolNode)(args[1]) || (0, _is.isFunctionAssignmentNode)(args[1])) {
+    if (args.length === 1) {
+      return map(args[0]);
+    }
+    const N = args.length - 1;
+    let X, callback;
+    callback = args[N];
+    X = args.slice(0, N);
+    X = X.map(arg => _compileAndEvaluate(arg, scope));
+    if (callback) {
+      if ((0, _is.isSymbolNode)(callback) || (0, _is.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 = (0, _compileInlineExpression.compileInlineExpression)(args[1], math, scope);
+        callback = (0, _compileInlineExpression.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
-  const map = typed('map', {
-    'Array, function': function (x, callback) {
-      return _map(x, callback, x);
-    },
-    'Matrix, function': function (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) {
+    const signatures = Object.fromEntries(Object.entries(typedFunction.signatures).map(_ref2 => {
+      let [signature, callbackFunction] = _ref2;
+      const 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 (0, _array.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 (0, _applyCallback.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];
+      }
+      const vals = args.slice(0, numberOfArrays);
+      const 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];
+      }
+      const vals = args.slice(0, numberOfArrays);
+      const idx = _transformDims(args[numberOfArrays]);
+      const 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/cjs/expression/transform/utils/dimToZeroBase.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.dimToZeroBase = dimToZeroBase;
+exports.isNumberOrBigNumber = isNumberOrBigNumber;
+var _is = require("../../../utils/is.js");
+/**
+ * Change last argument dim from one-based to zero-based.
+ */
+function dimToZeroBase(dim) {
+  if ((0, _is.isNumber)(dim)) {
+    return dim - 1;
+  } else if ((0, _is.isBigNumber)(dim)) {
+    return dim.minus(1);
+  } else {
+    return dim;
+  }
+}
+function isNumberOrBigNumber(n) {
+  return (0, _is.isNumber)(n) || (0, _is.isBigNumber)(n);
+}

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

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.lastDimToZeroBase = lastDimToZeroBase;
 var _is = require("../../../utils/is.js");
+var _dimToZeroBase = require("./dimToZeroBase.js");
 /**
  * Change last argument dim from one-based to zero-based.
  */
@@ -12,10 +13,8 @@ function lastDimToZeroBase(args) {
   if (args.length === 2 && (0, _is.isCollection)(args[0])) {
     args = args.slice();
     const dim = args[1];
-    if ((0, _is.isNumber)(dim)) {
-      args[1] = dim - 1;
-    } else if ((0, _is.isBigNumber)(dim)) {
-      args[1] = dim.minus(1);
+    if ((0, _dimToZeroBase.isNumberOrBigNumber)(dim)) {
+      args[1] = (0, _dimToZeroBase.dimToZeroBase)(dim);
     }
   }
   return args;