mathjs 13.0.2 → 13.1.0

package/lib/esm/function/arithmetic/multiplyScalar.js

@@ -20,16 +20,16 @@ export var createMultiplyScalar = /* #__PURE__ */factory(name, dependencies, _re
    */
   return typed('multiplyScalar', {
     'number, number': multiplyNumber,
-    'Complex, Complex': function ComplexComplex(x, y) {
+    'Complex, Complex': function Complex_Complex(x, y) {
       return x.mul(y);
     },
-    'BigNumber, BigNumber': function BigNumberBigNumber(x, y) {
+    'BigNumber, BigNumber': function BigNumber_BigNumber(x, y) {
       return x.times(y);
     },
-    'bigint, bigint': function bigintBigint(x, y) {
+    'bigint, bigint': function bigint_bigint(x, y) {
       return x * y;
     },
-    'Fraction, Fraction': function FractionFraction(x, y) {
+    'Fraction, Fraction': function Fraction_Fraction(x, y) {
       return x.mul(y);
     },
     'number | Fraction | BigNumber | Complex, Unit': (x, y) => y.multiply(x),

package/lib/esm/function/arithmetic/norm.js

@@ -74,10 +74,10 @@ export var createNorm = /* #__PURE__ */factory(name, dependencies, _ref => {
     Matrix: function Matrix(x) {
       return _norm(x, 2);
     },
-    'Array, number | BigNumber | string': function ArrayNumberBigNumberString(x, p) {
+    'Array, number | BigNumber | string': function Array_number__BigNumber__string(x, p) {
       return _norm(matrix(x), p);
     },
-    'Matrix, number | BigNumber | string': function MatrixNumberBigNumberString(x, p) {
+    'Matrix, number | BigNumber | string': function Matrix_number__BigNumber__string(x, p) {
       return _norm(x, p);
     }
   });

package/lib/esm/function/arithmetic/pow.js

@@ -56,10 +56,10 @@ export var createPow = /* #__PURE__ */factory(name, dependencies, _ref => {
    */
   return typed(name, {
     'number, number': _pow,
-    'Complex, Complex': function ComplexComplex(x, y) {
+    'Complex, Complex': function Complex_Complex(x, y) {
       return x.pow(y);
     },
-    'BigNumber, BigNumber': function BigNumberBigNumber(x, y) {
+    'BigNumber, BigNumber': function BigNumber_BigNumber(x, y) {
       if (y.isInteger() || x >= 0 || config.predictable) {
         return x.pow(y);
       } else {
@@ -67,7 +67,7 @@ export var createPow = /* #__PURE__ */factory(name, dependencies, _ref => {
       }
     },
     'bigint, bigint': (x, y) => x ** y,
-    'Fraction, Fraction': function FractionFraction(x, y) {
+    'Fraction, Fraction': function Fraction_Fraction(x, y) {
       var result = x.pow(y);
       if (result != null) {
         return result;
@@ -79,14 +79,14 @@ export var createPow = /* #__PURE__ */factory(name, dependencies, _ref => {
       }
     },
     'Array, number': _powArray,
-    'Array, BigNumber': function ArrayBigNumber(x, y) {
+    'Array, BigNumber': function Array_BigNumber(x, y) {
       return _powArray(x, y.toNumber());
     },
     'Matrix, number': _powMatrix,
-    'Matrix, BigNumber': function MatrixBigNumber(x, y) {
+    'Matrix, BigNumber': function Matrix_BigNumber(x, y) {
       return _powMatrix(x, y.toNumber());
     },
-    'Unit, number | BigNumber': function UnitNumberBigNumber(x, y) {
+    'Unit, number | BigNumber': function Unit_number__BigNumber(x, y) {
       return x.pow(y);
     }
   });

package/lib/esm/function/arithmetic/round.js

@@ -85,7 +85,7 @@ export var createRound = /* #__PURE__ */factory(name, dependencies, _ref => {
       var xSelected = nearlyEqual(x, xEpsilon, config.relTol, config.absTol) ? xEpsilon : x;
       return roundNumber(xSelected);
     },
-    'number, number': function numberNumber(x, n) {
+    'number, number': function number_number(x, n) {
       // Same as number: unless user specifies more decimals than relTol
       var epsilonExponent = toExponent(config.relTol);
       if (n >= epsilonExponent) {
@@ -95,7 +95,7 @@ export var createRound = /* #__PURE__ */factory(name, dependencies, _ref => {
       var xSelected = nearlyEqual(x, xEpsilon, config.relTol, config.absTol) ? xEpsilon : x;
       return roundNumber(xSelected, n);
     },
-    'number, BigNumber': function numberBigNumber(x, n) {
+    'number, BigNumber': function number_BigNumber(x, n) {
       if (!n.isInteger()) {
         throw new TypeError(NO_INT);
       }
@@ -104,13 +104,13 @@ export var createRound = /* #__PURE__ */factory(name, dependencies, _ref => {
     Complex: function Complex(x) {
       return x.round();
     },
-    'Complex, number': function ComplexNumber(x, n) {
+    'Complex, number': function Complex_number(x, n) {
       if (n % 1) {
         throw new TypeError(NO_INT);
       }
       return x.round(n);
     },
-    'Complex, BigNumber': function ComplexBigNumber(x, n) {
+    'Complex, BigNumber': function Complex_BigNumber(x, n) {
       if (!n.isInteger()) {
         throw new TypeError(NO_INT);
       }
@@ -123,7 +123,7 @@ export var createRound = /* #__PURE__ */factory(name, dependencies, _ref => {
       var xSelected = bigNearlyEqual(x, xEpsilon, config.relTol, config.absTol) ? xEpsilon : x;
       return xSelected.toDecimalPlaces(0);
     },
-    'BigNumber, BigNumber': function BigNumberBigNumber(x, n) {
+    'BigNumber, BigNumber': function BigNumber_BigNumber(x, n) {
       if (!n.isInteger()) {
         throw new TypeError(NO_INT);
       }
@@ -140,13 +140,13 @@ export var createRound = /* #__PURE__ */factory(name, dependencies, _ref => {
     Fraction: function Fraction(x) {
       return x.round();
     },
-    'Fraction, number': function FractionNumber(x, n) {
+    'Fraction, number': function Fraction_number(x, n) {
       if (n % 1) {
         throw new TypeError(NO_INT);
       }
       return x.round(n);
     },
-    'Fraction, BigNumber': function FractionBigNumber(x, n) {
+    'Fraction, BigNumber': function Fraction_BigNumber(x, n) {
       if (!n.isInteger()) {
         throw new TypeError(NO_INT);
       }

package/lib/esm/function/arithmetic/subtractScalar.js

@@ -20,16 +20,16 @@ export var createSubtractScalar = /* #__PURE__ */factory(name, dependencies, _re
    */
   return typed(name, {
     'number, number': subtractNumber,
-    'Complex, Complex': function ComplexComplex(x, y) {
+    'Complex, Complex': function Complex_Complex(x, y) {
       return x.sub(y);
     },
-    'BigNumber, BigNumber': function BigNumberBigNumber(x, y) {
+    'BigNumber, BigNumber': function BigNumber_BigNumber(x, y) {
       return x.minus(y);
     },
-    'bigint, bigint': function bigintBigint(x, y) {
+    'bigint, bigint': function bigint_bigint(x, y) {
       return x - y;
     },
-    'Fraction, Fraction': function FractionFraction(x, y) {
+    'Fraction, Fraction': function Fraction_Fraction(x, y) {
       return x.sub(y);
     },
     'Unit, Unit': typed.referToSelf(self => (x, y) => {

package/lib/esm/function/arithmetic/xgcd.js

@@ -33,7 +33,7 @@ export var createXgcd = /* #__PURE__ */factory(name, dependencies, _ref => {
    *                              where `div = gcd(a, b)` and `a*m + b*n = div`
    */
   return typed(name, {
-    'number, number': function numberNumber(a, b) {
+    'number, number': function number_number(a, b) {
       var res = xgcdNumber(a, b);
       return config.matrix === 'Array' ? res : matrix(res);
     },

package/lib/esm/function/combinatorics/bellNumbers.js

@@ -31,7 +31,7 @@ export var createBellNumbers = /* #__PURE__ */factory(name, dependencies, _ref =
    * @return {Number | BigNumber}     B(n)
    */
   return typed(name, {
-    'number | BigNumber': function numberBigNumber(n) {
+    'number | BigNumber': function number__BigNumber(n) {
       if (!isInteger(n) || isNegative(n)) {
         throw new TypeError('Non-negative integer value expected in function bellNumbers');
       }

package/lib/esm/function/combinatorics/catalan.js

@@ -33,7 +33,7 @@ export var createCatalan = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @return {Number | BigNumber}     Cn(n)
    */
   return typed(name, {
-    'number | BigNumber': function numberBigNumber(n) {
+    'number | BigNumber': function number__BigNumber(n) {
       if (!isInteger(n) || isNegative(n)) {
         throw new TypeError('Non-negative integer value expected in function catalan');
       }

package/lib/esm/function/combinatorics/composition.js

@@ -34,7 +34,7 @@ export var createComposition = /* #__PURE__ */factory(name, dependencies, _ref =
    * @return {Number | BigNumber}     Returns the composition counts of n into k parts.
    */
   return typed(name, {
-    'number | BigNumber, number | BigNumber': function numberBigNumberNumberBigNumber(n, k) {
+    'number | BigNumber, number | BigNumber': function number__BigNumber_number__BigNumber(n, k) {
       if (!isInteger(n) || !isPositive(n) || !isInteger(k) || !isPositive(k)) {
         throw new TypeError('Positive integer value expected in function composition');
       } else if (larger(k, n)) {

package/lib/esm/function/combinatorics/stirlingS2.js

@@ -49,7 +49,7 @@ export var createStirlingS2 = /* #__PURE__ */factory(name, dependencies, _ref =>
    * @return {Number | BigNumber}     S(n,k)
    */
   return typed(name, {
-    'number | BigNumber, number | BigNumber': function numberBigNumberNumberBigNumber(n, k) {
+    'number | BigNumber, number | BigNumber': function number__BigNumber_number__BigNumber(n, k) {
       if (!isInteger(n) || isNegative(n) || !isInteger(k) || isNegative(k)) {
         throw new TypeError('Non-negative integer value expected in function stirlingS2');
       } else if (larger(k, n)) {

package/lib/esm/function/geometry/distance.js

@@ -65,7 +65,7 @@ export var createDistance = /* #__PURE__ */factory(name, dependencies, _ref => {
     * @return {Number | BigNumber} Returns the distance from two/three points
   */
   return typed(name, {
-    'Array, Array, Array': function ArrayArrayArray(x, y, z) {
+    'Array, Array, Array': function Array_Array_Array(x, y, z) {
       // Point to Line 2D (x=Point, y=LinePoint1, z=LinePoint2)
       if (x.length === 2 && y.length === 2 && z.length === 2) {
         if (!_2d(x)) {
@@ -88,7 +88,7 @@ export var createDistance = /* #__PURE__ */factory(name, dependencies, _ref => {
         throw new TypeError('Invalid Arguments: Try again');
       }
     },
-    'Object, Object, Object': function ObjectObjectObject(x, y, z) {
+    'Object, Object, Object': function Object_Object_Object(x, y, z) {
       if (Object.keys(x).length === 2 && Object.keys(y).length === 2 && Object.keys(z).length === 2) {
         if (!_2d(x)) {
           throw new TypeError('Values of pointX and pointY should be numbers or BigNumbers');
@@ -114,7 +114,7 @@ export var createDistance = /* #__PURE__ */factory(name, dependencies, _ref => {
         throw new TypeError('Invalid Arguments: Try again');
       }
     },
-    'Array, Array': function ArrayArray(x, y) {
+    'Array, Array': function Array_Array(x, y) {
       // Point to Line 2D (x=[pointX, pointY], y=[x-coeff, y-coeff, const])
       if (x.length === 2 && y.length === 3) {
         if (!_2d(x)) {
@@ -146,7 +146,7 @@ export var createDistance = /* #__PURE__ */factory(name, dependencies, _ref => {
         throw new TypeError('Invalid Arguments: Try again');
       }
     },
-    'Object, Object': function ObjectObject(x, y) {
+    'Object, Object': function Object_Object(x, y) {
       if (Object.keys(x).length === 2 && Object.keys(y).length === 3) {
         if (!_2d(x)) {
           throw new TypeError('Values of pointX and pointY should be numbers or BigNumbers');

package/lib/esm/function/geometry/intersect.js

@@ -49,11 +49,11 @@ export var createIntersect = /* #__PURE__ */factory(name, dependencies, _ref =>
   return typed('intersect', {
     'Array, Array, Array': _AAA,
     'Array, Array, Array, Array': _AAAA,
-    'Matrix, Matrix, Matrix': function MatrixMatrixMatrix(x, y, plane) {
+    'Matrix, Matrix, Matrix': function Matrix_Matrix_Matrix(x, y, plane) {
       var arr = _AAA(x.valueOf(), y.valueOf(), plane.valueOf());
       return arr === null ? null : matrix(arr);
     },
-    'Matrix, Matrix, Matrix, Matrix': function MatrixMatrixMatrixMatrix(w, x, y, z) {
+    'Matrix, Matrix, Matrix, Matrix': function Matrix_Matrix_Matrix_Matrix(w, x, y, z) {
       // TODO: output matrix type should match input matrix type
       var arr = _AAAA(w.valueOf(), x.valueOf(), y.valueOf(), z.valueOf());
       return arr === null ? null : matrix(arr);

package/lib/esm/function/logical/and.js

@@ -67,10 +67,10 @@ export var createAnd = /* #__PURE__ */factory(name, dependencies, _ref => {
    */
   return typed(name, {
     'number, number': andNumber,
-    'Complex, Complex': function ComplexComplex(x, y) {
+    'Complex, Complex': function Complex_Complex(x, y) {
       return (x.re !== 0 || x.im !== 0) && (y.re !== 0 || y.im !== 0);
     },
-    'BigNumber, BigNumber': function BigNumberBigNumber(x, y) {
+    'BigNumber, BigNumber': function BigNumber_BigNumber(x, y) {
       return !x.isZero() && !y.isZero() && !x.isNaN() && !y.isNaN();
     },
     'bigint, bigint': andNumber,

package/lib/esm/function/logical/or.js

@@ -61,10 +61,10 @@ export var createOr = /* #__PURE__ */factory(name, dependencies, _ref => {
    */
   return typed(name, {
     'number, number': orNumber,
-    'Complex, Complex': function ComplexComplex(x, y) {
+    'Complex, Complex': function Complex_Complex(x, y) {
       return x.re !== 0 || x.im !== 0 || y.re !== 0 || y.im !== 0;
     },
-    'BigNumber, BigNumber': function BigNumberBigNumber(x, y) {
+    'BigNumber, BigNumber': function BigNumber_BigNumber(x, y) {
       return !x.isZero() && !x.isNaN() || !y.isZero() && !y.isNaN();
     },
     'bigint, bigint': orNumber,

package/lib/esm/function/logical/xor.js

@@ -60,11 +60,11 @@ export var createXor = /* #__PURE__ */factory(name, dependencies, _ref => {
    */
   return typed(name, {
     'number, number': xorNumber,
-    'Complex, Complex': function ComplexComplex(x, y) {
+    'Complex, Complex': function Complex_Complex(x, y) {
       return (x.re !== 0 || x.im !== 0) !== (y.re !== 0 || y.im !== 0);
     },
     'bigint, bigint': xorNumber,
-    'BigNumber, BigNumber': function BigNumberBigNumber(x, y) {
+    'BigNumber, BigNumber': function BigNumber_BigNumber(x, y) {
       return (!x.isZero() && !x.isNaN()) !== (!y.isZero() && !y.isNaN());
     },
     'Unit, Unit': typed.referToSelf(self => (x, y) => self(x.value || 0, y.value || 0))

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

@@ -42,7 +42,7 @@ export var createApply = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @return {Array | Matrix} res    The residual matrix with the function applied over some dimension.
    */
   return typed(name, {
-    'Array | Matrix, number | BigNumber, function': function ArrayMatrixNumberBigNumberFunction(mat, dim, callback) {
+    'Array | Matrix, number | BigNumber, function': function Array__Matrix_number__BigNumber_function(mat, dim, callback) {
       if (!isInteger(dim)) {
         throw new TypeError('Integer number expected for dimension');
       }
@@ -51,7 +51,7 @@ export var createApply = /* #__PURE__ */factory(name, dependencies, _ref => {
         throw new IndexError(dim, size.length);
       }
       if (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/esm/function/matrix/column.js

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

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

@@ -43,7 +43,7 @@ export var createConcat = /* #__PURE__ */factory(name, dependencies, _ref => {
    */
   return typed(name, {
     // TODO: change signature to '...Array | Matrix, dim?' when supported
-    '...Array | Matrix | number | BigNumber': function ArrayMatrixNumberBigNumber(args) {
+    '...Array | Matrix | number | BigNumber': function Array__Matrix__number__BigNumber(args) {
       var i;
       var len = args.length;
       var dim = -1; // zero-based dimension

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

@@ -32,7 +32,7 @@ export var createCount = /* #__PURE__ */factory(name, dependencies, _ref => {
     string: function string(x) {
       return x.length;
     },
-    'Matrix | Array': function MatrixArray(x) {
+    'Matrix | Array': function Matrix__Array(x) {
       return prod(size(x));
     }
   });

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

@@ -43,13 +43,13 @@ export var createCross = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @return {Array | Matrix}     Returns the cross product of `x` and `y`
    */
   return typed(name, {
-    'Matrix, Matrix': function MatrixMatrix(x, y) {
+    'Matrix, Matrix': function Matrix_Matrix(x, y) {
       return matrix(_cross(x.toArray(), y.toArray()));
     },
-    'Matrix, Array': function MatrixArray(x, y) {
+    'Matrix, Array': function Matrix_Array(x, y) {
       return matrix(_cross(x.toArray(), y));
     },
-    'Array, Matrix': function ArrayMatrix(x, y) {
+    'Array, Matrix': function Array_Matrix(x, y) {
       return matrix(_cross(x, y.toArray()));
     },
     'Array, Array': _cross

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

@@ -54,37 +54,37 @@ export var createDiag = /* #__PURE__ */factory(name, dependencies, _ref => {
     Array: function Array(x) {
       return _diag(x, 0, arraySize(x), null);
     },
-    'Array, number': function ArrayNumber(x, k) {
+    'Array, number': function Array_number(x, k) {
       return _diag(x, k, arraySize(x), null);
     },
-    'Array, BigNumber': function ArrayBigNumber(x, k) {
+    'Array, BigNumber': function Array_BigNumber(x, k) {
       return _diag(x, k.toNumber(), arraySize(x), null);
     },
-    'Array, string': function ArrayString(x, format) {
+    'Array, string': function Array_string(x, format) {
       return _diag(x, 0, arraySize(x), format);
     },
-    'Array, number, string': function ArrayNumberString(x, k, format) {
+    'Array, number, string': function Array_number_string(x, k, format) {
       return _diag(x, k, arraySize(x), format);
     },
-    'Array, BigNumber, string': function ArrayBigNumberString(x, k, format) {
+    'Array, BigNumber, string': function Array_BigNumber_string(x, k, format) {
       return _diag(x, k.toNumber(), arraySize(x), format);
     },
     Matrix: function Matrix(x) {
       return _diag(x, 0, x.size(), x.storage());
     },
-    'Matrix, number': function MatrixNumber(x, k) {
+    'Matrix, number': function Matrix_number(x, k) {
       return _diag(x, k, x.size(), x.storage());
     },
-    'Matrix, BigNumber': function MatrixBigNumber(x, k) {
+    'Matrix, BigNumber': function Matrix_BigNumber(x, k) {
       return _diag(x, k.toNumber(), x.size(), x.storage());
     },
-    'Matrix, string': function MatrixString(x, format) {
+    'Matrix, string': function Matrix_string(x, format) {
       return _diag(x, 0, x.size(), format);
     },
-    'Matrix, number, string': function MatrixNumberString(x, k, format) {
+    'Matrix, number, string': function Matrix_number_string(x, k, format) {
       return _diag(x, k, x.size(), format);
     },
-    'Matrix, BigNumber, string': function MatrixBigNumberString(x, k, format) {
+    'Matrix, BigNumber, string': function Matrix_BigNumber_string(x, k, format) {
       return _diag(x, k.toNumber(), x.size(), format);
     }
   });

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

@@ -57,7 +57,7 @@ export var createDiff = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @return {Array | Matrix}         Difference between array elements in given dimension
    */
   return typed(name, {
-    'Array | Matrix': function ArrayMatrix(arr) {
+    'Array | Matrix': function Array__Matrix(arr) {
       // No dimension specified => assume dimension 0
       if (isMatrix(arr)) {
         return matrix(_diff(arr.toArray()));
@@ -65,7 +65,7 @@ export var createDiff = /* #__PURE__ */factory(name, dependencies, _ref => {
         return _diff(arr);
       }
     },
-    'Array | Matrix, number': function ArrayMatrixNumber(arr, dim) {
+    'Array | Matrix, number': function Array__Matrix_number(arr, dim) {
       if (!isInteger(dim)) throw new RangeError('Dimension must be a whole number');
       if (isMatrix(arr)) {
         return matrix(_recursive(arr.toArray(), dim));

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

@@ -158,7 +158,7 @@ export var createEigs = /* #__PURE__ */factory(name, dependencies, _ref => {
     Array: function Array(x) {
       return doEigs(matrix(x));
     },
-    'Array, number|BigNumber': function ArrayNumberBigNumber(x, prec) {
+    'Array, number|BigNumber': function Array_numberBigNumber(x, prec) {
       return doEigs(matrix(x), {
         precision: prec
       });
@@ -171,13 +171,13 @@ export var createEigs = /* #__PURE__ */factory(name, dependencies, _ref => {
         matricize: true
       });
     },
-    'Matrix, number|BigNumber': function MatrixNumberBigNumber(mat, prec) {
+    'Matrix, number|BigNumber': function Matrix_numberBigNumber(mat, prec) {
       return doEigs(mat, {
         precision: prec,
         matricize: true
       });
     },
-    'Matrix, Object': function MatrixObject(mat, opts) {
+    'Matrix, Object': function Matrix_Object(mat, opts) {
       var useOpts = {
         matricize: true
       };

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

@@ -19,7 +19,7 @@ export var createFft = /* #__PURE__ */factory(name, dependencies, _ref => {
     log2
   } = _ref;
   /**
-   * Calculate N-dimensional fourier transform
+   * Calculate N-dimensional Fourier transform
    *
    * Syntax:
    *
@@ -35,12 +35,12 @@ export var createFft = /* #__PURE__ */factory(name, dependencies, _ref => {
    *      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(matrix) {
-      return matrix.create(_ndFft(matrix.toArray()));
+      return matrix.create(_ndFft(matrix.valueOf()), matrix.datatype());
     }
   });
 

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

@@ -38,12 +38,12 @@ export var createFilter = /* #__PURE__ */factory(name, dependencies, _ref => {
    */
   return typed('filter', {
     'Array, function': _filterCallback,
-    'Matrix, function': function MatrixFunction(x, test) {
-      return x.create(_filterCallback(x.toArray(), test));
+    'Matrix, function': function Matrix_function(x, test) {
+      return x.create(_filterCallback(x.valueOf(), test), x.datatype());
     },
     'Array, RegExp': filterRegExp,
-    'Matrix, RegExp': function MatrixRegExp(x, test) {
-      return x.create(filterRegExp(x.toArray(), test));
+    'Matrix, RegExp': function Matrix_RegExp(x, test) {
+      return x.create(filterRegExp(x.valueOf(), test), x.datatype());
     }
   });
 });

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

@@ -1,11 +1,10 @@
 import { flatten as flattenArray } from '../../utils/array.js';
 import { factory } from '../../utils/factory.js';
 var name = 'flatten';
-var dependencies = ['typed', 'matrix'];
+var dependencies = ['typed'];
 export var createFlatten = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
-    typed,
-    matrix
+    typed
   } = _ref;
   /**
    * Flatten a multidimensional matrix into a single dimensional matrix.
@@ -31,9 +30,9 @@ export var createFlatten = /* #__PURE__ */factory(name, dependencies, _ref => {
       return flattenArray(x);
     },
     Matrix: function Matrix(x) {
-      var flat = flattenArray(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(flattenArray(x.toArray()), x.datatype());
     }
   });
 });

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

@@ -32,7 +32,7 @@ export var createForEach = /* #__PURE__ */factory(name, dependencies, _ref => {
    */
   return typed(name, {
     'Array, function': _forEach,
-    'Matrix, function': function MatrixFunction(x, callback) {
+    'Matrix, function': function Matrix_function(x, callback) {
       x.forEach(callback);
     }
   });
@@ -45,16 +45,16 @@ export var createForEach = /* #__PURE__ */factory(name, dependencies, _ref => {
  * @private
  */
 function _forEach(array, callback) {
-  var recurse = function recurse(value, index) {
+  var _recurse = function recurse(value, index) {
     if (Array.isArray(value)) {
       forEachArray(value, function (child, i) {
         // we create a copy of the index array and append the new index value
-        recurse(child, index.concat(i));
+        _recurse(child, index.concat(i));
       });
     } else {
       // invoke the callback function with the right number of arguments
       return applyCallback(callback, value, index, array, 'forEach');
     }
   };
-  recurse(array, []);
+  _recurse(array, []);
 }

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

@@ -50,28 +50,28 @@ export var createIdentity = /* #__PURE__ */factory(name, dependencies, _ref => {
     string: function string(format) {
       return matrix(format);
     },
-    'number | BigNumber': function numberBigNumber(rows) {
+    'number | BigNumber': function number__BigNumber(rows) {
       return _identity(rows, rows, config.matrix === 'Matrix' ? 'dense' : undefined);
     },
-    'number | BigNumber, string': function numberBigNumberString(rows, format) {
+    'number | BigNumber, string': function number__BigNumber_string(rows, format) {
       return _identity(rows, rows, format);
     },
-    'number | BigNumber, number | BigNumber': function numberBigNumberNumberBigNumber(rows, cols) {
+    'number | BigNumber, number | BigNumber': function number__BigNumber_number__BigNumber(rows, cols) {
       return _identity(rows, cols, config.matrix === 'Matrix' ? 'dense' : undefined);
     },
-    'number | BigNumber, number | BigNumber, string': function numberBigNumberNumberBigNumberString(rows, cols, format) {
+    'number | BigNumber, number | BigNumber, string': function number__BigNumber_number__BigNumber_string(rows, cols, format) {
       return _identity(rows, cols, format);
     },
     Array: function Array(size) {
       return _identityVector(size);
     },
-    'Array, string': function ArrayString(size, format) {
+    'Array, string': function Array_string(size, format) {
       return _identityVector(size, format);
     },
     Matrix: function Matrix(size) {
       return _identityVector(size.valueOf(), size.storage());
     },
-    'Matrix, string': function MatrixString(size, format) {
+    'Matrix, string': function Matrix_string(size, format) {
       return _identityVector(size.valueOf(), format);
     }
   });

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

@@ -11,7 +11,7 @@ export var createIfft = /* #__PURE__ */factory(name, dependencies, _ref => {
     conj
   } = _ref;
   /**
-   * Calculate N-dimensional inverse fourier transform
+   * Calculate N-dimensional inverse Fourier transform
    *
    * Syntax:
    *
@@ -26,10 +26,10 @@ export var createIfft = /* #__PURE__ */factory(name, dependencies, _ref => {
    *      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 ArrayMatrix(arr) {
+    'Array | Matrix': function Array__Matrix(arr) {
       var size = isMatrix(arr) ? arr.size() : arraySize(arr);
       return dotDivide(conj(fft(conj(arr))), size.reduce((acc, curr) => acc * curr, 1));
     }

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

@@ -37,7 +37,7 @@ export var createInv = /* #__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: