mathjs 13.0.3 → 13.1.0

package/lib/esm/function/set/setUnion.js

@@ -34,7 +34,7 @@ export var createSetUnion = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @return {Array | Matrix}    The union of two (multi)sets
    */
   return typed(name, {
-    'Array | Matrix, Array | Matrix': function ArrayMatrixArrayMatrix(a1, a2) {
+    'Array | Matrix, Array | Matrix': function Array__Matrix_Array__Matrix(a1, a2) {
       if (subset(size(a1), new Index(0)) === 0) {
         // if any of them is empty, return the other one
         return flatten(a2);

package/lib/esm/function/signal/freqz.js

@@ -32,21 +32,21 @@ export var createFreqz = /* #__PURE__ */factory(name, dependencies, _ref => {
      *
      */
   return typed(name, {
-    'Array, Array': function ArrayArray(b, a) {
+    'Array, Array': function Array_Array(b, a) {
       var w = createBins(512);
       return _freqz(b, a, w);
     },
-    'Array, Array, Array': function ArrayArrayArray(b, a, w) {
+    'Array, Array, Array': function Array_Array_Array(b, a, w) {
       return _freqz(b, a, w);
     },
-    'Array, Array, number': function ArrayArrayNumber(b, a, w) {
+    'Array, Array, number': function Array_Array_number(b, a, w) {
       if (w < 0) {
         throw new Error('w must be a positive number');
       }
       var w2 = createBins(w);
       return _freqz(b, a, w2);
     },
-    'Matrix, Matrix': function MatrixMatrix(b, a) {
+    'Matrix, Matrix': function Matrix_Matrix(b, a) {
       // console.log('here')
       var _w = createBins(512);
       var {
@@ -58,7 +58,7 @@ export var createFreqz = /* #__PURE__ */factory(name, dependencies, _ref => {
         h: matrix(h)
       };
     },
-    'Matrix, Matrix, Matrix': function MatrixMatrixMatrix(b, a, w) {
+    'Matrix, Matrix, Matrix': function Matrix_Matrix_Matrix(b, a, w) {
       var {
         h
       } = _freqz(b.valueOf(), a.valueOf(), w.valueOf());
@@ -67,7 +67,7 @@ export var createFreqz = /* #__PURE__ */factory(name, dependencies, _ref => {
         w: matrix(w)
       };
     },
-    'Matrix, Matrix, number': function MatrixMatrixNumber(b, a, w) {
+    'Matrix, Matrix, number': function Matrix_Matrix_number(b, a, w) {
       if (w < 0) {
         throw new Error('w must be a positive number');
       }

package/lib/esm/function/statistics/corr.js

@@ -35,10 +35,10 @@ export var createCorr = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @return {*} The correlation coefficient
    */
   return typed(name, {
-    'Array, Array': function ArrayArray(A, B) {
+    'Array, Array': function Array_Array(A, B) {
       return _corr(A, B);
     },
-    'Matrix, Matrix': function MatrixMatrix(A, B) {
+    'Matrix, Matrix': function Matrix_Matrix(A, B) {
       var res = _corr(A.toArray(), B.toArray());
       return Array.isArray(res) ? matrix(res) : res;
     }

package/lib/esm/function/statistics/cumsum.js

@@ -42,12 +42,12 @@ export var createCumSum = /* #__PURE__ */factory(name, dependencies, _ref => {
     // sum([a, b, c, d, ...])
     Array: _cumsum,
     Matrix: function Matrix(matrix) {
-      return matrix.create(_cumsum(matrix.valueOf()));
+      return matrix.create(_cumsum(matrix.valueOf(), matrix.datatype()));
     },
     // sum([a, b, c, d, ...], dim)
     'Array, number | BigNumber': _ncumSumDim,
-    'Matrix, number | BigNumber': function MatrixNumberBigNumber(matrix, dim) {
-      return matrix.create(_ncumSumDim(matrix.valueOf(), dim));
+    'Matrix, number | BigNumber': function Matrix_number__BigNumber(matrix, dim) {
+      return matrix.create(_ncumSumDim(matrix.valueOf(), dim), matrix.datatype());
     },
     // cumsum(a, b, c, d, ...)
     '...': function _(args) {

package/lib/esm/function/statistics/max.js

@@ -46,7 +46,7 @@ export var createMax = /* #__PURE__ */factory(name, dependencies, _ref => {
     // max([a, b, c, d, ...])
     'Array | Matrix': _max,
     // max([a, b, c, d, ...], dim)
-    'Array | Matrix, number | BigNumber': function ArrayMatrixNumberBigNumber(array, dim) {
+    'Array | Matrix, number | BigNumber': function Array__Matrix_number__BigNumber(array, dim) {
       return reduce(array, dim.valueOf(), _largest);
     },
     // max(a, b, c, d, ...)

package/lib/esm/function/statistics/median.js

@@ -50,14 +50,14 @@ export var createMedian = /* #__PURE__ */factory(name, dependencies, _ref => {
 
   // helper function to type check the middle value of the array
   var middle = typed({
-    'number | BigNumber | Complex | Unit': function numberBigNumberComplexUnit(value) {
+    'number | BigNumber | Complex | Unit': function number__BigNumber__Complex__Unit(value) {
       return value;
     }
   });
 
   // helper function to type check the two middle value of the array
   var middle2 = typed({
-    'number | BigNumber | Complex | Unit, number | BigNumber | Complex | Unit': function numberBigNumberComplexUnitNumberBigNumberComplexUnit(left, right) {
+    'number | BigNumber | Complex | Unit, number | BigNumber | Complex | Unit': function number__BigNumber__Complex__Unit_number__BigNumber__Complex__Unit(left, right) {
       return divide(add(left, right), 2);
     }
   });
@@ -92,7 +92,7 @@ export var createMedian = /* #__PURE__ */factory(name, dependencies, _ref => {
     // median([a, b, c, d, ...])
     'Array | Matrix': _median,
     // median([a, b, c, d, ...], dim)
-    'Array | Matrix, number | BigNumber': function ArrayMatrixNumberBigNumber(array, dim) {
+    'Array | Matrix, number | BigNumber': function Array__Matrix_number__BigNumber(array, dim) {
       // TODO: implement median(A, dim)
       throw new Error('median(A, dim) is not yet supported');
       // return reduce(arguments[0], arguments[1], ...)

package/lib/esm/function/statistics/min.js

@@ -46,7 +46,7 @@ export var createMin = /* #__PURE__ */factory(name, dependencies, _ref => {
     // min([a, b, c, d, ...])
     'Array | Matrix': _min,
     // min([a, b, c, d, ...], dim)
-    'Array | Matrix, number | BigNumber': function ArrayMatrixNumberBigNumber(array, dim) {
+    'Array | Matrix, number | BigNumber': function Array__Matrix_number__BigNumber(array, dim) {
       return reduce(array, dim.valueOf(), _smallest);
     },
     // min(a, b, c, d, ...)

package/lib/esm/function/statistics/prod.js

@@ -40,7 +40,7 @@ export var createProd = /* #__PURE__ */factory(name, dependencies, _ref => {
     // prod([a, b, c, d, ...])
     'Array | Matrix': _prod,
     // prod([a, b, c, d, ...], dim)
-    'Array | Matrix, number | BigNumber': function ArrayMatrixNumberBigNumber(array, dim) {
+    'Array | Matrix, number | BigNumber': function Array__Matrix_number__BigNumber(array, dim) {
       // TODO: implement prod(A, dim)
       throw new Error('prod(A, dim) is not yet supported');
       // return reduce(arguments[0], arguments[1], math.prod)

package/lib/esm/function/statistics/variance.js

@@ -70,13 +70,13 @@ export var createVariance = /* #__PURE__ */factory(name, dependencies, _ref => {
    */
   return typed(name, {
     // variance([a, b, c, d, ...])
-    'Array | Matrix': function ArrayMatrix(array) {
+    'Array | Matrix': function Array__Matrix(array) {
       return _var(array, DEFAULT_NORMALIZATION);
     },
     // variance([a, b, c, d, ...], normalization)
     'Array | Matrix, string': _var,
     // variance([a, b, c, c, ...], dim)
-    'Array | Matrix, number | BigNumber': function ArrayMatrixNumberBigNumber(array, dim) {
+    'Array | Matrix, number | BigNumber': function Array__Matrix_number__BigNumber(array, dim) {
       return _varDim(array, dim, DEFAULT_NORMALIZATION);
     },
     // variance([a, b, c, c, ...], dim, normalization)

package/lib/esm/function/string/bin.js

@@ -29,12 +29,12 @@ export var createBin = factory(name, dependencies, _ref => {
     format
   } = _ref;
   return typed(name, {
-    'number | BigNumber': function numberBigNumber(n) {
+    'number | BigNumber': function number__BigNumber(n) {
       return format(n, {
         notation: 'bin'
       });
     },
-    'number | BigNumber, number | BigNumber': function numberBigNumberNumberBigNumber(n, wordSize) {
+    'number | BigNumber, number | BigNumber': function number__BigNumber_number__BigNumber(n, wordSize) {
       return format(n, {
         notation: 'bin',
         wordSize

package/lib/esm/function/string/hex.js

@@ -28,12 +28,12 @@ export var createHex = factory(name, dependencies, _ref => {
     format
   } = _ref;
   return typed(name, {
-    'number | BigNumber': function numberBigNumber(n) {
+    'number | BigNumber': function number__BigNumber(n) {
       return format(n, {
         notation: 'hex'
       });
     },
-    'number | BigNumber, number | BigNumber': function numberBigNumberNumberBigNumber(n, wordSize) {
+    'number | BigNumber, number | BigNumber': function number__BigNumber_number__BigNumber(n, wordSize) {
       return format(n, {
         notation: 'hex',
         wordSize

package/lib/esm/function/string/oct.js

@@ -30,12 +30,12 @@ export var createOct = factory(name, dependencies, _ref => {
     format
   } = _ref;
   return typed(name, {
-    'number | BigNumber': function numberBigNumber(n) {
+    'number | BigNumber': function number__BigNumber(n) {
       return format(n, {
         notation: 'oct'
       });
     },
-    'number | BigNumber, number | BigNumber': function numberBigNumberNumberBigNumber(n, wordSize) {
+    'number | BigNumber, number | BigNumber': function number__BigNumber_number__BigNumber(n, wordSize) {
       return format(n, {
         notation: 'oct',
         wordSize

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

@@ -10,10 +10,10 @@ export var createAcoth = /* #__PURE__ */factory(name, dependencies, _ref => {
     BigNumber: _BigNumber
   } = _ref;
   /**
-   * Calculate the hyperbolic arccotangent of a value,
+   * Calculate the inverse hyperbolic tangent of a value,
    * defined as `acoth(x) = atanh(1/x) = (ln((x+1)/x) + ln(x/(x-1))) / 2`.
    *
-   * To avoid confusion with the matrix hyperbolic arccotangent, this
+   * To avoid confusion with the matrix inverse hyperbolic tangent, this
    * function does not apply to matrices.
    *
    * Syntax:

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

@@ -8,10 +8,10 @@ export var createAcsch = /* #__PURE__ */factory(name, dependencies, _ref => {
     BigNumber: _BigNumber
   } = _ref;
   /**
-   * Calculate the hyperbolic arccosecant of a value,
+   * Calculate the inverse hyperbolic cosecant of a value,
    * defined as `acsch(x) = asinh(1/x) = ln(1/x + sqrt(1/x^2 + 1))`.
    *
-   * To avoid confusion with the matrix hyperbolic arccosecant, this function
+   * To avoid confusion with the matrix inverse hyperbolic cosecant, this function
    * does not apply to matrices.
    *
    * Syntax:

package/lib/esm/type/bigint.js

@@ -44,7 +44,7 @@ export var createBigint = /* #__PURE__ */factory(name, dependencies, _ref => {
     Fraction: function Fraction(x) {
       return BigInt(x.valueOf().toFixed());
     },
-    'string | boolean': function stringBoolean(x) {
+    'string | boolean': function string__boolean(x) {
       return BigInt(x);
     },
     null: function _null(x) {

package/lib/esm/type/complex/function/complex.js

@@ -52,11 +52,11 @@ export var createComplex = /* #__PURE__ */factory(name, dependencies, _ref => {
     number: function number(x) {
       return new Complex(x, 0);
     },
-    'number, number': function numberNumber(re, im) {
+    'number, number': function number_number(re, im) {
       return new Complex(re, im);
     },
     // TODO: this signature should be redundant
-    'BigNumber, BigNumber': function BigNumberBigNumber(re, im) {
+    'BigNumber, BigNumber': function BigNumber_BigNumber(re, im) {
       return new Complex(re.toNumber(), im.toNumber());
     },
     Fraction: function Fraction(x) {

package/lib/esm/type/fraction/function/fraction.js

@@ -54,7 +54,7 @@ export var createFraction = /* #__PURE__ */factory(name, dependencies, _ref => {
     string: function string(x) {
       return new Fraction(x);
     },
-    'number, number': function numberNumber(numerator, denominator) {
+    'number, number': function number_number(numerator, denominator) {
       return new Fraction(numerator, denominator);
     },
     null: function _null(x) {

package/lib/esm/type/matrix/DenseMatrix.js

@@ -1,11 +1,11 @@
 import { isArray, isBigNumber, isCollection, isIndex, isMatrix, isNumber, isString, typeOf } from '../../utils/is.js';
-import { arraySize, getArrayDataType, processSizesWildcard, reshape, resize, unsqueeze, validate, validateIndex, broadcastTo } from '../../utils/array.js';
+import { arraySize, getArrayDataType, processSizesWildcard, reshape, resize, unsqueeze, validate, validateIndex, broadcastTo, get } from '../../utils/array.js';
 import { format } from '../../utils/string.js';
 import { isInteger } from '../../utils/number.js';
 import { clone, deepStrictEqual } from '../../utils/object.js';
 import { DimensionError } from '../../error/DimensionError.js';
 import { factory } from '../../utils/factory.js';
-import { maxArgumentCount } from '../../utils/function.js';
+import { applyCallback } from '../../utils/applyCallback.js';
 var name = 'DenseMatrix';
 var dependencies = ['Matrix'];
 export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, _ref => {
@@ -166,24 +166,7 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, _
    * @return {*} value
    */
   DenseMatrix.prototype.get = function (index) {
-    if (!isArray(index)) {
-      throw new TypeError('Array expected');
-    }
-    if (index.length !== this._size.length) {
-      throw new DimensionError(index.length, this._size.length);
-    }
-
-    // check index
-    for (var x = 0; x < index.length; x++) {
-      validateIndex(index[x], this._size[x]);
-    }
-    var data = this._data;
-    for (var i = 0, ii = index.length; i < ii; i++) {
-      var indexI = index[i];
-      validateIndex(indexI, data.length);
-      data = data[indexI];
-    }
-    return data;
+    return get(this._data, index);
   };
 
   /**
@@ -546,28 +529,20 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, _
   DenseMatrix.prototype.map = function (callback) {
     // matrix instance
     var me = this;
-    var args = maxArgumentCount(callback);
-    var recurse = function recurse(value, index) {
+    var _recurse = function recurse(value, index) {
       if (isArray(value)) {
         return value.map(function (child, i) {
-          return recurse(child, index.concat(i));
+          return _recurse(child, index.concat(i));
         });
       } else {
         // invoke the callback function with the right number of arguments
-        if (args === 1) {
-          return callback(value);
-        } else if (args === 2) {
-          return callback(value, index);
-        } else {
-          // 3 or -1
-          return callback(value, index, me);
-        }
+        return applyCallback(callback, value, index, me, 'map');
       }
     };
 
     // determine the new datatype when the original matrix has datatype defined
     // TODO: should be done in matrix constructor instead
-    var data = recurse(this._data, []);
+    var data = _recurse(this._data, []);
     var datatype = this._datatype !== undefined ? getArrayDataType(data, typeOf) : undefined;
     return new DenseMatrix(data, datatype);
   };
@@ -582,16 +557,16 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, _
   DenseMatrix.prototype.forEach = function (callback) {
     // matrix instance
     var me = this;
-    var recurse = function recurse(value, index) {
+    var _recurse2 = function recurse(value, index) {
       if (isArray(value)) {
         value.forEach(function (child, i) {
-          recurse(child, index.concat(i));
+          _recurse2(child, index.concat(i));
         });
       } else {
         callback(value, index, me);
       }
     };
-    recurse(this._data, []);
+    _recurse2(this._data, []);
   };
 
   /**
@@ -599,10 +574,10 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, _
    * @return {Iterable<{ value, index: number[] }>}
    */
   DenseMatrix.prototype[Symbol.iterator] = function* () {
-    var recurse = function* recurse(value, index) {
+    var _recurse3 = function* recurse(value, index) {
       if (isArray(value)) {
         for (var i = 0; i < value.length; i++) {
-          yield* recurse(value[i], index.concat(i));
+          yield* _recurse3(value[i], index.concat(i));
         }
       } else {
         yield {
@@ -611,7 +586,7 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, _
         };
       }
     };
-    yield* recurse(this._data, []);
+    yield* _recurse3(this._data, []);
   };
 
   /**

package/lib/esm/type/matrix/SparseMatrix.js

@@ -5,7 +5,7 @@ import { clone, deepStrictEqual } from '../../utils/object.js';
 import { arraySize, getArrayDataType, processSizesWildcard, unsqueeze, validateIndex } from '../../utils/array.js';
 import { factory } from '../../utils/factory.js';
 import { DimensionError } from '../../error/DimensionError.js';
-import { maxArgumentCount } from '../../utils/function.js';
+import { applyCallback } from '../../utils/applyCallback.js';
 var name = 'SparseMatrix';
 var dependencies = ['typed', 'equalScalar', 'Matrix'];
 export var createSparseMatrixClass = /* #__PURE__ */factory(name, dependencies, _ref => {
@@ -873,12 +873,9 @@ export var createSparseMatrixClass = /* #__PURE__ */factory(name, dependencies,
     var rows = this._size[0];
     var columns = this._size[1];
     // invoke callback
-    var args = maxArgumentCount(callback);
     var invoke = function invoke(v, i, j) {
       // invoke callback
-      if (args === 1) return callback(v);
-      if (args === 2) return callback(v, [i, j]);
-      return callback(v, [i, j], me);
+      return applyCallback(callback, v, [i, j], me, 'map');
     };
     // invoke _map
     return _map(this, 0, rows - 1, 0, columns - 1, invoke, skipZeros);
@@ -908,11 +905,11 @@ export var createSparseMatrixClass = /* #__PURE__ */factory(name, dependencies,
     // invoke callback
     var invoke = function invoke(v, x, y) {
       // invoke callback
-      v = callback(v, x, y);
+      var value = callback(v, x, y);
       // check value != 0
-      if (!eq(v, zero)) {
+      if (!eq(value, zero)) {
         // store value
-        values.push(v);
+        values.push(value);
         // index
         index.push(x);
       }

package/lib/esm/type/matrix/function/index.js

@@ -43,7 +43,7 @@ export var createIndex = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @return {Index}        Returns the created index
    */
   return typed(name, {
-    '...number | string | BigNumber | Range | Array | Matrix': function numberStringBigNumberRangeArrayMatrix(args) {
+    '...number | string | BigNumber | Range | Array | Matrix': function number__string__BigNumber__Range__Array__Matrix(args) {
       var ranges = args.map(function (arg) {
         if (isBigNumber(arg)) {
           return arg.toNumber(); // convert BigNumber to Number

package/lib/esm/type/matrix/function/matrix.js

@@ -48,7 +48,7 @@ export var createMatrix = /* #__PURE__ */factory(name, dependencies, _ref => {
     string: function string(format) {
       return _create([], format);
     },
-    'string, string': function stringString(format, datatype) {
+    'string, string': function string_string(format, datatype) {
       return _create([], format, datatype);
     },
     Array: function Array(data) {

package/lib/esm/type/matrix/function/sparse.js

@@ -46,10 +46,10 @@ export var createSparse = /* #__PURE__ */factory(name, dependencies, _ref => {
     string: function string(datatype) {
       return new SparseMatrix([], datatype);
     },
-    'Array | Matrix': function ArrayMatrix(data) {
+    'Array | Matrix': function Array__Matrix(data) {
       return new SparseMatrix(data);
     },
-    'Array | Matrix, string': function ArrayMatrixString(data, datatype) {
+    'Array | Matrix, string': function Array__Matrix_string(data, datatype) {
       return new SparseMatrix(data, datatype);
     }
   });

package/lib/esm/type/number.js

@@ -132,7 +132,7 @@ export var createNumber = /* #__PURE__ */factory(name, dependencies, _ref => {
     null: function _null(x) {
       return 0;
     },
-    'Unit, string | Unit': function UnitStringUnit(unit, valuelessUnit) {
+    'Unit, string | Unit': function Unit_string__Unit(unit, valuelessUnit) {
       return unit.toNumber(valuelessUnit);
     },
     'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self))

package/lib/esm/type/unit/function/createUnit.js

@@ -50,7 +50,7 @@ export var createCreateUnit = /* #__PURE__ */factory(name, dependencies, _ref =>
    */
   return typed(name, {
     // General function signature. First parameter is an object where each property is the definition of a new unit. The object keys are the unit names and the values are the definitions. The values can be objects, strings, or Units. If a property is an empty object or an empty string, a new base unit is created. The second parameter is the options.
-    'Object, Object': function ObjectObject(obj, options) {
+    'Object, Object': function Object_Object(obj, options) {
       return Unit.createUnit(obj, options);
     },
     // Same as above but without the options.
@@ -58,13 +58,13 @@ export var createCreateUnit = /* #__PURE__ */factory(name, dependencies, _ref =>
       return Unit.createUnit(obj, {});
     },
     // Shortcut method for creating one unit.
-    'string, Unit | string | Object, Object': function stringUnitStringObjectObject(name, def, options) {
+    'string, Unit | string | Object, Object': function string_Unit__string__Object_Object(name, def, options) {
       var obj = {};
       obj[name] = def;
       return Unit.createUnit(obj, options);
     },
     // Same as above but without the options.
-    'string, Unit | string | Object': function stringUnitStringObject(name, def) {
+    'string, Unit | string | Object': function string_Unit__string__Object(name, def) {
       var obj = {};
       obj[name] = def;
       return Unit.createUnit(obj, {});

package/lib/esm/type/unit/function/splitUnit.js

@@ -25,7 +25,7 @@ export var createSplitUnit = /* #__PURE__ */factory(name, dependencies, _ref =>
    * @return {Array} An array of units.
    */
   return typed(name, {
-    'Unit, Array': function UnitArray(unit, parts) {
+    'Unit, Array': function Unit_Array(unit, parts) {
       return unit.splitUnit(parts);
     }
   });

package/lib/esm/type/unit/function/unit.js

@@ -48,10 +48,10 @@ export var createUnitFunction = /* #__PURE__ */factory(name, dependencies, _ref
         allowNoUnits: true
       }); // a unit with value, like '5cm'
     },
-    'number | BigNumber | Fraction | Complex, string | Unit': function numberBigNumberFractionComplexStringUnit(value, unit) {
+    'number | BigNumber | Fraction | Complex, string | Unit': function number__BigNumber__Fraction__Complex_string__Unit(value, unit) {
       return new Unit(value, unit);
     },
-    'number | BigNumber | Fraction': function numberBigNumberFraction(value) {
+    'number | BigNumber | Fraction': function number__BigNumber__Fraction(value) {
       // dimensionless
       return new Unit(value);
     },

package/lib/esm/utils/array.js

@@ -780,6 +780,32 @@ export function stretch(arrayToStretch, sizeToStretch, dimToStretch) {
   return concat(...Array(sizeToStretch).fill(arrayToStretch), dimToStretch);
 }
 
+/**
+* Retrieves a single element from an array given an index.
+*
+* @param {Array} array - The array from which to retrieve the value.
+* @param {Array<number>} idx - An array of indices specifying the position of the desired element in each dimension.
+* @returns {*} - The value at the specified position in the array.
+*
+* @example
+* const arr = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]];
+* const index = [1, 0, 1];
+* console.log(getValue(arr, index)); // 6
+*/
+export function get(array, index) {
+  if (!Array.isArray(array)) {
+    throw new Error('Array expected');
+  }
+  var size = arraySize(array);
+  if (index.length !== size.length) {
+    throw new DimensionError(index.length, size.length);
+  }
+  for (var x = 0; x < index.length; x++) {
+    validateIndex(index[x], size[x]);
+  }
+  return index.reduce((acc, curr) => acc[curr], array);
+}
+
 /**
  * Deep clones a multidimensional array
  * @param {Array} array

package/lib/esm/utils/collection.js

@@ -78,7 +78,7 @@ export function reduce(mat, dim, callback) {
     throw new IndexError(dim, size.length);
   }
   if (isMatrix(mat)) {
-    return mat.create(_reduce(mat.valueOf(), dim, callback));
+    return mat.create(_reduce(mat.valueOf(), dim, callback), mat.datatype());
   } else {
     return _reduce(mat, dim, callback);
   }

package/lib/esm/utils/function.js

@@ -83,17 +83,4 @@ export function memoizeCompare(fn, isEqual) {
   };
   memoize.cache = [];
   return memoize;
-}
-
-/**
- * Find the maximum number of arguments expected by a typed function.
- * @param {function} fn   A typed function
- * @return {number} Returns the maximum number of expected arguments.
- *                  Returns -1 when no signatures where found on the function.
- */
-export function maxArgumentCount(fn) {
-  return Object.keys(fn.signatures || {}).reduce(function (args, signature) {
-    var count = (signature.match(/,/g) || []).length + 1;
-    return Math.max(args, count);
-  }, -1);
 }

package/lib/esm/utils/is.js

@@ -12,6 +12,7 @@
 //   for security reasons, so these functions are not exposed in the expression
 //   parser.
 
+import { ObjectWrappingMap } from './map.js';
 export function isNumber(x) {
   return typeof x === 'number';
 }
@@ -88,6 +89,29 @@ export function isRegExp(x) {
 export function isObject(x) {
   return !!(x && typeof x === 'object' && x.constructor === Object && !isComplex(x) && !isFraction(x));
 }
+
+/**
+ * Returns `true` if the passed object appears to be a Map (i.e. duck typing).
+ *
+ * Methods looked for are `get`, `set`, `keys` and `has`.
+ *
+ * @param {Map | object} object
+ * @returns
+ */
+export function isMap(object) {
+  // We can use the fast instanceof, or a slower duck typing check.
+  // The duck typing method needs to cover enough methods to not be confused with DenseMatrix.
+  if (!object) {
+    return false;
+  }
+  return object instanceof Map || object instanceof ObjectWrappingMap || typeof object.set === 'function' && typeof object.get === 'function' && typeof object.keys === 'function' && typeof object.has === 'function';
+}
+export function isPartitionedMap(object) {
+  return isMap(object) && isMap(object.a) && isMap(object.b);
+}
+export function isObjectWrappingMap(object) {
+  return isMap(object) && isObject(object.wrappedObject);
+}
 export function isNull(x) {
   return x === null;
 }