mathjs 13.0.3 → 13.1.0

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');

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

@@ -56,29 +56,29 @@ export var createPickRandom = /* #__PURE__ */factory(name, dependencies, _ref =>
    *                                   Returns an array with the configured number of elements when number is defined.
    */
   return typed(name, {
-    'Array | Matrix': function ArrayMatrix(possibles) {
+    'Array | Matrix': function Array__Matrix(possibles) {
       return _pickRandom(possibles, {});
     },
-    'Array | Matrix, Object': function ArrayMatrixObject(possibles, options) {
+    'Array | Matrix, Object': function Array__Matrix_Object(possibles, options) {
       return _pickRandom(possibles, options);
     },
-    'Array | Matrix, number': function ArrayMatrixNumber(possibles, number) {
+    'Array | Matrix, number': function Array__Matrix_number(possibles, number) {
       return _pickRandom(possibles, {
         number
       });
     },
-    'Array | Matrix, Array | Matrix': function ArrayMatrixArrayMatrix(possibles, weights) {
+    'Array | Matrix, Array | Matrix': function Array__Matrix_Array__Matrix(possibles, weights) {
       return _pickRandom(possibles, {
         weights
       });
     },
-    'Array | Matrix, Array | Matrix, number': function ArrayMatrixArrayMatrixNumber(possibles, weights, number) {
+    'Array | Matrix, Array | Matrix, number': function Array__Matrix_Array__Matrix_number(possibles, weights, number) {
       return _pickRandom(possibles, {
         number,
         weights
       });
     },
-    'Array | Matrix, number, Array | Matrix': function ArrayMatrixNumberArrayMatrix(possibles, number, weights) {
+    'Array | Matrix, number, Array | Matrix': function Array__Matrix_number_Array__Matrix(possibles, number, weights) {
       return _pickRandom(possibles, {
         number,
         weights

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

@@ -60,7 +60,7 @@ export var createRandom = /* #__PURE__ */factory(name, dependencies, _ref => {
   });
   function _randomMatrix(size, min, max) {
     var res = randomMatrix(size.valueOf(), () => _random(min, max));
-    return isMatrix(size) ? size.create(res) : res;
+    return isMatrix(size) ? size.create(res, 'number') : res;
   }
   function _random(min, max) {
     return min + rng() * (max - min);

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

@@ -59,7 +59,7 @@ export var createRandomInt = /* #__PURE__ */factory(name, dependencies, _ref =>
   });
   function _randomIntMatrix(size, min, max) {
     var res = randomMatrix(size.valueOf(), () => _randomInt(min, max));
-    return isMatrix(size) ? size.create(res) : res;
+    return isMatrix(size) ? size.create(res, 'number') : res;
   }
   function _randomInt(min, max) {
     return Math.floor(min + rng() * (max - min));

package/lib/esm/function/relational/compare.js

@@ -80,19 +80,19 @@ export var createCompare = /* #__PURE__ */factory(name, dependencies, _ref => {
     typed,
     config
   }), {
-    'boolean, boolean': function booleanBoolean(x, y) {
+    'boolean, boolean': function boolean_boolean(x, y) {
       return x === y ? 0 : x > y ? 1 : -1;
     },
-    'BigNumber, BigNumber': function BigNumberBigNumber(x, y) {
+    'BigNumber, BigNumber': function BigNumber_BigNumber(x, y) {
       return bigNearlyEqual(x, y, config.relTol, config.absTol) ? new BigNumber(0) : new BigNumber(x.cmp(y));
     },
-    'bigint, bigint': function bigintBigint(x, y) {
+    'bigint, bigint': function bigint_bigint(x, y) {
       return x === y ? 0n : x > y ? 1n : -1n;
     },
-    'Fraction, Fraction': function FractionFraction(x, y) {
+    'Fraction, Fraction': function Fraction_Fraction(x, y) {
       return new Fraction(x.compare(y));
     },
-    'Complex, Complex': function ComplexComplex() {
+    'Complex, Complex': function Complex_Complex() {
       throw new TypeError('No ordering relation is defined for complex numbers');
     }
   }, compareUnits, matrixAlgorithmSuite({
@@ -107,7 +107,7 @@ export var createCompareNumber = /* #__PURE__ */factory(name, ['typed', 'config'
     config
   } = _ref2;
   return typed(name, {
-    'number, number': function numberNumber(x, y) {
+    'number, number': function number_number(x, y) {
       return nearlyEqual(x, y, config.relTol, config.absTol) ? 0 : x > y ? 1 : -1;
     }
   });

package/lib/esm/function/relational/deepEqual.js

@@ -36,7 +36,7 @@ export var createDeepEqual = /* #__PURE__ */factory(name, dependencies, _ref =>
    *            Returns true when the input matrices have the same size and each of their elements is equal.
    */
   return typed(name, {
-    'any, any': function anyAny(x, y) {
+    'any, any': function any_any(x, y) {
       return _deepEqual(x.valueOf(), y.valueOf());
     }
   });

package/lib/esm/function/relational/equal.js

@@ -90,7 +90,7 @@ export var createEqualNumber = factory(name, ['typed', 'equalScalar'], _ref2 =>
     equalScalar
   } = _ref2;
   return typed(name, {
-    'any, any': function anyAny(x, y) {
+    'any, any': function any_any(x, y) {
       // strict equality for null and undefined?
       if (x === null) {
         return y === null;

package/lib/esm/function/relational/equalScalar.js

@@ -23,22 +23,22 @@ export var createEqualScalar = /* #__PURE__ */factory(name, dependencies, _ref =
    * @private
    */
   return typed(name, {
-    'boolean, boolean': function booleanBoolean(x, y) {
+    'boolean, boolean': function boolean_boolean(x, y) {
       return x === y;
     },
-    'number, number': function numberNumber(x, y) {
+    'number, number': function number_number(x, y) {
       return nearlyEqual(x, y, config.relTol, config.absTol);
     },
-    'BigNumber, BigNumber': function BigNumberBigNumber(x, y) {
+    'BigNumber, BigNumber': function BigNumber_BigNumber(x, y) {
       return x.eq(y) || bigNearlyEqual(x, y, config.relTol, config.absTol);
     },
-    '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.equals(y);
     },
-    'Complex, Complex': function ComplexComplex(x, y) {
+    'Complex, Complex': function Complex_Complex(x, y) {
       return complexEquals(x, y, config.relTol, config.absTol);
     }
   }, compareUnits);
@@ -49,7 +49,7 @@ export var createEqualScalarNumber = factory(name, ['typed', 'config'], _ref2 =>
     config
   } = _ref2;
   return typed(name, {
-    'number, number': function numberNumber(x, y) {
+    'number, number': function number_number(x, y) {
       return nearlyEqual(x, y, config.relTol, config.absTol);
     }
   });

package/lib/esm/function/relational/equalText.js

@@ -34,7 +34,7 @@ export var createEqualText = /* #__PURE__ */factory(name, dependencies, _ref =>
    * @return {number | Array | DenseMatrix} Returns true if the values are equal, and false if not.
    */
   return typed(name, {
-    'any, any': function anyAny(x, y) {
+    'any, any': function any_any(x, y) {
       return isZero(compareText(x, y));
     }
   });

package/lib/esm/function/relational/larger.js

@@ -72,12 +72,12 @@ export var createLarger = /* #__PURE__ */factory(name, dependencies, _ref => {
     config
   }), {
     'boolean, boolean': (x, y) => x > y,
-    'BigNumber, BigNumber': function BigNumberBigNumber(x, y) {
+    'BigNumber, BigNumber': function BigNumber_BigNumber(x, y) {
       return x.gt(y) && !bigNearlyEqual(x, y, config.relTol, config.absTol);
     },
     'bigint, bigint': (x, y) => x > y,
     'Fraction, Fraction': (x, y) => x.compare(y) === 1,
-    'Complex, Complex': function ComplexComplex() {
+    'Complex, Complex': function Complex_Complex() {
       throw new TypeError('No ordering relation is defined for complex numbers');
     }
   }, compareUnits, matrixAlgorithmSuite({
@@ -92,7 +92,7 @@ export var createLargerNumber = /* #__PURE__ */factory(name, ['typed', 'config']
     config
   } = _ref2;
   return typed(name, {
-    'number, number': function numberNumber(x, y) {
+    'number, number': function number_number(x, y) {
       return x > y && !nearlyEqual(x, y, config.relTol, config.absTol);
     }
   });

package/lib/esm/function/relational/largerEq.js

@@ -68,14 +68,14 @@ export var createLargerEq = /* #__PURE__ */factory(name, dependencies, _ref => {
     config
   }), {
     'boolean, boolean': (x, y) => x >= y,
-    'BigNumber, BigNumber': function BigNumberBigNumber(x, y) {
+    'BigNumber, BigNumber': function BigNumber_BigNumber(x, y) {
       return x.gte(y) || bigNearlyEqual(x, y, config.relTol, config.absTol);
     },
-    'bigint, bigint': function bigintBigint(x, y) {
+    'bigint, bigint': function bigint_bigint(x, y) {
       return x >= y;
     },
     'Fraction, Fraction': (x, y) => x.compare(y) !== -1,
-    'Complex, Complex': function ComplexComplex() {
+    'Complex, Complex': function Complex_Complex() {
       throw new TypeError('No ordering relation is defined for complex numbers');
     }
   }, compareUnits, matrixAlgorithmSuite({
@@ -90,7 +90,7 @@ export var createLargerEqNumber = /* #__PURE__ */factory(name, ['typed', 'config
     config
   } = _ref2;
   return typed(name, {
-    'number, number': function numberNumber(x, y) {
+    'number, number': function number_number(x, y) {
       return x >= y || nearlyEqual(x, y, config.relTol, config.absTol);
     }
   });

package/lib/esm/function/relational/smaller.js

@@ -72,12 +72,12 @@ export var createSmaller = /* #__PURE__ */factory(name, dependencies, _ref => {
     config
   }), {
     'boolean, boolean': (x, y) => x < y,
-    'BigNumber, BigNumber': function BigNumberBigNumber(x, y) {
+    'BigNumber, BigNumber': function BigNumber_BigNumber(x, y) {
       return x.lt(y) && !bigNearlyEqual(x, y, config.relTol, config.absTol);
     },
     'bigint, bigint': (x, y) => x < y,
     'Fraction, Fraction': (x, y) => x.compare(y) === -1,
-    'Complex, Complex': function ComplexComplex(x, y) {
+    'Complex, Complex': function Complex_Complex(x, y) {
       throw new TypeError('No ordering relation is defined for complex numbers');
     }
   }, compareUnits, matrixAlgorithmSuite({
@@ -92,7 +92,7 @@ export var createSmallerNumber = /* #__PURE__ */factory(name, ['typed', 'config'
     config
   } = _ref2;
   return typed(name, {
-    'number, number': function numberNumber(x, y) {
+    'number, number': function number_number(x, y) {
       return x < y && !nearlyEqual(x, y, config.relTol, config.absTol);
     }
   });

package/lib/esm/function/relational/smallerEq.js

@@ -68,12 +68,12 @@ export var createSmallerEq = /* #__PURE__ */factory(name, dependencies, _ref =>
     config
   }), {
     'boolean, boolean': (x, y) => x <= y,
-    'BigNumber, BigNumber': function BigNumberBigNumber(x, y) {
+    'BigNumber, BigNumber': function BigNumber_BigNumber(x, y) {
       return x.lte(y) || bigNearlyEqual(x, y, config.relTol, config.absTol);
     },
     'bigint, bigint': (x, y) => x <= y,
     'Fraction, Fraction': (x, y) => x.compare(y) !== 1,
-    'Complex, Complex': function ComplexComplex() {
+    'Complex, Complex': function Complex_Complex() {
       throw new TypeError('No ordering relation is defined for complex numbers');
     }
   }, compareUnits, matrixAlgorithmSuite({
@@ -88,7 +88,7 @@ export var createSmallerEqNumber = /* #__PURE__ */factory(name, ['typed', 'confi
     config
   } = _ref2;
   return typed(name, {
-    'number, number': function numberNumber(x, y) {
+    'number, number': function number_number(x, y) {
       return x <= y || nearlyEqual(x, y, config.relTol, config.absTol);
     }
   });

package/lib/esm/function/relational/unequal.js

@@ -93,7 +93,7 @@ export var createUnequalNumber = factory(name, ['typed', 'equalScalar'], _ref2 =
     equalScalar
   } = _ref2;
   return typed(name, {
-    'any, any': function anyAny(x, y) {
+    'any, any': function any_any(x, y) {
       // strict equality for null and undefined?
       if (x === null) {
         return y !== null;

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

@@ -34,7 +34,7 @@ export var createSetCartesian = /* #__PURE__ */factory(name, dependencies, _ref
    * @return {Array | Matrix}    The cartesian product 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) {
       var result = [];
       if (subset(size(a1), new Index(0)) !== 0 && subset(size(a2), new Index(0)) !== 0) {
         // if any of them is empty, return empty

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

@@ -33,7 +33,7 @@ export var createSetDifference = /* #__PURE__ */factory(name, dependencies, _ref
    * @return {Array | Matrix}    The difference 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) {
       var result;
       if (subset(size(a1), new Index(0)) === 0) {
         // empty-anything=empty

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

@@ -31,7 +31,7 @@ export var createSetDistinct = /* #__PURE__ */factory(name, dependencies, _ref =
    * @return {Array | Matrix}    A set containing the distinc elements of the multiset
    */
   return typed(name, {
-    'Array | Matrix': function ArrayMatrix(a) {
+    'Array | Matrix': function Array__Matrix(a) {
       var result;
       if (subset(size(a), new Index(0)) === 0) {
         // if empty, return empty

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

@@ -33,7 +33,7 @@ export var createSetIntersect = /* #__PURE__ */factory(name, dependencies, _ref
    * @return {Array | Matrix}    The intersection 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) {
       var result;
       if (subset(size(a1), new Index(0)) === 0 || subset(size(a2), new Index(0)) === 0) {
         // of any of them is empty, return empty

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

@@ -32,7 +32,7 @@ export var createSetIsSubset = /* #__PURE__ */factory(name, dependencies, _ref =
    * @return {boolean} Returns true when a1 is a subset of a2, returns false otherwise
    */
   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) {
         // empty is a subset of anything
         return true;

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

@@ -32,7 +32,7 @@ export var createSetMultiplicity = /* #__PURE__ */factory(name, dependencies, _r
    * @return {number}            The number of how many times the multiset contains the element
    */
   return typed(name, {
-    'number | BigNumber | Fraction | Complex, Array | Matrix': function numberBigNumberFractionComplexArrayMatrix(e, a) {
+    'number | BigNumber | Fraction | Complex, Array | Matrix': function number__BigNumber__Fraction__Complex_Array__Matrix(e, a) {
       if (subset(size(a), new Index(0)) === 0) {
         // if empty, return 0
         return 0;

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

@@ -30,7 +30,7 @@ export var createSetPowerset = /* #__PURE__ */factory(name, dependencies, _ref =
    * @return {Array}    The powerset of the (multi)set
    */
   return typed(name, {
-    'Array | Matrix': function ArrayMatrix(a) {
+    'Array | Matrix': function Array__Matrix(a) {
       if (subset(size(a), new Index(0)) === 0) {
         // if empty, return empty
         return [];

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

@@ -30,10 +30,10 @@ export var createSetSize = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @return {number}           The number of elements of the (multi)set
    */
   return typed(name, {
-    'Array | Matrix': function ArrayMatrix(a) {
+    'Array | Matrix': function Array__Matrix(a) {
       return Array.isArray(a) ? flatten(a).length : flatten(a.toArray()).length;
     },
-    'Array | Matrix, boolean': function ArrayMatrixBoolean(a, unique) {
+    'Array | Matrix, boolean': function Array__Matrix_boolean(a, unique) {
       if (unique === false || a.length === 0) {
         return Array.isArray(a) ? flatten(a).length : flatten(a.toArray()).length;
       } else {

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

@@ -33,7 +33,7 @@ export var createSetSymDifference = /* #__PURE__ */factory(name, dependencies, _
    * @return {Array | Matrix}    The symmetric difference 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);