mathjs 13.0.3 → 13.1.1

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

@@ -21,11 +21,11 @@ const createHypot = exports.createHypot = /* #__PURE__ */(0, _factory.factory)(n
     isPositive
   } = _ref;
   /**
-   * Calculate the hypotenusa of a list with values. The hypotenusa is defined as:
+   * Calculate the hypotenuse of a list with values. The hypotenuse is defined as:
    *
    *     hypot(a, b, c, ...) = sqrt(a^2 + b^2 + c^2 + ...)
    *
-   * For matrix input, the hypotenusa is calculated for all values in the matrix.
+   * For matrix input, the hypotenuse is calculated for all values in the matrix.
    *
    * Syntax:
    *
@@ -55,7 +55,7 @@ const createHypot = exports.createHypot = /* #__PURE__ */(0, _factory.factory)(n
   });
 
   /**
-   * Calculate the hypotenusa for an Array with values
+   * Calculate the hypotenuse for an Array with values
    * @param {Array.<number | BigNumber>} args
    * @return {number | BigNumber} Returns the result
    * @private

package/lib/cjs/function/matrix/apply.js

@@ -57,7 +57,7 @@ const createApply = exports.createApply = /* #__PURE__ */(0, _factory.factory)(n
         throw new _IndexError.IndexError(dim, size.length);
       }
       if ((0, _is.isMatrix)(mat)) {
-        return mat.create(_apply(mat.valueOf(), dim, callback));
+        return mat.create(_apply(mat.valueOf(), dim, callback), mat.datatype());
       } else {
         return _apply(mat, dim, callback);
       }

package/lib/cjs/function/matrix/fft.js

@@ -25,7 +25,7 @@ const createFft = exports.createFft = /* #__PURE__ */(0, _factory.factory)(name,
     log2
   } = _ref;
   /**
-   * Calculate N-dimensional fourier transform
+   * Calculate N-dimensional Fourier transform
    *
    * Syntax:
    *
@@ -41,12 +41,12 @@ const createFft = exports.createFft = /* #__PURE__ */(0, _factory.factory)(name,
    *      ifft
    *
    * @param {Array | Matrix} arr    An array or matrix
-   * @return {Array | Matrix}       N-dimensional fourier transformation of the array
+   * @return {Array | Matrix}       N-dimensional Fourier transformation of the array
    */
   return typed(name, {
     Array: _ndFft,
     Matrix: function (matrix) {
-      return matrix.create(_ndFft(matrix.toArray()));
+      return matrix.create(_ndFft(matrix.valueOf()), matrix.datatype());
     }
   });
 

package/lib/cjs/function/matrix/filter.js

@@ -45,11 +45,11 @@ const createFilter = exports.createFilter = /* #__PURE__ */(0, _factory.factory)
   return typed('filter', {
     'Array, function': _filterCallback,
     'Matrix, function': function (x, test) {
-      return x.create(_filterCallback(x.toArray(), test));
+      return x.create(_filterCallback(x.valueOf(), 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.valueOf(), test), x.datatype());
     }
   });
 });

package/lib/cjs/function/matrix/flatten.js

@@ -7,11 +7,10 @@ exports.createFlatten = void 0;
 var _array = require("../../utils/array.js");
 var _factory = require("../../utils/factory.js");
 const name = 'flatten';
-const dependencies = ['typed', 'matrix'];
+const dependencies = ['typed'];
 const createFlatten = exports.createFlatten = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
   let {
-    typed,
-    matrix
+    typed
   } = _ref;
   /**
    * Flatten a multidimensional matrix into a single dimensional matrix.
@@ -37,9 +36,9 @@ const createFlatten = exports.createFlatten = /* #__PURE__ */(0, _factory.factor
       return (0, _array.flatten)(x);
     },
     Matrix: function (x) {
-      const flat = (0, _array.flatten)(x.toArray());
-      // TODO: return the same matrix type as x (Dense or Sparse Matrix)
-      return matrix(flat);
+      // Return the same matrix type as x (Dense or Sparse Matrix)
+      // Return the same data type as x
+      return x.create((0, _array.flatten)(x.toArray()), x.datatype());
     }
   });
 });

package/lib/cjs/function/matrix/ifft.js

