mathjs 13.0.2 → 13.1.0

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

@@ -9,7 +9,7 @@ export var createKron = /* #__PURE__ */factory(name, dependencies, _ref => {
     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.
@@ -33,26 +33,26 @@ export var createKron = /* #__PURE__ */factory(name, dependencies, _ref => {
      *
      * @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 MatrixMatrix(x, y) {
+    'Matrix, Matrix': function Matrix_Matrix(x, y) {
       return matrix(_kron(x.toArray(), y.toArray()));
     },
-    'Matrix, Array': function MatrixArray(x, y) {
+    'Matrix, Array': function Matrix_Array(x, y) {
       return matrix(_kron(x.toArray(), y));
     },
-    'Array, Matrix': function ArrayMatrix(x, y) {
+    'Array, Matrix': function Array_Matrix(x, y) {
       return matrix(_kron(x, y.toArray()));
     },
     'Array, Array': _kron
   });
 
   /**
-     * 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/esm/function/matrix/map.js

@@ -1,4 +1,5 @@
 import { applyCallback } from '../../utils/applyCallback.js';
+import { arraySize, broadcastSizes, broadcastTo, get } from '../../utils/array.js';
 import { factory } from '../../utils/factory.js';
 var name = 'map';
 var dependencies = ['typed'];
@@ -10,9 +11,12 @@ export var createMap = /* #__PURE__ */factory(name, dependencies, _ref => {
    * 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.
@@ -20,17 +24,23 @@ export var createMap = /* #__PURE__ */factory(name, dependencies, _ref => {
    * 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:
    *
@@ -43,11 +53,82 @@ export var createMap = /* #__PURE__ */factory(name, dependencies, _ref => {
    *     Transformed map of x; always has the same type and shape as x
    */
   return typed(name, {
-    'Array, function': _map,
-    'Matrix, function': function MatrixFunction(x, callback) {
+    'Array, function': _mapArray,
+    'Matrix, function': function Matrix_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');
+    }
+    var firstArrayIsMatrix = Arrays[0].isMatrix;
+    var newSize = broadcastSizes(...Arrays.map(M => M.isMatrix ? M.size() : arraySize(M)));
+    var _get = firstArrayIsMatrix ? (matrix, idx) => matrix.get(idx) : get;
+    var broadcastedArrays = firstArrayIsMatrix ? Arrays.map(M => M.isMatrix ? M.create(broadcastTo(M.toArray(), newSize), M.datatype()) : Arrays[0].create(broadcastTo(M.valueOf(), newSize))) : Arrays.map(M => M.isMatrix ? broadcastTo(M.toArray(), newSize) : broadcastTo(M, newSize));
+    var callback;
+    if (typed.isTypedFunction(multiCallback)) {
+      var firstIndex = newSize.map(() => 0);
+      var firstValues = broadcastedArrays.map(array => _get(array, firstIndex));
+      var callbackCase = _getTypedCallbackCase(multiCallback, firstValues, firstIndex, broadcastedArrays);
+      callback = _getLimitedCallback(callbackCase);
+    } else {
+      var numberOfArrays = Arrays.length;
+      var _callbackCase = _getCallbackCase(multiCallback, numberOfArrays);
+      callback = _getLimitedCallback(_callbackCase);
+    }
+    var 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;
+    }
+  }
 });
 
 /**
@@ -57,17 +138,27 @@ export var createMap = /* #__PURE__ */factory(name, dependencies, _ref => {
  * @return {Array}
  * @private
  */
-function _map(array, callback) {
-  var recurse = function recurse(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 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 applyCallback(callback, value, index, array, 'map');
+  }
 }

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

@@ -37,22 +37,22 @@ export var createMatrixFromFunction = /* #__PURE__ */factory(name, dependencies,
    * @return {Array | Matrix} Returns the created matrix
    */
   return typed(name, {
-    'Array | Matrix, function, string, string': function ArrayMatrixFunctionStringString(size, fn, format, datatype) {
+    'Array | Matrix, function, string, string': function Array__Matrix_function_string_string(size, fn, format, datatype) {
       return _create(size, fn, format, datatype);
     },
-    'Array | Matrix, function, string': function ArrayMatrixFunctionString(size, fn, format) {
+    'Array | Matrix, function, string': function Array__Matrix_function_string(size, fn, format) {
       return _create(size, fn, format);
     },
-    'Matrix, function': function MatrixFunction(size, fn) {
+    'Matrix, function': function Matrix_function(size, fn) {
       return _create(size, fn, 'dense');
     },
-    'Array, function': function ArrayFunction(size, fn) {
+    'Array, function': function Array_function(size, fn) {
       return _create(size, fn, 'dense').toArray();
     },
-    'Array | Matrix, string, function': function ArrayMatrixStringFunction(size, format, fn) {
+    'Array | Matrix, string, function': function Array__Matrix_string_function(size, format, fn) {
       return _create(size, fn, format);
     },
-    'Array | Matrix, string, string, function': function ArrayMatrixStringStringFunction(size, format, datatype, fn) {
+    'Array | Matrix, string, string, function': function Array__Matrix_string_string_function(size, format, datatype, fn) {
       return _create(size, fn, format, datatype);
     }
   });

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

@@ -51,7 +51,7 @@ export var createOnes = /* #__PURE__ */factory(name, dependencies, _ref => {
     },
     // math.ones(m, n, p, ..., format)
     // TODO: more accurate signature '...number | BigNumber, string' as soon as typed-function supports this
-    '...number | BigNumber | string': function numberBigNumberString(size) {
+    '...number | BigNumber | string': function number__BigNumber__string(size) {
       var last = size[size.length - 1];
       if (typeof last === 'string') {
         var format = size.pop();
@@ -67,7 +67,7 @@ export var createOnes = /* #__PURE__ */factory(name, dependencies, _ref => {
       var format = size.storage();
       return _ones(size.valueOf(), format);
     },
-    'Array | Matrix, string': function ArrayMatrixString(size, format) {
+    'Array | Matrix, string': function Array__Matrix_string(size, format) {
       return _ones(size.valueOf(), format);
     }
   });

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

@@ -51,10 +51,10 @@ export var createPartitionSelect = /* #__PURE__ */factory(name, dependencies, _r
    * @return {*} Returns the kth lowest value.
    */
   return typed(name, {
-    'Array | Matrix, number': function ArrayMatrixNumber(x, k) {
+    'Array | Matrix, number': function Array__Matrix_number(x, k) {
       return _partitionSelect(x, k, asc);
     },
-    'Array | Matrix, number, string': function ArrayMatrixNumberString(x, k, compare) {
+    'Array | Matrix, number, string': function Array__Matrix_number_string(x, k, compare) {
       if (compare === 'asc') {
         return _partitionSelect(x, k, asc);
       } else if (compare === 'desc') {

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

@@ -41,7 +41,7 @@ export var createPinv = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @return {number | Complex | Array | Matrix} The inverse of `x`.
    */
   return typed(name, {
-    'Array | Matrix': function ArrayMatrix(x) {
+    'Array | Matrix': function Array__Matrix(x) {
       var size = isMatrix(x) ? x.size() : arraySize(x);
       switch (size.length) {
         case 1:

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

@@ -65,36 +65,36 @@ export var createRange = /* #__PURE__ */factory(name, dependencies, _ref => {
     // TODO: a number or boolean should not be converted to string here
     string: _strRange,
     'string, boolean': _strRange,
-    'number, number': function numberNumber(start, end) {
+    'number, number': function number_number(start, end) {
       return _out(_range(start, end, 1, false));
     },
-    'number, number, number': function numberNumberNumber(start, end, step) {
+    'number, number, number': function number_number_number(start, end, step) {
       return _out(_range(start, end, step, false));
     },
-    'number, number, boolean': function numberNumberBoolean(start, end, includeEnd) {
+    'number, number, boolean': function number_number_boolean(start, end, includeEnd) {
       return _out(_range(start, end, 1, includeEnd));
     },
-    'number, number, number, boolean': function numberNumberNumberBoolean(start, end, step, includeEnd) {
+    'number, number, number, boolean': function number_number_number_boolean(start, end, step, includeEnd) {
       return _out(_range(start, end, step, includeEnd));
     },
-    'BigNumber, BigNumber': function BigNumberBigNumber(start, end) {
+    'BigNumber, BigNumber': function BigNumber_BigNumber(start, end) {
       var BigNumber = start.constructor;
       return _out(_range(start, end, new BigNumber(1), false));
     },
-    'BigNumber, BigNumber, BigNumber': function BigNumberBigNumberBigNumber(start, end, step) {
+    'BigNumber, BigNumber, BigNumber': function BigNumber_BigNumber_BigNumber(start, end, step) {
       return _out(_range(start, end, step, false));
     },
-    'BigNumber, BigNumber, boolean': function BigNumberBigNumberBoolean(start, end, includeEnd) {
+    'BigNumber, BigNumber, boolean': function BigNumber_BigNumber_boolean(start, end, includeEnd) {
       var BigNumber = start.constructor;
       return _out(_range(start, end, new BigNumber(1), includeEnd));
     },
-    'BigNumber, BigNumber, BigNumber, boolean': function BigNumberBigNumberBigNumberBoolean(start, end, step, includeEnd) {
+    'BigNumber, BigNumber, BigNumber, boolean': function BigNumber_BigNumber_BigNumber_boolean(start, end, step, includeEnd) {
       return _out(_range(start, end, step, includeEnd));
     },
-    'Unit, Unit, Unit': function UnitUnitUnit(start, end, step) {
+    'Unit, Unit, Unit': function Unit_Unit_Unit(start, end, step) {
       return _out(_range(start, end, step, false));
     },
-    'Unit, Unit, Unit, boolean': function UnitUnitUnitBoolean(start, end, step, includeEnd) {
+    'Unit, Unit, Unit, boolean': function Unit_Unit_Unit_boolean(start, end, step, includeEnd) {
       return _out(_range(start, end, step, includeEnd));
     }
   });

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

@@ -48,10 +48,10 @@ export var createReshape = /* #__PURE__ */factory(name, dependencies, _ref => {
    *                                not equal that of the old ones
    */
   return typed(name, {
-    'Matrix, Array': function MatrixArray(x, sizes) {
+    'Matrix, Array': function Matrix_Array(x, sizes) {
       return x.reshape(sizes, true);
     },
-    'Array, Array': function ArrayArray(x, sizes) {
+    'Array, Array': function Array_Array(x, sizes) {
       sizes.forEach(function (size) {
         if (!isInteger(size)) {
           throw new TypeError('Invalid size for dimension: ' + size);

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

@@ -37,21 +37,21 @@ export var createRotate = /* #__PURE__ */factory(name, dependencies, _ref => {
      * @return {Array | Matrix}                              Multiplication of the rotation matrix and w
      */
   return typed(name, {
-    'Array , number | BigNumber | Complex | Unit': function ArrayNumberBigNumberComplexUnit(w, theta) {
+    'Array , number | BigNumber | Complex | Unit': function Array__number__BigNumber__Complex__Unit(w, theta) {
       _validateSize(w, 2);
       var matrixRes = multiply(rotationMatrix(theta), w);
       return matrixRes.toArray();
     },
-    'Matrix , number | BigNumber | Complex | Unit': function MatrixNumberBigNumberComplexUnit(w, theta) {
+    'Matrix , number | BigNumber | Complex | Unit': function Matrix__number__BigNumber__Complex__Unit(w, theta) {
       _validateSize(w, 2);
       return multiply(rotationMatrix(theta), w);
     },
-    'Array, number | BigNumber | Complex | Unit, Array | Matrix': function ArrayNumberBigNumberComplexUnitArrayMatrix(w, theta, v) {
+    'Array, number | BigNumber | Complex | Unit, Array | Matrix': function Array_number__BigNumber__Complex__Unit_Array__Matrix(w, theta, v) {
       _validateSize(w, 3);
       var matrixRes = multiply(rotationMatrix(theta, v), w);
       return matrixRes;
     },
-    'Matrix, number | BigNumber | Complex | Unit, Array | Matrix': function MatrixNumberBigNumberComplexUnitArrayMatrix(w, theta, v) {
+    'Matrix, number | BigNumber | Complex | Unit, Array | Matrix': function Matrix_number__BigNumber__Complex__Unit_Array__Matrix(w, theta, v) {
       _validateSize(w, 3);
       return multiply(rotationMatrix(theta, v), w);
     }

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

@@ -57,28 +57,28 @@ export var createRotationMatrix = /* #__PURE__ */factory(name, dependencies, _re
     string: function string(format) {
       return matrix(format);
     },
-    'number | BigNumber | Complex | Unit': function numberBigNumberComplexUnit(theta) {
+    'number | BigNumber | Complex | Unit': function number__BigNumber__Complex__Unit(theta) {
       return _rotationMatrix2x2(theta, config.matrix === 'Matrix' ? 'dense' : undefined);
     },
-    'number | BigNumber | Complex | Unit, string': function numberBigNumberComplexUnitString(theta, format) {
+    'number | BigNumber | Complex | Unit, string': function number__BigNumber__Complex__Unit_string(theta, format) {
       return _rotationMatrix2x2(theta, format);
     },
-    'number | BigNumber | Complex | Unit, Array': function numberBigNumberComplexUnitArray(theta, v) {
+    'number | BigNumber | Complex | Unit, Array': function number__BigNumber__Complex__Unit_Array(theta, v) {
       var matrixV = matrix(v);
       _validateVector(matrixV);
       return _rotationMatrix3x3(theta, matrixV, undefined);
     },
-    'number | BigNumber | Complex | Unit, Matrix': function numberBigNumberComplexUnitMatrix(theta, v) {
+    'number | BigNumber | Complex | Unit, Matrix': function number__BigNumber__Complex__Unit_Matrix(theta, v) {
       _validateVector(v);
       var storageType = v.storage() || (config.matrix === 'Matrix' ? 'dense' : undefined);
       return _rotationMatrix3x3(theta, v, storageType);
     },
-    'number | BigNumber | Complex | Unit, Array, string': function numberBigNumberComplexUnitArrayString(theta, v, format) {
+    'number | BigNumber | Complex | Unit, Array, string': function number__BigNumber__Complex__Unit_Array_string(theta, v, format) {
       var matrixV = matrix(v);
       _validateVector(matrixV);
       return _rotationMatrix3x3(theta, matrixV, format);
     },
-    'number | BigNumber | Complex | Unit, Matrix, string': function numberBigNumberComplexUnitMatrixString(theta, v, format) {
+    'number | BigNumber | Complex | Unit, Matrix, string': function number__BigNumber__Complex__Unit_Matrix_string(theta, v, format) {
       _validateVector(v);
       return _rotationMatrix3x3(theta, v, format);
     }

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

@@ -34,7 +34,7 @@ export var createRow = /* #__PURE__ */factory(name, dependencies, _ref => {
    */
   return typed(name, {
     'Matrix, number': _row,
-    'Array, number': function ArrayNumber(value, row) {
+    'Array, number': function Array_number(value, row) {
       return _row(matrix(clone(value)), row).valueOf();
     }
   });

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

@@ -18,12 +18,12 @@ export var createSize = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    * 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:
    *
@@ -34,15 +34,15 @@ export var createSize = /* #__PURE__ */factory(name, dependencies, _ref => {
    */
   return typed(name, {
     Matrix: function Matrix(x) {
-      return x.create(x.size());
+      return x.create(x.size(), 'number');
     },
     Array: arraySize,
     string: function string(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 numberComplexBigNumberUnitBooleanNull(x) {
+    'number | Complex | BigNumber | Unit | boolean | null': function number__Complex__BigNumber__Unit__boolean__null(x) {
       // scalar
-      return config.matrix === 'Array' ? [] : matrix ? matrix([]) : noMatrix();
+      return config.matrix === 'Array' ? [] : matrix ? matrix([], 'dense', 'number') : noMatrix();
     }
   });
 });

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

@@ -52,19 +52,19 @@ export var createSort = /* #__PURE__ */factory(name, dependencies, _ref => {
       _matrixIsVector(x);
       return matrix(x.toArray().sort(compareAsc), x.storage());
     },
-    'Array, function': function ArrayFunction(x, _comparator) {
+    'Array, function': function Array_function(x, _comparator) {
       _arrayIsVector(x);
       return x.sort(_comparator);
     },
-    'Matrix, function': function MatrixFunction(x, _comparator) {
+    'Matrix, function': function Matrix_function(x, _comparator) {
       _matrixIsVector(x);
       return matrix(x.toArray().sort(_comparator), x.storage());
     },
-    'Array, string': function ArrayString(x, order) {
+    'Array, string': function Array_string(x, order) {
       _arrayIsVector(x);
       return x.sort(_comparator(order));
     },
-    'Matrix, string': function MatrixString(x, order) {
+    'Matrix, string': function Matrix_string(x, order) {
       _matrixIsVector(x);
       return matrix(x.toArray().sort(_comparator(order)), x.storage());
     }

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

@@ -69,7 +69,7 @@ export var createSqrtm = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @return {Array | Matrix}     The principal square root of matrix `A`
    */
   return typed(name, {
-    'Array | Matrix': function ArrayMatrix(A) {
+    'Array | Matrix': function Array__Matrix(A) {
       var size = isMatrix(A) ? A.size() : arraySize(A);
       switch (size.length) {
         case 1:

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

@@ -2,11 +2,10 @@ import { clone } from '../../utils/object.js';
 import { squeeze as arraySqueeze } from '../../utils/array.js';
 import { factory } from '../../utils/factory.js';
 var name = 'squeeze';
-var dependencies = ['typed', 'matrix'];
+var dependencies = ['typed'];
 export var createSqueeze = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
-    typed,
-    matrix
+    typed
   } = _ref;
   /**
    * Squeeze a matrix, remove inner and outer singleton dimensions from a matrix.
@@ -44,7 +43,7 @@ export var createSqueeze = /* #__PURE__ */factory(name, dependencies, _ref => {
     Matrix: function Matrix(x) {
       var res = arraySqueeze(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 any(x) {
       // scalar

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

@@ -62,7 +62,7 @@ export var createSubset = /* #__PURE__ */factory(name, dependencies, _ref => {
 
   return typed(name, {
     // get subset
-    'Matrix, Index': function MatrixIndex(value, index) {
+    'Matrix, Index': function Matrix_Index(value, index) {
       if (isEmptyIndex(index)) {
         return matrix();
       }
@@ -78,7 +78,7 @@ export var createSubset = /* #__PURE__ */factory(name, dependencies, _ref => {
     'Object, Index': _getObjectProperty,
     'string, Index': _getSubstring,
     // set subset
-    'Matrix, Index, any, any': function MatrixIndexAnyAny(value, index, replacement, defaultValue) {
+    'Matrix, Index, any, any': function Matrix_Index_any_any(value, index, replacement, defaultValue) {
       if (isEmptyIndex(index)) {
         return value;
       }

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

@@ -49,7 +49,7 @@ export var createZeros = /* #__PURE__ */factory(name, dependencies, _ref => {
     },
     // math.zeros(m, n, p, ..., format)
     // TODO: more accurate signature '...number | BigNumber, string' as soon as typed-function supports this
-    '...number | BigNumber | string': function numberBigNumberString(size) {
+    '...number | BigNumber | string': function number__BigNumber__string(size) {
       var last = size[size.length - 1];
       if (typeof last === 'string') {
         var format = size.pop();
@@ -65,7 +65,7 @@ export var createZeros = /* #__PURE__ */factory(name, dependencies, _ref => {
       var format = size.storage();
       return _zeros(size.valueOf(), format);
     },
-    'Array | Matrix, string': function ArrayMatrixString(size, format) {
+    'Array | Matrix, string': function Array__Matrix_string(size, format) {
       return _zeros(size.valueOf(), format);
     }
   });

package/lib/esm/function/probability/combinations.js

@@ -31,7 +31,7 @@ export var createCombinations = /* #__PURE__ */factory(name, dependencies, _ref
    */
   return typed(name, {
     'number, number': combinationsNumber,
-    'BigNumber, BigNumber': function BigNumberBigNumber(n, k) {
+    'BigNumber, BigNumber': function BigNumber_BigNumber(n, k) {
       var BigNumber = n.constructor;
       var result, i;
       var nMinusk = n.minus(k);

package/lib/esm/function/probability/combinationsWithRep.js

@@ -31,7 +31,7 @@ export var createCombinationsWithRep = /* #__PURE__ */factory(name, dependencies
    * @return {number | BigNumber}     Number of possible combinations with replacement.
    */
   return typed(name, {
-    'number, number': function numberNumber(n, k) {
+    'number, number': function number_number(n, k) {
       if (!isInteger(n) || n < 0) {
         throw new TypeError('Positive integer value expected in function combinationsWithRep');
       }
@@ -48,7 +48,7 @@ export var createCombinationsWithRep = /* #__PURE__ */factory(name, dependencies
       var prodrange = product(k + 1, n + k - 1);
       return prodrange / product(1, n - 1);
     },
-    'BigNumber, BigNumber': function BigNumberBigNumber(n, k) {
+    'BigNumber, BigNumber': function BigNumber_BigNumber(n, k) {
       var BigNumber = n.constructor;
       var result, i;
       var one = new BigNumber(1);

package/lib/esm/function/probability/kldivergence.js

@@ -30,16 +30,16 @@ export var createKldivergence = /* #__PURE__ */factory(name, dependencies, _ref
      * @return {number}              Returns distance between q and p
      */
   return typed(name, {
-    'Array, Array': function ArrayArray(q, p) {
+    'Array, Array': function Array_Array(q, p) {
       return _kldiv(matrix(q), matrix(p));
     },
-    'Matrix, Array': function MatrixArray(q, p) {
+    'Matrix, Array': function Matrix_Array(q, p) {
       return _kldiv(q, matrix(p));
     },
-    'Array, Matrix': function ArrayMatrix(q, p) {
+    'Array, Matrix': function Array_Matrix(q, p) {
       return _kldiv(matrix(q), p);
     },
-    'Matrix, Matrix': function MatrixMatrix(q, p) {
+    'Matrix, Matrix': function Matrix_Matrix(q, p) {
       return _kldiv(q, p);
     }
   });

package/lib/esm/function/probability/multinomial.js

@@ -34,7 +34,7 @@ export var createMultinomial = /* #__PURE__ */factory(name, dependencies, _ref =
    * @return {Number | BigNumber}         Multinomial coefficient.
    */
   return typed(name, {
-    'Array | Matrix': function ArrayMatrix(a) {
+    'Array | Matrix': function Array__Matrix(a) {
       var sum = 0;
       var denom = 1;
       deepForEach(a, function (ai) {

package/lib/esm/function/probability/permutations.js

@@ -35,7 +35,7 @@ export var createPermutations = /* #__PURE__ */factory(name, dependencies, _ref
    */
   return typed(name, {
     'number | BigNumber': factorial,
-    'number, number': function numberNumber(n, k) {
+    'number, number': function number_number(n, k) {
       if (!isInteger(n) || n < 0) {
         throw new TypeError('Positive integer value expected in function permutations');
       }
@@ -48,7 +48,7 @@ export var createPermutations = /* #__PURE__ */factory(name, dependencies, _ref
       // Permute n objects, k at a time
       return product(n - k + 1, n);
     },
-    'BigNumber, BigNumber': function BigNumberBigNumber(n, k) {
+    'BigNumber, BigNumber': function BigNumber_BigNumber(n, k) {
       var result, i;
       if (!isPositiveInteger(n) || !isPositiveInteger(k)) {
         throw new TypeError('Positive integer value expected in function permutations');