mathjs 10.6.2 → 11.0.0

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

@@ -1,11 +1,10 @@
 import { factory } from '../../utils/factory.js';
-import { DimensionError } from '../../error/DimensionError.js';
-import { createAlgorithm01 } from '../../type/matrix/utils/algorithm01.js';
-import { createAlgorithm03 } from '../../type/matrix/utils/algorithm03.js';
-import { createAlgorithm05 } from '../../type/matrix/utils/algorithm05.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 { createMatAlgo03xDSf } from '../../type/matrix/utils/matAlgo03xDSf.js';
+import { createMatAlgo05xSfSf } from '../../type/matrix/utils/matAlgo05xSfSf.js';
+import { createMatAlgo10xSids } from '../../type/matrix/utils/matAlgo10xSids.js';
+import { createMatAlgo12xSfs } from '../../type/matrix/utils/matAlgo12xSfs.js';
+import { createMatrixAlgorithmSuite } from '../../type/matrix/utils/matrixAlgorithmSuite.js';
 var name = 'subtract';
 var dependencies = ['typed', 'matrix', 'equalScalar', 'addScalar', 'unaryMinus', 'DenseMatrix'];
 export var createSubtract = /* #__PURE__ */factory(name, dependencies, _ref => {
@@ -18,25 +17,27 @@ export var createSubtract = /* #__PURE__ */factory(name, dependencies, _ref => {
     DenseMatrix
   } = _ref;
   // TODO: split function subtract in two: subtract and subtractScalar
-  var algorithm01 = createAlgorithm01({
+  var matAlgo01xDSid = createMatAlgo01xDSid({
     typed
   });
-  var algorithm03 = createAlgorithm03({
+  var matAlgo03xDSf = createMatAlgo03xDSf({
     typed
   });
-  var algorithm05 = createAlgorithm05({
+  var matAlgo05xSfSf = createMatAlgo05xSfSf({
     typed,
     equalScalar
   });
-  var algorithm10 = createAlgorithm10({
+  var matAlgo10xSids = createMatAlgo10xSids({
     typed,
     DenseMatrix
   });
-  var algorithm13 = createAlgorithm13({
-    typed
+  var matAlgo12xSfs = createMatAlgo12xSfs({
+    typed,
+    DenseMatrix
   });
-  var algorithm14 = createAlgorithm14({
-    typed
+  var matrixAlgorithmSuite = createMatrixAlgorithmSuite({
+    typed,
+    matrix
   });
   /**
    * Subtract two values, `x - y`.
@@ -73,19 +74,11 @@ export var createSubtract = /* #__PURE__ */factory(name, dependencies, _ref => {
    */
 
   return typed(name, {
-    'number, number': function numberNumber(x, y) {
-      return x - y;
-    },
-    'Complex, Complex': function ComplexComplex(x, y) {
-      return x.sub(y);
-    },
-    'BigNumber, BigNumber': function BigNumberBigNumber(x, y) {
-      return x.minus(y);
-    },
-    'Fraction, Fraction': function FractionFraction(x, y) {
-      return x.sub(y);
-    },
-    'Unit, Unit': function UnitUnit(x, y) {
+    'number, number': (x, y) => x - y,
+    'Complex, Complex': (x, y) => x.sub(y),
+    'BigNumber, BigNumber': (x, y) => x.minus(y),
+    'Fraction, Fraction': (x, y) => x.sub(y),
+    'Unit, Unit': typed.referToSelf(self => (x, y) => {
       if (x.value === null) {
         throw new Error('Parameter x contains a unit with undefined value');
       }
@@ -99,72 +92,15 @@ export var createSubtract = /* #__PURE__ */factory(name, dependencies, _ref => {
       }
 
       var res = x.clone();
-      res.value = this(res.value, y.value);
+      res.value = typed.find(self, [res.valueType(), y.valueType()])(res.value, y.value);
       res.fixPrefix = false;
       return res;
-    },
-    'SparseMatrix, SparseMatrix': function SparseMatrixSparseMatrix(x, y) {
-      checkEqualDimensions(x, y);
-      return algorithm05(x, y, this);
-    },
-    'SparseMatrix, DenseMatrix': function SparseMatrixDenseMatrix(x, y) {
-      checkEqualDimensions(x, y);
-      return algorithm03(y, x, this, true);
-    },
-    'DenseMatrix, SparseMatrix': function DenseMatrixSparseMatrix(x, y) {
-      checkEqualDimensions(x, y);
-      return algorithm01(x, y, this, false);
-    },
-    'DenseMatrix, DenseMatrix': function DenseMatrixDenseMatrix(x, y) {
-      checkEqualDimensions(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 algorithm10(x, unaryMinus(y), addScalar);
-    },
-    'DenseMatrix, any': function DenseMatrixAny(x, y) {
-      return algorithm14(x, y, this);
-    },
-    'any, SparseMatrix': function anySparseMatrix(x, y) {
-      return algorithm10(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();
-    }
-  });
-});
-/**
- * Check whether matrix x and y have the same number of dimensions.
- * Throws a DimensionError when dimensions are not equal
- * @param {Matrix} x
- * @param {Matrix} y
- */
-
-function checkEqualDimensions(x, y) {
-  var xsize = x.size();
-  var ysize = y.size();
-
-  if (xsize.length !== ysize.length) {
-    throw new DimensionError(xsize.length, ysize.length);
-  }
-}
+    })
+  }, matrixAlgorithmSuite({
+    SS: matAlgo05xSfSf,
+    DS: matAlgo01xDSid,
+    SD: matAlgo03xDSf,
+    Ss: matAlgo12xSfs,
+    sS: matAlgo10xSids
+  }));
+});

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

@@ -33,24 +33,14 @@ export var createUnaryMinus = /* #__PURE__ */factory(name, dependencies, _ref =>
    */
   return typed(name, {
     number: unaryMinusNumber,
-    Complex: function Complex(x) {
-      return x.neg();
-    },
-    BigNumber: function BigNumber(x) {
-      return x.neg();
-    },
-    Fraction: function Fraction(x) {
-      return x.neg();
-    },
-    Unit: function Unit(x) {
+    'Complex | BigNumber | Fraction': x => x.neg(),
+    Unit: typed.referToSelf(self => x => {
       var res = x.clone();
-      res.value = this(x.value);
+      res.value = typed.find(self, res.valueType())(x.value);
       return res;
-    },
-    'Array | Matrix': function ArrayMatrix(x) {
-      // deep map collection, skip zeros since unaryMinus(0) = 0
-      return deepMap(x, this, true);
-    } // TODO: add support for string
+    }),
+    // deep map collection, skip zeros since unaryMinus(0) = 0
+    'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self, true)) // TODO: add support for string
 
   });
 });

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

@@ -48,10 +48,8 @@ export var createUnaryPlus = /* #__PURE__ */factory(name, dependencies, _ref =>
     Unit: function Unit(x) {
       return x.clone();
     },
-    'Array | Matrix': function ArrayMatrix(x) {
-      // deep map collection, skip zeros since unaryPlus(0) = 0
-      return deepMap(x, this, true);
-    },
+    // deep map collection, skip zeros since unaryPlus(0) = 0
+    'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self, true)),
     'boolean | string': function booleanString(x) {
       // convert to a number or bignumber
       return config.number === 'BigNumber' ? new BigNumber(+x) : +x;

package/lib/esm/function/bitwise/bitAnd.js

@@ -1,10 +1,9 @@
 import { bitAndBigNumber } from '../../utils/bignumber/bitwise.js';
-import { createAlgorithm02 } from '../../type/matrix/utils/algorithm02.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 { createAlgorithm06 } from '../../type/matrix/utils/algorithm06.js';
+import { createMatAlgo02xDS0 } from '../../type/matrix/utils/matAlgo02xDS0.js';
+import { createMatAlgo11xS0s } from '../../type/matrix/utils/matAlgo11xS0s.js';
+import { createMatAlgo06xS0S0 } from '../../type/matrix/utils/matAlgo06xS0S0.js';
 import { factory } from '../../utils/factory.js';
+import { createMatrixAlgorithmSuite } from '../../type/matrix/utils/matrixAlgorithmSuite.js';
 import { bitAndNumber } from '../../plain/number/index.js';
 var name = 'bitAnd';
 var dependencies = ['typed', 'matrix', 'equalScalar'];
@@ -14,23 +13,21 @@ export var createBitAnd = /* #__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 algorithm14 = createAlgorithm14({
-    typed
+  var matrixAlgorithmSuite = createMatrixAlgorithmSuite({
+    typed,
+    matrix
   });
   /**
    * Bitwise AND two values, `x & y`.
@@ -57,50 +54,10 @@ export var createBitAnd = /* #__PURE__ */factory(name, dependencies, _ref => {
 
   return typed(name, {
     'number, number': bitAndNumber,
-    'BigNumber, BigNumber': bitAndBigNumber,
-    'SparseMatrix, SparseMatrix': function SparseMatrixSparseMatrix(x, y) {
-      return algorithm06(x, y, this, false);
-    },
-    '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, 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 algorithm11(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();
-    }
-  });
+    'BigNumber, BigNumber': bitAndBigNumber
+  }, matrixAlgorithmSuite({
+    SS: matAlgo06xS0S0,
+    DS: matAlgo02xDS0,
+    Ss: matAlgo11xS0s
+  }));
 });

package/lib/esm/function/bitwise/bitNot.js

@@ -34,8 +34,6 @@ export var createBitNot = /* #__PURE__ */factory(name, dependencies, _ref => {
   return typed(name, {
     number: bitNotNumber,
     BigNumber: bitNotBigNumber,
-    'Array | Matrix': function ArrayMatrix(x) {
-      return deepMap(x, this);
-    }
+    'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self))
   });
 });

package/lib/esm/function/bitwise/bitOr.js

@@ -1,10 +1,9 @@
 import { bitOrBigNumber } from '../../utils/bignumber/bitwise.js';
 import { factory } from '../../utils/factory.js';
-import { createAlgorithm14 } from '../../type/matrix/utils/algorithm14.js';
-import { createAlgorithm13 } from '../../type/matrix/utils/algorithm13.js';
-import { createAlgorithm10 } from '../../type/matrix/utils/algorithm10.js';
-import { createAlgorithm04 } from '../../type/matrix/utils/algorithm04.js';
-import { createAlgorithm01 } from '../../type/matrix/utils/algorithm01.js';
+import { createMatAlgo10xSids } from '../../type/matrix/utils/matAlgo10xSids.js';
+import { createMatAlgo04xSidSid } from '../../type/matrix/utils/matAlgo04xSidSid.js';
+import { createMatAlgo01xDSid } from '../../type/matrix/utils/matAlgo01xDSid.js';
+import { createMatrixAlgorithmSuite } from '../../type/matrix/utils/matrixAlgorithmSuite.js';
 import { bitOrNumber } from '../../plain/number/index.js';
 var name = 'bitOr';
 var dependencies = ['typed', 'matrix', 'equalScalar', 'DenseMatrix'];
@@ -15,22 +14,20 @@ export var createBitOr = /* #__PURE__ */factory(name, dependencies, _ref => {
     equalScalar,
     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 algorithm14 = createAlgorithm14({
-    typed
+  var matrixAlgorithmSuite = createMatrixAlgorithmSuite({
+    typed,
+    matrix
   });
   /**
    * Bitwise OR two values, `x | y`.
@@ -58,50 +55,10 @@ export var createBitOr = /* #__PURE__ */factory(name, dependencies, _ref => {
 
   return typed(name, {
     'number, number': bitOrNumber,
-    'BigNumber, BigNumber': bitOrBigNumber,
-    '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, any': function SparseMatrixAny(x, y) {
-      return algorithm10(x, y, this, false);
-    },
-    'DenseMatrix, any': function DenseMatrixAny(x, y) {
-      return algorithm14(x, y, this, false);
-    },
-    'any, SparseMatrix': function anySparseMatrix(x, y) {
-      return algorithm10(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();
-    }
-  });
+    'BigNumber, BigNumber': bitOrBigNumber
+  }, matrixAlgorithmSuite({
+    SS: matAlgo04xSidSid,
+    DS: matAlgo01xDSid,
+    Ss: matAlgo10xSids
+  }));
 });

package/lib/esm/function/bitwise/bitXor.js

@@ -1,10 +1,9 @@
 import { bitXor as bigBitXor } from '../../utils/bignumber/bitwise.js';
-import { createAlgorithm03 } from '../../type/matrix/utils/algorithm03.js';
-import { createAlgorithm07 } from '../../type/matrix/utils/algorithm07.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 { createMatAlgo03xDSf } from '../../type/matrix/utils/matAlgo03xDSf.js';
+import { createMatAlgo07xSSf } from '../../type/matrix/utils/matAlgo07xSSf.js';
+import { createMatAlgo12xSfs } from '../../type/matrix/utils/matAlgo12xSfs.js';
 import { factory } from '../../utils/factory.js';
+import { createMatrixAlgorithmSuite } from '../../type/matrix/utils/matrixAlgorithmSuite.js';
 import { bitXorNumber } from '../../plain/number/index.js';
 var name = 'bitXor';
 var dependencies = ['typed', 'matrix', 'DenseMatrix'];
@@ -14,22 +13,20 @@ export var createBitXor = /* #__PURE__ */factory(name, dependencies, _ref => {
     matrix,
     DenseMatrix
   } = _ref;
-  var algorithm03 = createAlgorithm03({
+  var matAlgo03xDSf = createMatAlgo03xDSf({
     typed
   });
-  var algorithm07 = createAlgorithm07({
+  var matAlgo07xSSf = createMatAlgo07xSSf({
     typed,
     DenseMatrix
   });
-  var algorithm12 = createAlgorithm12({
+  var matAlgo12xSfs = createMatAlgo12xSfs({
     typed,
     DenseMatrix
   });
-  var algorithm13 = createAlgorithm13({
-    typed
-  });
-  var algorithm14 = createAlgorithm14({
-    typed
+  var matrixAlgorithmSuite = createMatrixAlgorithmSuite({
+    typed,
+    matrix
   });
   /**
    * Bitwise XOR two values, `x ^ y`.
@@ -56,50 +53,10 @@ export var createBitXor = /* #__PURE__ */factory(name, dependencies, _ref => {
 
   return typed(name, {
     'number, number': bitXorNumber,
-    'BigNumber, BigNumber': bigBitXor,
-    'SparseMatrix, SparseMatrix': function SparseMatrixSparseMatrix(x, y) {
-      return algorithm07(x, y, this);
-    },
-    'SparseMatrix, DenseMatrix': function SparseMatrixDenseMatrix(x, y) {
-      return algorithm03(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 algorithm12(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();
-    }
-  });
+    'BigNumber, BigNumber': bigBitXor
+  }, matrixAlgorithmSuite({
+    SS: matAlgo07xSSf,
+    DS: matAlgo03xDSf,
+    Ss: matAlgo12xSfs
+  }));
 });