@@ -17,7 +17,7 @@ const createIfft = exports.createIfft = /* #__PURE__ */(0, _factory.factory)(nam
     conj
   } = _ref;
   /**
-   * Calculate N-dimensional inverse fourier transform
+   * Calculate N-dimensional inverse Fourier transform
    *
    * Syntax:
    *
@@ -32,7 +32,7 @@ const createIfft = exports.createIfft = /* #__PURE__ */(0, _factory.factory)(nam
    *      fft
    *
    * @param {Array | Matrix} arr    An array or matrix
-   * @return {Array | Matrix}       N-dimensional fourier transformation of the array
+   * @return {Array | Matrix}       N-dimensional Fourier transformation of the array
    */
   return typed(name, {
     'Array | Matrix': function (arr) {

package/lib/cjs/function/matrix/kron.js

@@ -15,7 +15,7 @@ const createKron = exports.createKron = /* #__PURE__ */(0, _factory.factory)(nam
     multiplyScalar
   } = _ref;
   /**
-     * Calculates the kronecker product of 2 matrices or vectors.
+     * Calculates the Kronecker product of 2 matrices or vectors.
      *
      * NOTE: If a one dimensional vector / matrix is given, it will be
      * wrapped so its two dimensions.
@@ -39,7 +39,7 @@ const createKron = exports.createKron = /* #__PURE__ */(0, _factory.factory)(nam
      *
      * @param  {Array | Matrix} x     First vector
      * @param  {Array | Matrix} y     Second vector
-     * @return {Array | Matrix}       Returns the kronecker product of `x` and `y`
+     * @return {Array | Matrix}       Returns the Kronecker product of `x` and `y`
      */
   return typed(name, {
     'Matrix, Matrix': function (x, y) {
@@ -55,10 +55,10 @@ const createKron = exports.createKron = /* #__PURE__ */(0, _factory.factory)(nam
   });
 
   /**
-     * Calculate the kronecker product of two matrices / vectors
+     * Calculate the Kronecker product of two matrices / vectors
      * @param {Array} a  First vector
      * @param {Array} b  Second vector
-     * @returns {Array} Returns the kronecker product of x and y
+     * @returns {Array} Returns the Kronecker product of x and y
      * @private
      */
   function _kron(a, b) {

package/lib/cjs/function/matrix/map.js

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.createMap = void 0;
 var _applyCallback = require("../../utils/applyCallback.js");
+var _array = require("../../utils/array.js");
 var _factory = require("../../utils/factory.js");
 const name = 'map';
 const dependencies = ['typed'];
@@ -16,9 +17,12 @@ const createMap = exports.createMap = /* #__PURE__ */(0, _factory.factory)(name,
    * Create a new matrix or array with the results of a callback function executed on
    * each entry of a given matrix/array.
    *
-   * For each entry of the input, the callback is invoked with three arguments:
-   * the value of the entry, the index at which that entry occurs, and the full
-   * matrix/array being traversed. Note that because the matrix/array might be
+   * For each entry of the input,
+   *
+   * the callback is invoked with 2N + 1 arguments:
+   * the N values of the entry, the index at which that entry occurs, and the N full
+   * broadcasted matrix/array being traversed where N is the number of matrices being traversed.
+   * Note that because the matrix/array might be
    * multidimensional, the "index" argument is always an array of numbers giving
    * the index in each dimension. This is true even for vectors: the "index"
    * argument is an array of length 1, rather than simply a number.
@@ -26,17 +30,23 @@ const createMap = exports.createMap = /* #__PURE__ */(0, _factory.factory)(name,
    * Syntax:
    *
    *    math.map(x, callback)
+   *    math.map(x, y, ..., callback)
    *
    * Examples:
    *
    *    math.map([1, 2, 3], function(value) {
    *      return value * value
    *    })  // returns [1, 4, 9]
+   *    math.map([1, 2], [3, 4], function(a, b) {
+   *     return a + b
+   *    })  // returns [4, 6]
    *
    *    // The callback is normally called with three arguments:
    *    //    callback(value, index, Array)
    *    // If you want to call with only one argument, use:
    *    math.map([1, 2, 3], x => math.format(x)) // returns ['1', '2', '3']
+   *    // It can also be called with 2N + 1 arguments: for N arrays
+   *    //    callback(value1, value2, index, BroadcastedArray1, BroadcastedArray2)
    *
    * See also:
    *
@@ -49,11 +59,82 @@ const createMap = exports.createMap = /* #__PURE__ */(0, _factory.factory)(name,
    *     Transformed map of x; always has the same type and shape as x
    */
   return typed(name, {
-    'Array, function': _map,
+    'Array, function': _mapArray,
     'Matrix, function': function (x, callback) {
       return x.map(callback);
-    }
+    },
+    'Array|Matrix, Array|Matrix, ...Array|Matrix|function': (A, B, rest) => _mapMultiple([A, B, ...rest.slice(0, rest.length - 1)], rest[rest.length - 1])
   });
+
+  /**
+  * Maps over multiple arrays or matrices.
+  *
+  * @param {Array<Array|Matrix>} Arrays - An array of arrays or matrices to map over.
+  * @param {function} multiCallback - The callback function to apply to each element.
+  * @throws {Error} If the last argument is not a callback function.
+  * @returns {Array|Matrix} A new array or matrix with each element being the result of the callback function.
+  *
+  * @example
+  * _mapMultiple([[1, 2, 3], [4, 5, 6]], (a, b) => a + b); // Returns [5, 7, 9]
+  */
+  function _mapMultiple(Arrays, multiCallback) {
+    if (typeof multiCallback !== 'function') {
+      throw new Error('Last argument must be a callback function');
+    }
+    const firstArrayIsMatrix = Arrays[0].isMatrix;
+    const newSize = (0, _array.broadcastSizes)(...Arrays.map(M => M.isMatrix ? M.size() : (0, _array.arraySize)(M)));
+    const _get = firstArrayIsMatrix ? (matrix, idx) => matrix.get(idx) : _array.get;
+    const broadcastedArrays = firstArrayIsMatrix ? Arrays.map(M => M.isMatrix ? M.create((0, _array.broadcastTo)(M.toArray(), newSize), M.datatype()) : Arrays[0].create((0, _array.broadcastTo)(M.valueOf(), newSize))) : Arrays.map(M => M.isMatrix ? (0, _array.broadcastTo)(M.toArray(), newSize) : (0, _array.broadcastTo)(M, newSize));
+    let callback;
+    if (typed.isTypedFunction(multiCallback)) {
+      const firstIndex = newSize.map(() => 0);
+      const firstValues = broadcastedArrays.map(array => _get(array, firstIndex));
+      const callbackCase = _getTypedCallbackCase(multiCallback, firstValues, firstIndex, broadcastedArrays);
+      callback = _getLimitedCallback(callbackCase);
+    } else {
+      const numberOfArrays = Arrays.length;
+      const callbackCase = _getCallbackCase(multiCallback, numberOfArrays);
+      callback = _getLimitedCallback(callbackCase);
+    }
+    const broadcastedArraysCallback = (x, idx) => callback([x, ...broadcastedArrays.slice(1).map(Array => _get(Array, idx))], idx);
+    if (firstArrayIsMatrix) {
+      return broadcastedArrays[0].map(broadcastedArraysCallback);
+    } else {
+      return _mapArray(broadcastedArrays[0], broadcastedArraysCallback);
+    }
+    function _getLimitedCallback(callbackCase) {
+      switch (callbackCase) {
+        case 0:
+          return x => multiCallback(...x);
+        case 1:
+          return (x, idx) => multiCallback(...x, idx);
+        case 2:
+          return (x, idx) => multiCallback(...x, idx, ...broadcastedArrays);
+      }
+    }
+    function _getCallbackCase(callback, numberOfArrays) {
+      if (callback.length > numberOfArrays + 1) {
+        return 2;
+      }
+      if (callback.length === numberOfArrays + 1) {
+        return 1;
+      }
+      return 0;
+    }
+    function _getTypedCallbackCase(callback, values, idx, arrays) {
+      if (typed.resolve(callback, [...values, idx, ...arrays]) !== null) {
+        return 2;
+      }
+      if (typed.resolve(callback, [...values, idx]) !== null) {
+        return 1;
+      }
+      if (typed.resolve(callback, values) !== null) {
+        return 0;
+      }
+      // this should never happen
+      return 0;
+    }
+  }
 });
 
 /**
@@ -63,17 +144,27 @@ const createMap = exports.createMap = /* #__PURE__ */(0, _factory.factory)(name,
  * @return {Array}
  * @private
  */
-function _map(array, callback) {
-  const recurse = function (value, index) {
-    if (Array.isArray(value)) {
-      return value.map(function (child, i) {
-        // we create a copy of the index array and append the new index value
-        return recurse(child, index.concat(i));
-      });
-    } else {
-      // invoke the callback function with the right number of arguments
-      return (0, _applyCallback.applyCallback)(callback, value, index, array, 'map');
-    }
-  };
-  return recurse(array, []);
+function _mapArray(array, callback) {
+  return _recurse(array, [], array, callback);
+}
+
+/**
+ * Recursive function to map a multi-dimensional array.
+ *
+ * @param {*} value - The current value being processed in the array.
+ * @param {Array} index - The index of the current value being processed in the array.
+ * @param {Array} array - The array being processed.
+ * @param {Function} callback - Function that produces the element of the new Array, taking three arguments: the value of the element, the index of the element, and the Array being processed.
+ * @returns {*} The new array with each element being the result of the callback function.
+ */
+function _recurse(value, index, array, callback) {
+  if (Array.isArray(value)) {
+    return value.map(function (child, i) {
+      // we create a copy of the index array and append the new index value
+      return _recurse(child, index.concat(i), array, callback);
+    });
+  } else {
+    // invoke the callback function with the right number of arguments
+    return (0, _applyCallback.applyCallback)(callback, value, index, array, 'map');
+  }
 }

package/lib/cjs/function/matrix/size.js

@@ -24,12 +24,12 @@ const createSize = exports.createSize = /* #__PURE__ */(0, _factory.factory)(nam
    *
    * Examples:
    *
-   *     math.size(2.3)                  // returns []
-   *     math.size('hello world')        // returns [11]
+   *     math.size(2.3)                       // returns []
+   *     math.size('hello world')             // returns [11]
    *
    *     const A = [[1, 2, 3], [4, 5, 6]]
-   *     math.size(A)                    // returns [2, 3]
-   *     math.size(math.range(1,6))      // returns [5]
+   *     math.size(A)                         // returns [2, 3]
+   *     math.size(math.range(1,6).toArray()) // returns [5]
    *
    * See also:
    *
@@ -40,15 +40,15 @@ const createSize = exports.createSize = /* #__PURE__ */(0, _factory.factory)(nam
    */
   return typed(name, {
     Matrix: function (x) {
-      return x.create(x.size());
+      return x.create(x.size(), 'number');
     },
     Array: _array.arraySize,
     string: function (x) {
-      return config.matrix === 'Array' ? [x.length] : matrix([x.length]);
+      return config.matrix === 'Array' ? [x.length] : matrix([x.length], 'dense', 'number');
     },
     'number | Complex | BigNumber | Unit | boolean | null': function (x) {
       // scalar
-      return config.matrix === 'Array' ? [] : matrix ? matrix([]) : (0, _noop.noMatrix)();
+      return config.matrix === 'Array' ? [] : matrix ? matrix([], 'dense', 'number') : (0, _noop.noMatrix)();
     }
   });
 });

package/lib/cjs/function/matrix/squeeze.js

@@ -8,11 +8,10 @@ var _object = require("../../utils/object.js");
 var _array = require("../../utils/array.js");
 var _factory = require("../../utils/factory.js");
 const name = 'squeeze';
-const dependencies = ['typed', 'matrix'];
+const dependencies = ['typed'];
 const createSqueeze = exports.createSqueeze = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
   let {
-    typed,
-    matrix
+    typed
   } = _ref;
   /**
    * Squeeze a matrix, remove inner and outer singleton dimensions from a matrix.
@@ -50,7 +49,7 @@ const createSqueeze = exports.createSqueeze = /* #__PURE__ */(0, _factory.factor
     Matrix: function (x) {
       const res = (0, _array.squeeze)(x.toArray());
       // FIXME: return the same type of matrix as the input
-      return Array.isArray(res) ? matrix(res) : res;
+      return Array.isArray(res) ? x.create(res, x.datatype()) : res;
     },
     any: function (x) {
       // scalar

package/lib/cjs/function/probability/random.js

@@ -66,7 +66,7 @@ const createRandom = exports.createRandom = /* #__PURE__ */(0, _factory.factory)
   });
   function _randomMatrix(size, min, max) {
     const res = (0, _randomMatrix2.randomMatrix)(size.valueOf(), () => _random(min, max));
-    return (0, _is.isMatrix)(size) ? size.create(res) : res;
+    return (0, _is.isMatrix)(size) ? size.create(res, 'number') : res;
   }
   function _random(min, max) {
     return min + rng() * (max - min);

package/lib/cjs/function/probability/randomInt.js

@@ -65,7 +65,7 @@ const createRandomInt = exports.createRandomInt = /* #__PURE__ */(0, _factory.fa
   });
   function _randomIntMatrix(size, min, max) {
     const res = (0, _randomMatrix.randomMatrix)(size.valueOf(), () => _randomInt(min, max));
-    return (0, _is.isMatrix)(size) ? size.create(res) : res;
+    return (0, _is.isMatrix)(size) ? size.create(res, 'number') : res;
   }
   function _randomInt(min, max) {
     return Math.floor(min + rng() * (max - min));

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

@@ -48,12 +48,12 @@ const createCumSum = exports.createCumSum = /* #__PURE__ */(0, _factory.factory)
     // sum([a, b, c, d, ...])
     Array: _cumsum,
     Matrix: function (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 (matrix, dim) {
-      return matrix.create(_ncumSumDim(matrix.valueOf(), dim));
+      return matrix.create(_ncumSumDim(matrix.valueOf(), dim), matrix.datatype());
     },
     // cumsum(a, b, c, d, ...)
     '...': function (args) {

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

@@ -16,10 +16,10 @@ const createAcoth = exports.createAcoth = /* #__PURE__ */(0, _factory.factory)(n
     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/cjs/function/trigonometry/acsch.js

@@ -14,10 +14,10 @@ const createAcsch = exports.createAcsch = /* #__PURE__ */(0, _factory.factory)(n
     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/cjs/header.js

@@ -6,8 +6,8 @@
  * It features real and complex numbers, units, matrices, a large set of
  * mathematical functions, and a flexible expression parser.
  *
- * @version 13.0.3
- * @date    2024-07-19
+ * @version 13.1.1
+ * @date    2024-08-27
  *
  * @license
  * Copyright (C) 2013-2024 Jos de Jong <wjosdejong@gmail.com>

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

@@ -11,7 +11,7 @@ var _number = require("../../utils/number.js");
 var _object = require("../../utils/object.js");
 var _DimensionError = require("../../error/DimensionError.js");
 var _factory = require("../../utils/factory.js");
-var _function = require("../../utils/function.js");
+var _applyCallback = require("../../utils/applyCallback.js");
 const name = 'DenseMatrix';
 const dependencies = ['Matrix'];
 const createDenseMatrixClass = exports.createDenseMatrixClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
@@ -172,24 +172,7 @@ const createDenseMatrixClass = exports.createDenseMatrixClass = /* #__PURE__ */(
    * @return {*} value
    */
   DenseMatrix.prototype.get = function (index) {
-    if (!(0, _is.isArray)(index)) {
-      throw new TypeError('Array expected');
-    }
-    if (index.length !== this._size.length) {
-      throw new _DimensionError.DimensionError(index.length, this._size.length);
-    }
-
-    // check index
-    for (let x = 0; x < index.length; x++) {
-      (0, _array.validateIndex)(index[x], this._size[x]);
-    }
-    let data = this._data;
-    for (let i = 0, ii = index.length; i < ii; i++) {
-      const indexI = index[i];
-      (0, _array.validateIndex)(indexI, data.length);
-      data = data[indexI];
-    }
-    return data;
+    return (0, _array.get)(this._data, index);
   };
 
   /**
@@ -552,7 +535,6 @@ const createDenseMatrixClass = exports.createDenseMatrixClass = /* #__PURE__ */(
   DenseMatrix.prototype.map = function (callback) {
     // matrix instance
     const me = this;
-    const args = (0, _function.maxArgumentCount)(callback);
     const recurse = function (value, index) {
       if ((0, _is.isArray)(value)) {
         return value.map(function (child, i) {
@@ -560,14 +542,7 @@ const createDenseMatrixClass = exports.createDenseMatrixClass = /* #__PURE__ */(
         });
       } 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 (0, _applyCallback.applyCallback)(callback, value, index, me, 'map');
       }
     };
 

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

@@ -11,7 +11,7 @@ var _object = require("../../utils/object.js");
 var _array = require("../../utils/array.js");
 var _factory = require("../../utils/factory.js");
 var _DimensionError = require("../../error/DimensionError.js");
-var _function = require("../../utils/function.js");
+var _applyCallback = require("../../utils/applyCallback.js");
 const name = 'SparseMatrix';
 const dependencies = ['typed', 'equalScalar', 'Matrix'];
 const createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
@@ -879,12 +879,9 @@ const createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ *
     const rows = this._size[0];
     const columns = this._size[1];
     // invoke callback
-    const args = (0, _function.maxArgumentCount)(callback);
     const invoke = function (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 (0, _applyCallback.applyCallback)(callback, v, [i, j], me, 'map');
     };
     // invoke _map
     return _map(this, 0, rows - 1, 0, columns - 1, invoke, skipZeros);
@@ -914,11 +911,11 @@ const createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ *
     // invoke callback
     const invoke = function (v, x, y) {
       // invoke callback
-      v = callback(v, x, y);
+      const 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/cjs/utils/array.js

@@ -16,6 +16,7 @@ exports.filterRegExp = filterRegExp;
 exports.flatten = flatten;
 exports.forEach = forEach;
 exports.generalize = generalize;
+exports.get = get;
 exports.getArrayDataType = getArrayDataType;
 exports.identify = identify;
 exports.initial = initial;
@@ -813,6 +814,32 @@ 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
+*/
+function get(array, index) {
+  if (!Array.isArray(array)) {
+    throw new Error('Array expected');
+  }
+  const size = arraySize(array);
+  if (index.length !== size.length) {
+    throw new _DimensionError.DimensionError(index.length, size.length);
+  }
+  for (let 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/cjs/utils/collection.js

@@ -87,7 +87,7 @@ function reduce(mat, dim, callback) {
     throw new _IndexError.IndexError(dim, size.length);
   }
   if ((0, _is.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/cjs/utils/customs.js

@@ -4,9 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.getSafeMethod = getSafeMethod;
-exports.getSafeProperties = getSafeProperties;
 exports.getSafeProperty = getSafeProperty;
-exports.hasSafeProperty = hasSafeProperty;
 exports.isPlainObject = isPlainObject;
 exports.isSafeMethod = isSafeMethod;
 exports.isSafeProperty = isSafeProperty;
@@ -22,7 +20,7 @@ var _object = require("./object.js");
  */
 function getSafeProperty(object, prop) {
   // only allow getting safe properties of a plain object
-  if (isPlainObject(object) && isSafeProperty(object, prop)) {
+  if (isSafeProperty(object, prop)) {
     return object[prop];
   }
   if (typeof object[prop] === 'function' && isSafeMethod(object, prop)) {
@@ -43,27 +41,22 @@ function getSafeProperty(object, prop) {
 // TODO: merge this function into access.js?
 function setSafeProperty(object, prop, value) {
   // only allow setting safe properties of a plain object
-  if (isPlainObject(object) && isSafeProperty(object, prop)) {
+  if (isSafeProperty(object, prop)) {
     object[prop] = value;
     return value;
   }
   throw new Error('No access to property "' + prop + '"');
 }
-function getSafeProperties(object) {
-  return Object.keys(object).filter(prop => (0, _object.hasOwnProperty)(object, prop));
-}
-function hasSafeProperty(object, prop) {
-  return prop in object;
-}
 
 /**
- * Test whether a property is safe to use for an object.
+ * Test whether a property is safe to use on an object or Array.
  * For example .toString and .constructor are not safe
+ * @param {Object | Array} object
  * @param {string} prop
  * @return {boolean} Returns true when safe
  */
 function isSafeProperty(object, prop) {
-  if (!object || typeof object !== 'object') {
+  if (!isPlainObject(object) && !Array.isArray(object)) {
     return false;
   }
   // SAFE: whitelisted