mathjs 10.6.2 → 11.0.0

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

@@ -1,7 +1,7 @@
 import { factory } from '../../utils/factory.js';
 import { deepMap } from '../../utils/collection.js';
-import { createAlgorithm12 } from '../../type/matrix/utils/algorithm12.js';
-import { createAlgorithm14 } from '../../type/matrix/utils/algorithm14.js';
+import { createMatAlgo12xSfs } from '../../type/matrix/utils/matAlgo12xSfs.js';
+import { createMatAlgo14xDs } from '../../type/matrix/utils/matAlgo14xDs.js';
 var name = 'fix';
 var dependencies = ['typed', 'Complex', 'matrix', 'ceil', 'floor', 'equalScalar', 'zeros', 'DenseMatrix'];
 export var createFixNumber = /* #__PURE__ */factory(name, ['typed', 'ceil', 'floor'], _ref => {
@@ -30,11 +30,11 @@ export var createFix = /* #__PURE__ */factory(name, dependencies, _ref2 => {
     zeros,
     DenseMatrix
   } = _ref2;
-  var algorithm12 = createAlgorithm12({
+  var matAlgo12xSfs = createMatAlgo12xSfs({
     typed,
     DenseMatrix
   });
-  var algorithm14 = createAlgorithm14({
+  var matAlgo14xDs = createMatAlgo14xDs({
     typed
   });
   var fixNumber = createFixNumber({
@@ -104,26 +104,26 @@ export var createFix = /* #__PURE__ */factory(name, dependencies, _ref2 => {
     'Fraction, number | BigNumber': function FractionNumberBigNumber(x, n) {
       return x.s < 0 ? ceil(x, n) : floor(x, n);
     },
-    'Array | Matrix': function ArrayMatrix(x) {
+    'Array | Matrix': typed.referToSelf(self => x => {
       // deep map collection, skip zeros since fix(0) = 0
-      return deepMap(x, this, true);
-    },
-    'Array | Matrix, number | BigNumber': function ArrayMatrixNumberBigNumber(x, n) {
+      return deepMap(x, self, true);
+    }),
+    'Array | Matrix, number | BigNumber': typed.referToSelf(self => (x, n) => {
       // deep map collection, skip zeros since fix(0) = 0
-      return deepMap(x, i => this(i, n), true);
-    },
-    'number | Complex | Fraction | BigNumber, Array': function numberComplexFractionBigNumberArray(x, y) {
+      return deepMap(x, i => self(i, n), true);
+    }),
+    'number | Complex | Fraction | BigNumber, Array': typed.referToSelf(self => (x, y) => {
       // use matrix implementation
-      return algorithm14(matrix(y), x, this, true).valueOf();
-    },
-    'number | Complex | Fraction | BigNumber, Matrix': function numberComplexFractionBigNumberMatrix(x, y) {
+      return matAlgo14xDs(matrix(y), x, self, true).valueOf();
+    }),
+    'number | Complex | Fraction | BigNumber, Matrix': typed.referToSelf(self => (x, y) => {
       if (equalScalar(x, 0)) return zeros(y.size(), y.storage());
 
       if (y.storage() === 'dense') {
-        return algorithm14(y, x, this, true);
+        return matAlgo14xDs(y, x, self, true);
       }
 
-      return algorithm12(y, x, this, true);
-    }
+      return matAlgo12xSfs(y, x, self, true);
+    })
   });
 });

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

@@ -3,9 +3,9 @@ import { factory } from '../../utils/factory.js';
 import { deepMap } from '../../utils/collection.js';
 import { nearlyEqual } from '../../utils/number.js';
 import { nearlyEqual as bigNearlyEqual } from '../../utils/bignumber/nearlyEqual.js';
-import { createAlgorithm11 } from '../../type/matrix/utils/algorithm11.js';
-import { createAlgorithm12 } from '../../type/matrix/utils/algorithm12.js';
-import { createAlgorithm14 } from '../../type/matrix/utils/algorithm14.js';
+import { createMatAlgo11xS0s } from '../../type/matrix/utils/matAlgo11xS0s.js';
+import { createMatAlgo12xSfs } from '../../type/matrix/utils/matAlgo12xSfs.js';
+import { createMatAlgo14xDs } from '../../type/matrix/utils/matAlgo14xDs.js';
 var name = 'floor';
 var dependencies = ['typed', 'config', 'round', 'matrix', 'equalScalar', 'zeros', 'DenseMatrix'];
 export var createFloorNumber = /* #__PURE__ */factory(name, ['typed', 'config', 'round'], _ref => {
@@ -44,15 +44,15 @@ export var createFloor = /* #__PURE__ */factory(name, dependencies, _ref2 => {
     zeros,
     DenseMatrix
   } = _ref2;
-  var algorithm11 = createAlgorithm11({
+  var matAlgo11xS0s = createMatAlgo11xS0s({
     typed,
     equalScalar
   });
-  var algorithm12 = createAlgorithm12({
+  var matAlgo12xSfs = createMatAlgo12xSfs({
     typed,
     DenseMatrix
   });
-  var algorithm14 = createAlgorithm14({
+  var matAlgo14xDs = createMatAlgo14xDs({
     typed
   });
   var floorNumber = createFloorNumber({
@@ -136,32 +136,32 @@ export var createFloor = /* #__PURE__ */factory(name, dependencies, _ref2 => {
     'Fraction, BigNumber': function FractionBigNumber(x, n) {
       return x.floor(n.toNumber());
     },
-    'Array | Matrix': function ArrayMatrix(x) {
+    'Array | Matrix': typed.referToSelf(self => x => {
       // deep map collection, skip zeros since floor(0) = 0
-      return deepMap(x, this, true);
-    },
-    'Array, number | BigNumber': function ArrayNumberBigNumber(x, n) {
+      return deepMap(x, self, true);
+    }),
+    'Array, number | BigNumber': typed.referToSelf(self => (x, n) => {
       // deep map collection, skip zeros since ceil(0) = 0
-      return deepMap(x, i => this(i, n), true);
-    },
-    'SparseMatrix, number | BigNumber': function SparseMatrixNumberBigNumber(x, y) {
-      return algorithm11(x, y, this, false);
-    },
-    'DenseMatrix, number | BigNumber': function DenseMatrixNumberBigNumber(x, y) {
-      return algorithm14(x, y, this, false);
-    },
-    'number | Complex | Fraction | BigNumber, Array': function numberComplexFractionBigNumberArray(x, y) {
+      return deepMap(x, i => self(i, n), true);
+    }),
+    'SparseMatrix, number | BigNumber': typed.referToSelf(self => (x, y) => {
+      return matAlgo11xS0s(x, y, self, false);
+    }),
+    'DenseMatrix, number | BigNumber': typed.referToSelf(self => (x, y) => {
+      return matAlgo14xDs(x, y, self, false);
+    }),
+    'number | Complex | Fraction | BigNumber, Array': typed.referToSelf(self => (x, y) => {
       // use matrix implementation
-      return algorithm14(matrix(y), x, this, true).valueOf();
-    },
-    'number | Complex | Fraction | BigNumber, Matrix': function numberComplexFractionBigNumberMatrix(x, y) {
+      return matAlgo14xDs(matrix(y), x, self, true).valueOf();
+    }),
+    'number | Complex | Fraction | BigNumber, Matrix': typed.referToSelf(self => (x, y) => {
       if (equalScalar(x, 0)) return zeros(y.size(), y.storage());
 
       if (y.storage() === 'dense') {
-        return algorithm14(y, x, this, true);
+        return matAlgo14xDs(y, x, self, true);
       }
 
-      return algorithm12(y, x, this, true);
-    }
+      return matAlgo12xSfs(y, x, self, true);
+    })
   });
 });

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

@@ -1,9 +1,8 @@
 import { factory } from '../../utils/factory.js';
-import { createAlgorithm01 } from '../../type/matrix/utils/algorithm01.js';
-import { createAlgorithm04 } from '../../type/matrix/utils/algorithm04.js';
-import { createAlgorithm10 } from '../../type/matrix/utils/algorithm10.js';
-import { createAlgorithm13 } from '../../type/matrix/utils/algorithm13.js';
-import { createAlgorithm14 } from '../../type/matrix/utils/algorithm14.js';
+import { createMatAlgo01xDSid } from '../../type/matrix/utils/matAlgo01xDSid.js';
+import { createMatAlgo04xSidSid } from '../../type/matrix/utils/matAlgo04xSidSid.js';
+import { createMatAlgo10xSids } from '../../type/matrix/utils/matAlgo10xSids.js';
+import { createMatrixAlgorithmSuite } from '../../type/matrix/utils/matrixAlgorithmSuite.js';
 import { gcdNumber } from '../../plain/number/index.js';
 var name = 'gcd';
 var dependencies = ['typed', 'matrix', 'equalScalar', 'BigNumber', 'DenseMatrix'];
@@ -15,22 +14,31 @@ export var createGcd = /* #__PURE__ */factory(name, dependencies, _ref => {
     BigNumber,
     DenseMatrix
   } = _ref;
-  var algorithm01 = createAlgorithm01({
+  var matAlgo01xDSid = createMatAlgo01xDSid({
     typed
   });
-  var algorithm04 = createAlgorithm04({
+  var matAlgo04xSidSid = createMatAlgo04xSidSid({
     typed,
     equalScalar
   });
-  var algorithm10 = createAlgorithm10({
+  var matAlgo10xSids = createMatAlgo10xSids({
     typed,
     DenseMatrix
   });
-  var algorithm13 = createAlgorithm13({
-    typed
+  var matrixAlgorithmSuite = createMatrixAlgorithmSuite({
+    typed,
+    matrix
   });
-  var algorithm14 = createAlgorithm14({
-    typed
+  var gcdTypes = 'number | BigNumber | Fraction | Matrix | Array';
+  var gcdManySignature = {};
+  gcdManySignature["".concat(gcdTypes, ", ").concat(gcdTypes, ", ...").concat(gcdTypes)] = typed.referToSelf(self => (a, b, args) => {
+    var res = self(a, b);
+
+    for (var i = 0; i < args.length; i++) {
+      res = self(res, args[i]);
+    }
+
+    return res;
   });
   /**
    * Calculate the greatest common divisor for two or more values or arrays.
@@ -61,64 +69,12 @@ export var createGcd = /* #__PURE__ */factory(name, dependencies, _ref => {
   return typed(name, {
     'number, number': gcdNumber,
     'BigNumber, BigNumber': _gcdBigNumber,
-    'Fraction, Fraction': function FractionFraction(x, y) {
-      return x.gcd(y);
-    },
-    'SparseMatrix, SparseMatrix': function SparseMatrixSparseMatrix(x, y) {
-      return algorithm04(x, y, this);
-    },
-    'SparseMatrix, DenseMatrix': function SparseMatrixDenseMatrix(x, y) {
-      return algorithm01(y, x, this, true);
-    },
-    'DenseMatrix, SparseMatrix': function DenseMatrixSparseMatrix(x, y) {
-      return algorithm01(x, y, this, false);
-    },
-    'DenseMatrix, DenseMatrix': function DenseMatrixDenseMatrix(x, y) {
-      return algorithm13(x, y, this);
-    },
-    'Array, Array': function ArrayArray(x, y) {
-      // use matrix implementation
-      return this(matrix(x), matrix(y)).valueOf();
-    },
-    'Array, Matrix': function ArrayMatrix(x, y) {
-      // use matrix implementation
-      return this(matrix(x), y);
-    },
-    'Matrix, Array': function MatrixArray(x, y) {
-      // use matrix implementation
-      return this(x, matrix(y));
-    },
-    'SparseMatrix, number | BigNumber': function SparseMatrixNumberBigNumber(x, y) {
-      return algorithm10(x, y, this, false);
-    },
-    'DenseMatrix, number | BigNumber': function DenseMatrixNumberBigNumber(x, y) {
-      return algorithm14(x, y, this, false);
-    },
-    'number | BigNumber, SparseMatrix': function numberBigNumberSparseMatrix(x, y) {
-      return algorithm10(y, x, this, true);
-    },
-    'number | BigNumber, DenseMatrix': function numberBigNumberDenseMatrix(x, y) {
-      return algorithm14(y, x, this, true);
-    },
-    'Array, number | BigNumber': function ArrayNumberBigNumber(x, y) {
-      // use matrix implementation
-      return algorithm14(matrix(x), y, this, false).valueOf();
-    },
-    'number | BigNumber, Array': function numberBigNumberArray(x, y) {
-      // use matrix implementation
-      return algorithm14(matrix(y), x, this, true).valueOf();
-    },
-    // TODO: need a smarter notation here
-    'Array | Matrix | number | BigNumber, Array | Matrix | number | BigNumber, ...Array | Matrix | number | BigNumber': function ArrayMatrixNumberBigNumberArrayMatrixNumberBigNumberArrayMatrixNumberBigNumber(a, b, args) {
-      var res = this(a, b);
-
-      for (var i = 0; i < args.length; i++) {
-        res = this(res, args[i]);
-      }
-
-      return res;
-    }
-  });
+    'Fraction, Fraction': (x, y) => x.gcd(y)
+  }, matrixAlgorithmSuite({
+    SS: matAlgo04xSidSid,
+    DS: matAlgo01xDSid,
+    Ss: matAlgo10xSids
+  }), gcdManySignature);
   /**
    * Calculate gcd for BigNumbers
    * @param {BigNumber} a

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

@@ -1,5 +1,6 @@
 import { factory } from '../../utils/factory.js';
 import { flatten } from '../../utils/array.js';
+import { isComplex } from '../../utils/is.js';
 var name = 'hypot';
 var dependencies = ['typed', 'abs', 'addScalar', 'divideScalar', 'multiplyScalar', 'sqrt', 'smaller', 'isPositive'];
 export var createHypot = /* #__PURE__ */factory(name, dependencies, _ref => {
@@ -44,12 +45,8 @@ export var createHypot = /* #__PURE__ */factory(name, dependencies, _ref => {
    */
   return typed(name, {
     '... number | BigNumber': _hypot,
-    Array: function Array(x) {
-      return this.apply(this, flatten(x));
-    },
-    Matrix: function Matrix(x) {
-      return this.apply(this, flatten(x.toArray()));
-    }
+    Array: _hypot,
+    Matrix: M => _hypot(flatten(M.toArray()))
   });
   /**
    * Calculate the hypotenusa for an Array with values
@@ -65,6 +62,10 @@ export var createHypot = /* #__PURE__ */factory(name, dependencies, _ref => {
     var largest = 0;
 
     for (var i = 0; i < args.length; i++) {
+      if (isComplex(args[i])) {
+        throw new TypeError('Unexpected type of argument to hypot');
+      }
+
       var value = abs(args[i]);
 
       if (smaller(largest, value)) {

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

@@ -1,9 +1,8 @@
 import { factory } from '../../utils/factory.js';
-import { createAlgorithm02 } from '../../type/matrix/utils/algorithm02.js';
-import { createAlgorithm06 } from '../../type/matrix/utils/algorithm06.js';
-import { createAlgorithm11 } from '../../type/matrix/utils/algorithm11.js';
-import { createAlgorithm13 } from '../../type/matrix/utils/algorithm13.js';
-import { createAlgorithm14 } from '../../type/matrix/utils/algorithm14.js';
+import { createMatAlgo02xDS0 } from '../../type/matrix/utils/matAlgo02xDS0.js';
+import { createMatAlgo06xS0S0 } from '../../type/matrix/utils/matAlgo06xS0S0.js';
+import { createMatAlgo11xS0s } from '../../type/matrix/utils/matAlgo11xS0s.js';
+import { createMatrixAlgorithmSuite } from '../../type/matrix/utils/matrixAlgorithmSuite.js';
 import { lcmNumber } from '../../plain/number/index.js';
 var name = 'lcm';
 var dependencies = ['typed', 'matrix', 'equalScalar'];
@@ -13,23 +12,32 @@ export var createLcm = /* #__PURE__ */factory(name, dependencies, _ref => {
     matrix,
     equalScalar
   } = _ref;
-  var algorithm02 = createAlgorithm02({
+  var matAlgo02xDS0 = createMatAlgo02xDS0({
     typed,
     equalScalar
   });
-  var algorithm06 = createAlgorithm06({
+  var matAlgo06xS0S0 = createMatAlgo06xS0S0({
     typed,
     equalScalar
   });
-  var algorithm11 = createAlgorithm11({
+  var matAlgo11xS0s = createMatAlgo11xS0s({
     typed,
     equalScalar
   });
-  var algorithm13 = createAlgorithm13({
-    typed
+  var matrixAlgorithmSuite = createMatrixAlgorithmSuite({
+    typed,
+    matrix
   });
-  var algorithm14 = createAlgorithm14({
-    typed
+  var lcmTypes = 'number | BigNumber | Fraction | Matrix | Array';
+  var lcmManySignature = {};
+  lcmManySignature["".concat(lcmTypes, ", ").concat(lcmTypes, ", ...").concat(lcmTypes)] = typed.referToSelf(self => (a, b, args) => {
+    var res = self(a, b);
+
+    for (var i = 0; i < args.length; i++) {
+      res = self(res, args[i]);
+    }
+
+    return res;
   });
   /**
    * Calculate the least common multiple for two or more values or arrays.
@@ -64,64 +72,12 @@ export var createLcm = /* #__PURE__ */factory(name, dependencies, _ref => {
   return typed(name, {
     'number, number': lcmNumber,
     'BigNumber, BigNumber': _lcmBigNumber,
-    'Fraction, Fraction': function FractionFraction(x, y) {
-      return x.lcm(y);
-    },
-    'SparseMatrix, SparseMatrix': function SparseMatrixSparseMatrix(x, y) {
-      return algorithm06(x, y, this);
-    },
-    'SparseMatrix, DenseMatrix': function SparseMatrixDenseMatrix(x, y) {
-      return algorithm02(y, x, this, true);
-    },
-    'DenseMatrix, SparseMatrix': function DenseMatrixSparseMatrix(x, y) {
-      return algorithm02(x, y, this, false);
-    },
-    'DenseMatrix, DenseMatrix': function DenseMatrixDenseMatrix(x, y) {
-      return algorithm13(x, y, this);
-    },
-    'Array, Array': function ArrayArray(x, y) {
-      // use matrix implementation
-      return this(matrix(x), matrix(y)).valueOf();
-    },
-    'Array, Matrix': function ArrayMatrix(x, y) {
-      // use matrix implementation
-      return this(matrix(x), y);
-    },
-    'Matrix, Array': function MatrixArray(x, y) {
-      // use matrix implementation
-      return this(x, matrix(y));
-    },
-    'SparseMatrix, number | BigNumber': function SparseMatrixNumberBigNumber(x, y) {
-      return algorithm11(x, y, this, false);
-    },
-    'DenseMatrix, number | BigNumber': function DenseMatrixNumberBigNumber(x, y) {
-      return algorithm14(x, y, this, false);
-    },
-    'number | BigNumber, SparseMatrix': function numberBigNumberSparseMatrix(x, y) {
-      return algorithm11(y, x, this, true);
-    },
-    'number | BigNumber, DenseMatrix': function numberBigNumberDenseMatrix(x, y) {
-      return algorithm14(y, x, this, true);
-    },
-    'Array, number | BigNumber': function ArrayNumberBigNumber(x, y) {
-      // use matrix implementation
-      return algorithm14(matrix(x), y, this, false).valueOf();
-    },
-    'number | BigNumber, Array': function numberBigNumberArray(x, y) {
-      // use matrix implementation
-      return algorithm14(matrix(y), x, this, true).valueOf();
-    },
-    // TODO: need a smarter notation here
-    'Array | Matrix | number | BigNumber, Array | Matrix | number | BigNumber, ...Array | Matrix | number | BigNumber': function ArrayMatrixNumberBigNumberArrayMatrixNumberBigNumberArrayMatrixNumberBigNumber(a, b, args) {
-      var res = this(a, b);
-
-      for (var i = 0; i < args.length; i++) {
-        res = this(res, args[i]);
-      }
-
-      return res;
-    }
-  });
+    'Fraction, Fraction': (x, y) => x.lcm(y)
+  }, matrixAlgorithmSuite({
+    SS: matAlgo06xS0S0,
+    DS: matAlgo02xDS0,
+    Ss: matAlgo11xS0s
+  }), lcmManySignature);
   /**
    * Calculate lcm for two BigNumbers
    * @param {BigNumber} a

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

@@ -1,5 +1,4 @@
 import { factory } from '../../utils/factory.js';
-import { deepMap } from '../../utils/collection.js';
 import { logNumber } from '../../plain/number/index.js';
 var name = 'log';
 var dependencies = ['config', 'typed', 'divideScalar', 'Complex'];
@@ -14,7 +13,8 @@ export var createLog = /* #__PURE__ */factory(name, dependencies, _ref => {
   /**
    * Calculate the logarithm of a value.
    *
-   * For matrices, the function is evaluated element wise.
+   * To avoid confusion with the matrix logarithm, this function does not
+   * apply to matrices.
    *
    * Syntax:
    *
@@ -37,12 +37,12 @@ export var createLog = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    *    exp, log2, log10, log1p
    *
-   * @param {number | BigNumber | Complex | Array | Matrix} x
+   * @param {number | BigNumber | Complex} x
    *            Value for which to calculate the logarithm.
    * @param {number | BigNumber | Complex} [base=e]
    *            Optional base for the logarithm. If not provided, the natural
    *            logarithm of `x` is calculated.
-   * @return {number | BigNumber | Complex | Array | Matrix}
+   * @return {number | BigNumber | Complex}
    *            Returns the logarithm of `x`
    */
   return typed(name, {
@@ -65,12 +65,9 @@ export var createLog = /* #__PURE__ */factory(name, dependencies, _ref => {
         return new Complex(x.toNumber(), 0).log();
       }
     },
-    'Array | Matrix': function ArrayMatrix(x) {
-      return deepMap(x, this);
-    },
-    'any, any': function anyAny(x, base) {
+    'any, any': typed.referToSelf(self => (x, base) => {
       // calculate logarithm for a specified base, log(x, base)
-      return divideScalar(this(x), this(base));
-    }
+      return divideScalar(self(x), self(base));
+    })
   });
 });

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

@@ -55,8 +55,6 @@ export var createLog10 = /* #__PURE__ */factory(name, dependencies, _ref => {
         return new _Complex(x.toNumber(), 0).log().div(Math.LN10);
       }
     },
-    'Array | Matrix': function ArrayMatrix(x) {
-      return deepMap(x, this);
-    }
+    'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self))
   });
 });

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

@@ -63,13 +63,11 @@ export var createLog1p = /* #__PURE__ */factory(name, dependencies, _ref => {
         return _log1pComplex(new Complex(x.toNumber(), 0));
       }
     },
-    'Array | Matrix': function ArrayMatrix(x) {
-      return deepMap(x, this);
-    },
-    'any, any': function anyAny(x, base) {
+    'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self)),
+    'any, any': typed.referToSelf(self => (x, base) => {
       // calculate logarithm for a specified base, log1p(x, base)
-      return divideScalar(this(x), log(base));
-    }
+      return divideScalar(self(x), log(base));
+    })
   });
   /**
    * Calculate the natural logarithm of a complex number + 1

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

@@ -53,9 +53,7 @@ export var createLog2 = /* #__PURE__ */factory(name, dependencies, _ref => {
         return _log2Complex(new Complex(x.toNumber(), 0));
       }
     },
-    'Array | Matrix': function ArrayMatrix(x) {
-      return deepMap(x, this);
-    }
+    'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self))
   });
   /**
    * Calculate log2 for a complex value

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

@@ -1,12 +1,11 @@
 import { factory } from '../../utils/factory.js';
-import { createAlgorithm02 } from '../../type/matrix/utils/algorithm02.js';
-import { createAlgorithm03 } from '../../type/matrix/utils/algorithm03.js';
-import { createAlgorithm05 } from '../../type/matrix/utils/algorithm05.js';
-import { createAlgorithm11 } from '../../type/matrix/utils/algorithm11.js';
-import { createAlgorithm12 } from '../../type/matrix/utils/algorithm12.js';
-import { createAlgorithm13 } from '../../type/matrix/utils/algorithm13.js';
-import { createAlgorithm14 } from '../../type/matrix/utils/algorithm14.js';
+import { createMatAlgo02xDS0 } from '../../type/matrix/utils/matAlgo02xDS0.js';
+import { createMatAlgo03xDSf } from '../../type/matrix/utils/matAlgo03xDSf.js';
+import { createMatAlgo05xSfSf } from '../../type/matrix/utils/matAlgo05xSfSf.js';
+import { createMatAlgo11xS0s } from '../../type/matrix/utils/matAlgo11xS0s.js';
+import { createMatAlgo12xSfs } from '../../type/matrix/utils/matAlgo12xSfs.js';
 import { modNumber } from '../../plain/number/index.js';
+import { createMatrixAlgorithmSuite } from '../../type/matrix/utils/matrixAlgorithmSuite.js';
 var name = 'mod';
 var dependencies = ['typed', 'matrix', 'equalScalar', 'DenseMatrix'];
 export var createMod = /* #__PURE__ */factory(name, dependencies, _ref => {
@@ -16,30 +15,28 @@ export var createMod = /* #__PURE__ */factory(name, dependencies, _ref => {
     equalScalar,
     DenseMatrix
   } = _ref;
-  var algorithm02 = createAlgorithm02({
+  var matAlgo02xDS0 = createMatAlgo02xDS0({
     typed,
     equalScalar
   });
-  var algorithm03 = createAlgorithm03({
+  var matAlgo03xDSf = createMatAlgo03xDSf({
     typed
   });
-  var algorithm05 = createAlgorithm05({
+  var matAlgo05xSfSf = createMatAlgo05xSfSf({
     typed,
     equalScalar
   });
-  var algorithm11 = createAlgorithm11({
+  var matAlgo11xS0s = createMatAlgo11xS0s({
     typed,
     equalScalar
   });
-  var algorithm12 = createAlgorithm12({
+  var matAlgo12xSfs = createMatAlgo12xSfs({
     typed,
     DenseMatrix
   });
-  var algorithm13 = createAlgorithm13({
-    typed
-  });
-  var algorithm14 = createAlgorithm14({
-    typed
+  var matrixAlgorithmSuite = createMatrixAlgorithmSuite({
+    typed,
+    matrix
   });
   /**
    * Calculates the modulus, the remainder of an integer division.
@@ -93,50 +90,12 @@ export var createMod = /* #__PURE__ */factory(name, dependencies, _ref => {
 
 
       return x.compare(0) >= 0 ? x.mod(y) : x.mod(y).add(y).mod(y);
-    },
-    'SparseMatrix, SparseMatrix': function SparseMatrixSparseMatrix(x, y) {
-      return algorithm05(x, y, this, false);
-    },
-    'SparseMatrix, DenseMatrix': function SparseMatrixDenseMatrix(x, y) {
-      return algorithm02(y, x, this, true);
-    },
-    'DenseMatrix, SparseMatrix': function DenseMatrixSparseMatrix(x, y) {
-      return algorithm03(x, y, this, false);
-    },
-    'DenseMatrix, DenseMatrix': function DenseMatrixDenseMatrix(x, y) {
-      return algorithm13(x, y, this);
-    },
-    'Array, Array': function ArrayArray(x, y) {
-      // use matrix implementation
-      return this(matrix(x), matrix(y)).valueOf();
-    },
-    'Array, Matrix': function ArrayMatrix(x, y) {
-      // use matrix implementation
-      return this(matrix(x), y);
-    },
-    'Matrix, Array': function MatrixArray(x, y) {
-      // use matrix implementation
-      return this(x, matrix(y));
-    },
-    'SparseMatrix, any': function SparseMatrixAny(x, y) {
-      return algorithm11(x, y, this, false);
-    },
-    'DenseMatrix, any': function DenseMatrixAny(x, y) {
-      return algorithm14(x, y, this, false);
-    },
-    'any, SparseMatrix': function anySparseMatrix(x, y) {
-      return algorithm12(y, x, this, true);
-    },
-    'any, DenseMatrix': function anyDenseMatrix(x, y) {
-      return algorithm14(y, x, this, true);
-    },
-    'Array, any': function ArrayAny(x, y) {
-      // use matrix implementation
-      return algorithm14(matrix(x), y, this, false).valueOf();
-    },
-    'any, Array': function anyArray(x, y) {
-      // use matrix implementation
-      return algorithm14(matrix(y), x, this, true).valueOf();
     }
-  });
+  }, matrixAlgorithmSuite({
+    SS: matAlgo05xSfSf,
+    DS: matAlgo03xDSf,
+    SD: matAlgo02xDS0,
+    Ss: matAlgo11xS0s,
+    sS: matAlgo12xSfs
+  }));
 });