mathjs 13.0.2 → 13.1.0

package/lib/esm/function/algebra/derivative.js

@@ -99,24 +99,24 @@ export var createDerivative = /* #__PURE__ */factory(name, dependencies, _ref =>
   // FIXME: move the toTex method of derivative to latex.js. Difficulty is that it relies on parse.
   // NOTE: the optional "order" parameter here is currently unused
   var _derivTex = typed('_derivTex', {
-    'Node, SymbolNode': function NodeSymbolNode(expr, x) {
+    'Node, SymbolNode': function Node_SymbolNode(expr, x) {
       if (isConstantNode(expr) && typeOf(expr.value) === 'string') {
         return _derivTex(parse(expr.value).toString(), x.toString(), 1);
       } else {
         return _derivTex(expr.toTex(), x.toString(), 1);
       }
     },
-    'Node, ConstantNode': function NodeConstantNode(expr, x) {
+    'Node, ConstantNode': function Node_ConstantNode(expr, x) {
       if (typeOf(x.value) === 'string') {
         return _derivTex(expr, parse(x.value));
       } else {
         throw new Error("The second parameter to 'derivative' is a non-string constant");
       }
     },
-    'Node, SymbolNode, ConstantNode': function NodeSymbolNodeConstantNode(expr, x, order) {
+    'Node, SymbolNode, ConstantNode': function Node_SymbolNode_ConstantNode(expr, x, order) {
       return _derivTex(expr.toString(), x.name, order.value);
     },
-    'string, string, number': function stringStringNumber(expr, x, order) {
+    'string, string, number': function string_string_number(expr, x, order) {
       var d;
       if (order === 1) {
         d = '{d\\over d' + x + '}';
@@ -143,11 +143,11 @@ export var createDerivative = /* #__PURE__ */factory(name, dependencies, _ref =>
    */
   // TODO: can we rewrite constTag into a pure function?
   var constTag = typed('constTag', {
-    'Object, ConstantNode, string': function ObjectConstantNodeString(constNodes, node) {
+    'Object, ConstantNode, string': function Object_ConstantNode_string(constNodes, node) {
       constNodes[node] = true;
       return true;
     },
-    'Object, SymbolNode, string': function ObjectSymbolNodeString(constNodes, node, varName) {
+    'Object, SymbolNode, string': function Object_SymbolNode_string(constNodes, node, varName) {
       // Treat other variables like constants. For reasoning, see:
       //   https://en.wikipedia.org/wiki/Partial_derivative
       if (node.name !== varName) {
@@ -156,17 +156,17 @@ export var createDerivative = /* #__PURE__ */factory(name, dependencies, _ref =>
       }
       return false;
     },
-    'Object, ParenthesisNode, string': function ObjectParenthesisNodeString(constNodes, node, varName) {
+    'Object, ParenthesisNode, string': function Object_ParenthesisNode_string(constNodes, node, varName) {
       return constTag(constNodes, node.content, varName);
     },
-    'Object, FunctionAssignmentNode, string': function ObjectFunctionAssignmentNodeString(constNodes, node, varName) {
+    'Object, FunctionAssignmentNode, string': function Object_FunctionAssignmentNode_string(constNodes, node, varName) {
       if (!node.params.includes(varName)) {
         constNodes[node] = true;
         return true;
       }
       return constTag(constNodes, node.expr, varName);
     },
-    'Object, FunctionNode | OperatorNode, string': function ObjectFunctionNodeOperatorNodeString(constNodes, node, varName) {
+    'Object, FunctionNode | OperatorNode, string': function Object_FunctionNode__OperatorNode_string(constNodes, node, varName) {
       if (node.args.length > 0) {
         var isConst = constTag(constNodes, node.args[0], varName);
         for (var i = 1; i < node.args.length; ++i) {
@@ -189,25 +189,25 @@ export var createDerivative = /* #__PURE__ */factory(name, dependencies, _ref =>
    * @return {ConstantNode | SymbolNode | ParenthesisNode | FunctionNode | OperatorNode}    The derivative of `expr`
    */
   var _derivative = typed('_derivative', {
-    'ConstantNode, Object': function ConstantNodeObject(node) {
+    'ConstantNode, Object': function ConstantNode_Object(node) {
       return createConstantNode(0);
     },
-    'SymbolNode, Object': function SymbolNodeObject(node, constNodes) {
+    'SymbolNode, Object': function SymbolNode_Object(node, constNodes) {
       if (constNodes[node] !== undefined) {
         return createConstantNode(0);
       }
       return createConstantNode(1);
     },
-    'ParenthesisNode, Object': function ParenthesisNodeObject(node, constNodes) {
+    'ParenthesisNode, Object': function ParenthesisNode_Object(node, constNodes) {
       return new ParenthesisNode(_derivative(node.content, constNodes));
     },
-    'FunctionAssignmentNode, Object': function FunctionAssignmentNodeObject(node, constNodes) {
+    'FunctionAssignmentNode, Object': function FunctionAssignmentNode_Object(node, constNodes) {
       if (constNodes[node] !== undefined) {
         return createConstantNode(0);
       }
       return _derivative(node.expr, constNodes);
     },
-    'FunctionNode, Object': function FunctionNodeObject(node, constNodes) {
+    'FunctionNode, Object': function FunctionNode_Object(node, constNodes) {
       if (constNodes[node] !== undefined) {
         return createConstantNode(0);
       }
@@ -411,7 +411,7 @@ export var createDerivative = /* #__PURE__ */factory(name, dependencies, _ref =>
       }
       return new OperatorNode(op, func, [chainDerivative, funcDerivative]);
     },
-    'OperatorNode, Object': function OperatorNodeObject(node, constNodes) {
+    'OperatorNode, Object': function OperatorNode_Object(node, constNodes) {
       if (constNodes[node] !== undefined) {
         return createConstantNode(0);
       }

package/lib/esm/function/algebra/lyap.js

@@ -36,16 +36,16 @@ export var createLyap = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @return {Matrix | Array} Matrix P solution to the Continuous-time Lyapunov equation AP+PA'=Q
    */
   return typed(name, {
-    'Matrix, Matrix': function MatrixMatrix(A, Q) {
+    'Matrix, Matrix': function Matrix_Matrix(A, Q) {
       return sylvester(A, transpose(A), multiply(-1, Q));
     },
-    'Array, Matrix': function ArrayMatrix(A, Q) {
+    'Array, Matrix': function Array_Matrix(A, Q) {
       return sylvester(matrix(A), transpose(matrix(A)), multiply(-1, Q));
     },
-    'Matrix, Array': function MatrixArray(A, Q) {
+    'Matrix, Array': function Matrix_Array(A, Q) {
       return sylvester(A, transpose(matrix(A)), matrix(multiply(-1, Q)));
     },
-    'Array, Array': function ArrayArray(A, Q) {
+    'Array, Array': function Array_Array(A, Q) {
       return sylvester(matrix(A), transpose(matrix(A)), matrix(multiply(-1, Q))).toArray();
     }
   });

package/lib/esm/function/algebra/simplify/util.js

@@ -168,11 +168,11 @@ export var createUtil = /* #__PURE__ */factory(name, dependencies, _ref => {
   function allChildren(node, context) {
     var op;
     var children = [];
-    var findChildren = function findChildren(node) {
+    var _findChildren = function findChildren(node) {
       for (var i = 0; i < node.args.length; i++) {
         var child = node.args[i];
         if (isOperatorNode(child) && op === child.op) {
-          findChildren(child);
+          _findChildren(child);
         } else {
           children.push(child);
         }
@@ -180,7 +180,7 @@ export var createUtil = /* #__PURE__ */factory(name, dependencies, _ref => {
     };
     if (isAssociative(node, context)) {
       op = node.op;
-      findChildren(node);
+      _findChildren(node);
       return children;
     } else {
       return node.args;

package/lib/esm/function/algebra/simplifyConstant.js

@@ -62,7 +62,7 @@ export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _
    */
   var simplifyConstant = typed('simplifyConstant', {
     Node: node => _ensureNode(foldFraction(node, {})),
-    'Node, Object': function NodeObject(expr, options) {
+    'Node, Object': function Node_Object(expr, options) {
       return _ensureNode(foldFraction(expr, options));
     }
   });
@@ -142,7 +142,7 @@ export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _
   // Convert numbers to a preferred number type in preference order: Fraction, number, Complex
   // BigNumbers are left alone
   var _toNumber = typed({
-    'string, Object': function stringObject(s, options) {
+    'string, Object': function string_Object(s, options) {
       var numericType = safeNumberType(s, config);
       if (numericType === 'BigNumber') {
         if (bignumber === undefined) {
@@ -161,32 +161,32 @@ export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _
         return _exactFraction(n, options);
       }
     },
-    'Fraction, Object': function FractionObject(s, options) {
+    'Fraction, Object': function Fraction_Object(s, options) {
       return s;
     },
     // we don't need options here
 
-    'BigNumber, Object': function BigNumberObject(s, options) {
+    'BigNumber, Object': function BigNumber_Object(s, options) {
       return s;
     },
     // we don't need options here
 
-    'number, Object': function numberObject(s, options) {
+    'number, Object': function number_Object(s, options) {
       return _exactFraction(s, options);
     },
-    'bigint, Object': function bigintObject(s, options) {
+    'bigint, Object': function bigint_Object(s, options) {
       return s;
     },
-    'Complex, Object': function ComplexObject(s, options) {
+    'Complex, Object': function Complex_Object(s, options) {
       if (s.im !== 0) {
         return s;
       }
       return _exactFraction(s.re, options);
     },
-    'Matrix, Object': function MatrixObject(s, options) {
+    'Matrix, Object': function Matrix_Object(s, options) {
       return matrix(_exactFraction(s.valueOf()));
     },
-    'Array, Object': function ArrayObject(s, options) {
+    'Array, Object': function Array_Object(s, options) {
       return s.map(_exactFraction);
     }
   });

package/lib/esm/function/algebra/solver/lsolve.js

@@ -41,13 +41,13 @@ export var createLsolve = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @return {DenseMatrix | Array}  A column vector with the linear system solution (x)
    */
   return typed(name, {
-    'SparseMatrix, Array | Matrix': function SparseMatrixArrayMatrix(m, b) {
+    'SparseMatrix, Array | Matrix': function SparseMatrix_Array__Matrix(m, b) {
       return _sparseForwardSubstitution(m, b);
     },
-    'DenseMatrix, Array | Matrix': function DenseMatrixArrayMatrix(m, b) {
+    'DenseMatrix, Array | Matrix': function DenseMatrix_Array__Matrix(m, b) {
       return _denseForwardSubstitution(m, b);
     },
-    'Array, Array | Matrix': function ArrayArrayMatrix(a, b) {
+    'Array, Array | Matrix': function Array_Array__Matrix(a, b) {
       var m = matrix(a);
       var r = _denseForwardSubstitution(m, b);
       return r.valueOf();

package/lib/esm/function/algebra/solver/lsolveAll.js

@@ -41,13 +41,13 @@ export var createLsolveAll = /* #__PURE__ */factory(name, dependencies, _ref =>
    * @return {DenseMatrix[] | Array[]}  An array of affine-independent column vectors (x) that solve the linear system
    */
   return typed(name, {
-    'SparseMatrix, Array | Matrix': function SparseMatrixArrayMatrix(m, b) {
+    'SparseMatrix, Array | Matrix': function SparseMatrix_Array__Matrix(m, b) {
       return _sparseForwardSubstitution(m, b);
     },
-    'DenseMatrix, Array | Matrix': function DenseMatrixArrayMatrix(m, b) {
+    'DenseMatrix, Array | Matrix': function DenseMatrix_Array__Matrix(m, b) {
       return _denseForwardSubstitution(m, b);
     },
-    'Array, Array | Matrix': function ArrayArrayMatrix(a, b) {
+    'Array, Array | Matrix': function Array_Array__Matrix(a, b) {
       var m = matrix(a);
       var R = _denseForwardSubstitution(m, b);
       return R.map(r => r.valueOf());

package/lib/esm/function/algebra/solver/lusolve.js

@@ -52,25 +52,25 @@ export var createLusolve = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @return {DenseMatrix | Array}           Column vector with the solution to the linear system A * x = b
    */
   return typed(name, {
-    'Array, Array | Matrix': function ArrayArrayMatrix(a, b) {
+    'Array, Array | Matrix': function Array_Array__Matrix(a, b) {
       a = matrix(a);
       var d = lup(a);
       var x = _lusolve(d.L, d.U, d.p, null, b);
       return x.valueOf();
     },
-    'DenseMatrix, Array | Matrix': function DenseMatrixArrayMatrix(a, b) {
+    'DenseMatrix, Array | Matrix': function DenseMatrix_Array__Matrix(a, b) {
       var d = lup(a);
       return _lusolve(d.L, d.U, d.p, null, b);
     },
-    'SparseMatrix, Array | Matrix': function SparseMatrixArrayMatrix(a, b) {
+    'SparseMatrix, Array | Matrix': function SparseMatrix_Array__Matrix(a, b) {
       var d = lup(a);
       return _lusolve(d.L, d.U, d.p, null, b);
     },
-    'SparseMatrix, Array | Matrix, number, number': function SparseMatrixArrayMatrixNumberNumber(a, b, order, threshold) {
+    'SparseMatrix, Array | Matrix, number, number': function SparseMatrix_Array__Matrix_number_number(a, b, order, threshold) {
       var d = slu(a, order, threshold);
       return _lusolve(d.L, d.U, d.p, d.q, b);
     },
-    'Object, Array | Matrix': function ObjectArrayMatrix(d, b) {
+    'Object, Array | Matrix': function Object_Array__Matrix(d, b) {
       return _lusolve(d.L, d.U, d.p, d.q, b);
     }
   });

package/lib/esm/function/algebra/solver/usolve.js

@@ -41,13 +41,13 @@ export var createUsolve = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @return {DenseMatrix | Array}  A column vector with the linear system solution (x)
    */
   return typed(name, {
-    'SparseMatrix, Array | Matrix': function SparseMatrixArrayMatrix(m, b) {
+    'SparseMatrix, Array | Matrix': function SparseMatrix_Array__Matrix(m, b) {
       return _sparseBackwardSubstitution(m, b);
     },
-    'DenseMatrix, Array | Matrix': function DenseMatrixArrayMatrix(m, b) {
+    'DenseMatrix, Array | Matrix': function DenseMatrix_Array__Matrix(m, b) {
       return _denseBackwardSubstitution(m, b);
     },
-    'Array, Array | Matrix': function ArrayArrayMatrix(a, b) {
+    'Array, Array | Matrix': function Array_Array__Matrix(a, b) {
       var m = matrix(a);
       var r = _denseBackwardSubstitution(m, b);
       return r.valueOf();

package/lib/esm/function/algebra/solver/usolveAll.js

@@ -41,13 +41,13 @@ export var createUsolveAll = /* #__PURE__ */factory(name, dependencies, _ref =>
    * @return {DenseMatrix[] | Array[]}  An array of affine-independent column vectors (x) that solve the linear system
    */
   return typed(name, {
-    'SparseMatrix, Array | Matrix': function SparseMatrixArrayMatrix(m, b) {
+    'SparseMatrix, Array | Matrix': function SparseMatrix_Array__Matrix(m, b) {
       return _sparseBackwardSubstitution(m, b);
     },
-    'DenseMatrix, Array | Matrix': function DenseMatrixArrayMatrix(m, b) {
+    'DenseMatrix, Array | Matrix': function DenseMatrix_Array__Matrix(m, b) {
       return _denseBackwardSubstitution(m, b);
     },
-    'Array, Array | Matrix': function ArrayArrayMatrix(a, b) {
+    'Array, Array | Matrix': function Array_Array__Matrix(a, b) {
       var m = matrix(a);
       var R = _denseBackwardSubstitution(m, b);
       return R.map(r => r.valueOf());

package/lib/esm/function/algebra/sylvester.js

@@ -50,25 +50,25 @@ export var createSylvester = /* #__PURE__ */factory(name, dependencies, _ref =>
    */
   return typed(name, {
     'Matrix, Matrix, Matrix': _sylvester,
-    'Array, Matrix, Matrix': function ArrayMatrixMatrix(A, B, C) {
+    'Array, Matrix, Matrix': function Array_Matrix_Matrix(A, B, C) {
       return _sylvester(matrix(A), B, C);
     },
-    'Array, Array, Matrix': function ArrayArrayMatrix(A, B, C) {
+    'Array, Array, Matrix': function Array_Array_Matrix(A, B, C) {
       return _sylvester(matrix(A), matrix(B), C);
     },
-    'Array, Matrix, Array': function ArrayMatrixArray(A, B, C) {
+    'Array, Matrix, Array': function Array_Matrix_Array(A, B, C) {
       return _sylvester(matrix(A), B, matrix(C));
     },
-    'Matrix, Array, Matrix': function MatrixArrayMatrix(A, B, C) {
+    'Matrix, Array, Matrix': function Matrix_Array_Matrix(A, B, C) {
       return _sylvester(A, matrix(B), C);
     },
-    'Matrix, Array, Array': function MatrixArrayArray(A, B, C) {
+    'Matrix, Array, Array': function Matrix_Array_Array(A, B, C) {
       return _sylvester(A, matrix(B), matrix(C));
     },
-    'Matrix, Matrix, Array': function MatrixMatrixArray(A, B, C) {
+    'Matrix, Matrix, Array': function Matrix_Matrix_Array(A, B, C) {
       return _sylvester(A, B, matrix(C));
     },
-    'Array, Array, Array': function ArrayArrayArray(A, B, C) {
+    'Array, Array, Array': function Array_Array_Array(A, B, C) {
       return _sylvester(matrix(A), matrix(B), matrix(C)).toArray();
     }
   });

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

@@ -20,16 +20,16 @@ export var createAddScalar = /* #__PURE__ */factory(name, dependencies, _ref =>
    */
   return typed(name, {
     'number, number': addNumber,
-    'Complex, Complex': function ComplexComplex(x, y) {
+    'Complex, Complex': function Complex_Complex(x, y) {
       return x.add(y);
     },
-    'BigNumber, BigNumber': function BigNumberBigNumber(x, y) {
+    'BigNumber, BigNumber': function BigNumber_BigNumber(x, y) {
       return x.plus(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.add(y);
     },
     'Unit, Unit': typed.referToSelf(self => (x, y) => {

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

@@ -22,7 +22,7 @@ export var createCeilNumber = /* #__PURE__ */factory(name, ['typed', 'config', '
         return Math.ceil(x);
       }
     },
-    'number, number': function numberNumber(x, n) {
+    'number, number': function number_number(x, n) {
       if (nearlyEqual(x, round(x, n), config.relTol, config.absTol)) {
         return round(x, n);
       } else {
@@ -103,10 +103,10 @@ export var createCeil = /* #__PURE__ */factory(name, dependencies, _ref2 => {
     Complex: function Complex(x) {
       return x.ceil();
     },
-    'Complex, number': function ComplexNumber(x, n) {
+    'Complex, number': function Complex_number(x, n) {
       return x.ceil(n);
     },
-    'Complex, BigNumber': function ComplexBigNumber(x, n) {
+    'Complex, BigNumber': function Complex_BigNumber(x, n) {
       return x.ceil(n.toNumber());
     },
     BigNumber: function BigNumber(x) {
@@ -116,7 +116,7 @@ export var createCeil = /* #__PURE__ */factory(name, dependencies, _ref2 => {
         return x.ceil();
       }
     },
-    'BigNumber, BigNumber': function BigNumberBigNumber(x, n) {
+    'BigNumber, BigNumber': function BigNumber_BigNumber(x, n) {
       if (bigNearlyEqual(x, round(x, n), config.relTol, config.absTol)) {
         return round(x, n);
       } else {
@@ -126,10 +126,10 @@ export var createCeil = /* #__PURE__ */factory(name, dependencies, _ref2 => {
     Fraction: function Fraction(x) {
       return x.ceil();
     },
-    'Fraction, number': function FractionNumber(x, n) {
+    'Fraction, number': function Fraction_number(x, n) {
       return x.ceil(n);
     },
-    'Fraction, BigNumber': function FractionBigNumber(x, n) {
+    'Fraction, BigNumber': function Fraction_BigNumber(x, n) {
       return x.ceil(n.toNumber());
     },
     'Array | Matrix': typed.referToSelf(self => x => {

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

@@ -55,24 +55,24 @@ export var createDivide = /* #__PURE__ */factory(name, dependencies, _ref => {
   return typed('divide', extend({
     // we extend the signatures of divideScalar with signatures dealing with matrices
 
-    'Array | Matrix, Array | Matrix': function ArrayMatrixArrayMatrix(x, y) {
+    'Array | Matrix, Array | Matrix': function Array__Matrix_Array__Matrix(x, y) {
       // TODO: implement matrix right division using pseudo inverse
       // https://www.mathworks.nl/help/matlab/ref/mrdivide.html
       // https://www.gnu.org/software/octave/doc/interpreter/Arithmetic-Ops.html
       // https://stackoverflow.com/questions/12263932/how-does-gnu-octave-matrix-division-work-getting-unexpected-behaviour
       return multiply(x, inv(y));
     },
-    'DenseMatrix, any': function DenseMatrixAny(x, y) {
+    'DenseMatrix, any': function DenseMatrix_any(x, y) {
       return matAlgo14xDs(x, y, divideScalar, false);
     },
-    'SparseMatrix, any': function SparseMatrixAny(x, y) {
+    'SparseMatrix, any': function SparseMatrix_any(x, y) {
       return matAlgo11xS0s(x, y, divideScalar, false);
     },
-    'Array, any': function ArrayAny(x, y) {
+    'Array, any': function Array_any(x, y) {
       // use matrix implementation
       return matAlgo14xDs(matrix(x), y, divideScalar, false).valueOf();
     },
-    'any, Array | Matrix': function anyArrayMatrix(x, y) {
+    'any, Array | Matrix': function any_Array__Matrix(x, y) {
       return multiply(x, inv(y));
     }
   }, divideScalar.signatures));

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

@@ -19,19 +19,19 @@ export var createDivideScalar = /* #__PURE__ */factory(name, dependencies, _ref
    * @private
    */
   return typed(name, {
-    'number, number': function numberNumber(x, y) {
+    'number, number': function number_number(x, y) {
       return x / y;
     },
-    'Complex, Complex': function ComplexComplex(x, y) {
+    'Complex, Complex': function Complex_Complex(x, y) {
       return x.div(y);
     },
-    'BigNumber, BigNumber': function BigNumberBigNumber(x, y) {
+    'BigNumber, BigNumber': function BigNumber_BigNumber(x, y) {
       return x.div(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.div(y);
     },
     'Unit, number | Complex | Fraction | BigNumber | Unit': (x, y) => x.divide(y),

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

@@ -14,7 +14,7 @@ export var createFixNumber = /* #__PURE__ */factory(name, ['typed', 'ceil', 'flo
     number: function number(x) {
       return x > 0 ? floor(x) : ceil(x);
     },
-    'number, number': function numberNumber(x, n) {
+    'number, number': function number_number(x, n) {
       return x > 0 ? floor(x, n) : ceil(x, n);
     }
   });
@@ -84,23 +84,23 @@ export var createFix = /* #__PURE__ */factory(name, dependencies, _ref2 => {
     Complex: function Complex(x) {
       return new _Complex(x.re > 0 ? Math.floor(x.re) : Math.ceil(x.re), x.im > 0 ? Math.floor(x.im) : Math.ceil(x.im));
     },
-    'Complex, number': function ComplexNumber(x, n) {
+    'Complex, number': function Complex_number(x, n) {
       return new _Complex(x.re > 0 ? floor(x.re, n) : ceil(x.re, n), x.im > 0 ? floor(x.im, n) : ceil(x.im, n));
     },
-    'Complex, BigNumber': function ComplexBigNumber(x, bn) {
+    'Complex, BigNumber': function Complex_BigNumber(x, bn) {
       var n = bn.toNumber();
       return new _Complex(x.re > 0 ? floor(x.re, n) : ceil(x.re, n), x.im > 0 ? floor(x.im, n) : ceil(x.im, n));
     },
     BigNumber: function BigNumber(x) {
       return x.isNegative() ? ceil(x) : floor(x);
     },
-    'BigNumber, number | BigNumber': function BigNumberNumberBigNumber(x, n) {
+    'BigNumber, number | BigNumber': function BigNumber_number__BigNumber(x, n) {
       return x.isNegative() ? ceil(x, n) : floor(x, n);
     },
     Fraction: function Fraction(x) {
       return x.s < 0 ? x.ceil() : x.floor();
     },
-    'Fraction, number | BigNumber': function FractionNumberBigNumber(x, n) {
+    'Fraction, number | BigNumber': function Fraction_number__BigNumber(x, n) {
       return x.s < 0 ? ceil(x, n) : floor(x, n);
     },
     'Array | Matrix': typed.referToSelf(self => x => {

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

@@ -22,7 +22,7 @@ export var createFloorNumber = /* #__PURE__ */factory(name, ['typed', 'config',
         return Math.floor(x);
       }
     },
-    'number, number': function numberNumber(x, n) {
+    'number, number': function number_number(x, n) {
       if (nearlyEqual(x, round(x, n), config.relTol, config.absTol)) {
         return round(x, n);
       } else {
@@ -106,10 +106,10 @@ export var createFloor = /* #__PURE__ */factory(name, dependencies, _ref2 => {
     Complex: function Complex(x) {
       return x.floor();
     },
-    'Complex, number': function ComplexNumber(x, n) {
+    'Complex, number': function Complex_number(x, n) {
       return x.floor(n);
     },
-    'Complex, BigNumber': function ComplexBigNumber(x, n) {
+    'Complex, BigNumber': function Complex_BigNumber(x, n) {
       return x.floor(n.toNumber());
     },
     BigNumber: function BigNumber(x) {
@@ -119,7 +119,7 @@ export var createFloor = /* #__PURE__ */factory(name, dependencies, _ref2 => {
         return x.floor();
       }
     },
-    'BigNumber, BigNumber': function BigNumberBigNumber(x, n) {
+    'BigNumber, BigNumber': function BigNumber_BigNumber(x, n) {
       if (bigNearlyEqual(x, round(x, n), config.relTol, config.absTol)) {
         return round(x, n);
       } else {
@@ -129,10 +129,10 @@ export var createFloor = /* #__PURE__ */factory(name, dependencies, _ref2 => {
     Fraction: function Fraction(x) {
       return x.floor();
     },
-    'Fraction, number': function FractionNumber(x, n) {
+    'Fraction, number': function Fraction_number(x, n) {
       return x.floor(n);
     },
-    'Fraction, BigNumber': function FractionBigNumber(x, n) {
+    'Fraction, BigNumber': function Fraction_BigNumber(x, n) {
       return x.floor(n.toNumber());
     },
     'Array | Matrix': typed.referToSelf(self => x => {

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

@@ -15,11 +15,11 @@ export var createHypot = /* #__PURE__ */factory(name, dependencies, _ref => {
     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:
    *
@@ -49,7 +49,7 @@ export var createHypot = /* #__PURE__ */factory(name, dependencies, _ref => {
   });
 
   /**
-   * 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/esm/function/arithmetic/mod.js

@@ -90,10 +90,10 @@ export var createMod = /* #__PURE__ */factory(name, dependencies, _ref => {
    */
   return typed(name, {
     'number, number': _modNumber,
-    'BigNumber, BigNumber': function BigNumberBigNumber(x, y) {
+    'BigNumber, BigNumber': function BigNumber_BigNumber(x, y) {
       return y.isZero() ? x : x.sub(y.mul(floor(x.div(y))));
     },
-    'bigint, bigint': function bigintBigint(x, y) {
+    'bigint, bigint': function bigint_bigint(x, y) {
       if (y === 0n) {
         return x;
       }
@@ -103,7 +103,7 @@ export var createMod = /* #__PURE__ */factory(name, dependencies, _ref => {
       }
       return x % y;
     },
-    'Fraction, Fraction': function FractionFraction(x, y) {
+    'Fraction, Fraction': function Fraction_Fraction(x, y) {
       return y.equals(0) ? x : x.sub(y.mul(floor(x.div(y))));
     }
   }, matrixAlgorithmSuite({

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

@@ -817,7 +817,7 @@ export var createMultiply = /* #__PURE__ */factory(name, dependencies, _ref => {
       // return array or scalar
       return isMatrix(m) ? m.valueOf() : m;
     }),
-    'Matrix, Matrix': function MatrixMatrix(x, y) {
+    'Matrix, Matrix': function Matrix_Matrix(x, y) {
       // dimensions
       var xsize = x.size();
       var ysize = y.size();
@@ -848,23 +848,23 @@ export var createMultiply = /* #__PURE__ */factory(name, dependencies, _ref => {
       // use Matrix * Matrix implementation
       return self(matrix(x, y.storage()), y);
     }),
-    'SparseMatrix, any': function SparseMatrixAny(x, y) {
+    'SparseMatrix, any': function SparseMatrix_any(x, y) {
       return matAlgo11xS0s(x, y, multiplyScalar, false);
     },
-    'DenseMatrix, any': function DenseMatrixAny(x, y) {
+    'DenseMatrix, any': function DenseMatrix_any(x, y) {
       return matAlgo14xDs(x, y, multiplyScalar, false);
     },
-    'any, SparseMatrix': function anySparseMatrix(x, y) {
+    'any, SparseMatrix': function any_SparseMatrix(x, y) {
       return matAlgo11xS0s(y, x, multiplyScalar, true);
     },
-    'any, DenseMatrix': function anyDenseMatrix(x, y) {
+    'any, DenseMatrix': function any_DenseMatrix(x, y) {
       return matAlgo14xDs(y, x, multiplyScalar, true);
     },
-    'Array, any': function ArrayAny(x, y) {
+    'Array, any': function Array_any(x, y) {
       // use matrix implementation
       return matAlgo14xDs(matrix(x), y, multiplyScalar, false).valueOf();
     },
-    'any, Array': function anyArray(x, y) {
+    'any, Array': function any_Array(x, y) {
       // use matrix implementation
       return matAlgo14xDs(matrix(y), x, multiplyScalar, true).valueOf();
     },