mathjs 10.6.2 → 11.0.0

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

@@ -1,9 +1,9 @@
-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 { createMatAlgo14xDs } from '../../type/matrix/utils/matAlgo14xDs.js';
+import { createMatAlgo06xS0S0 } from '../../type/matrix/utils/matAlgo06xS0S0.js';
 import { factory } from '../../utils/factory.js';
+import { createMatrixAlgorithmSuite } from '../../type/matrix/utils/matrixAlgorithmSuite.js';
 import { andNumber } from '../../plain/number/index.js';
 var name = 'and';
 var dependencies = ['typed', 'matrix', 'equalScalar', 'zeros', 'not'];
@@ -15,23 +15,24 @@ export var createAnd = /* #__PURE__ */factory(name, dependencies, _ref => {
     zeros,
     not
   } = _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({
+  var matAlgo14xDs = createMatAlgo14xDs({
     typed
   });
-  var algorithm14 = createAlgorithm14({
-    typed
+  var matrixAlgorithmSuite = createMatrixAlgorithmSuite({
+    typed,
+    matrix
   });
   /**
    * Logical `and`. Test whether two values are both defined with a nonzero/nonempty value.
@@ -70,76 +71,53 @@ export var createAnd = /* #__PURE__ */factory(name, dependencies, _ref => {
     'BigNumber, BigNumber': function BigNumberBigNumber(x, y) {
       return !x.isZero() && !y.isZero() && !x.isNaN() && !y.isNaN();
     },
-    'Unit, Unit': function UnitUnit(x, y) {
-      return this(x.value || 0, y.value || 0);
-    },
-    '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) {
+    'Unit, Unit': typed.referToSelf(self => (x, y) => self(x.value || 0, y.value || 0)),
+    'SparseMatrix, any': typed.referToSelf(self => (x, y) => {
       // check scalar
       if (not(y)) {
         // return zero matrix
         return zeros(x.size(), x.storage());
       }
 
-      return algorithm11(x, y, this, false);
-    },
-    'DenseMatrix, any': function DenseMatrixAny(x, y) {
+      return matAlgo11xS0s(x, y, self, false);
+    }),
+    'DenseMatrix, any': typed.referToSelf(self => (x, y) => {
       // check scalar
       if (not(y)) {
         // return zero matrix
         return zeros(x.size(), x.storage());
       }
 
-      return algorithm14(x, y, this, false);
-    },
-    'any, SparseMatrix': function anySparseMatrix(x, y) {
+      return matAlgo14xDs(x, y, self, false);
+    }),
+    'any, SparseMatrix': typed.referToSelf(self => (x, y) => {
       // check scalar
       if (not(x)) {
         // return zero matrix
         return zeros(x.size(), x.storage());
       }
 
-      return algorithm11(y, x, this, true);
-    },
-    'any, DenseMatrix': function anyDenseMatrix(x, y) {
+      return matAlgo11xS0s(y, x, self, true);
+    }),
+    'any, DenseMatrix': typed.referToSelf(self => (x, y) => {
       // check scalar
       if (not(x)) {
         // return zero matrix
         return zeros(x.size(), x.storage());
       }
 
-      return algorithm14(y, x, this, true);
-    },
-    'Array, any': function ArrayAny(x, y) {
+      return matAlgo14xDs(y, x, self, true);
+    }),
+    'Array, any': typed.referToSelf(self => (x, y) => {
       // use matrix implementation
-      return this(matrix(x), y).valueOf();
-    },
-    'any, Array': function anyArray(x, y) {
+      return self(matrix(x), y).valueOf();
+    }),
+    'any, Array': typed.referToSelf(self => (x, y) => {
       // use matrix implementation
-      return this(x, matrix(y)).valueOf();
-    }
-  });
+      return self(x, matrix(y)).valueOf();
+    })
+  }, matrixAlgorithmSuite({
+    SS: matAlgo06xS0S0,
+    DS: matAlgo02xDS0
+  }));
 });

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

@@ -34,6 +34,7 @@ export var createNot = /* #__PURE__ */factory(name, dependencies, _ref => {
    *            Returns true when input is a zero or empty value.
    */
   return typed(name, {
+    'null | undefined': () => true,
     number: notNumber,
     Complex: function Complex(x) {
       return x.re === 0 && x.im === 0;
@@ -41,11 +42,7 @@ export var createNot = /* #__PURE__ */factory(name, dependencies, _ref => {
     BigNumber: function BigNumber(x) {
       return x.isZero() || x.isNaN();
     },
-    Unit: function Unit(x) {
-      return x.value !== null ? this(x.value) : true;
-    },
-    'Array | Matrix': function ArrayMatrix(x) {
-      return deepMap(x, this);
-    }
+    Unit: typed.referToSelf(self => x => typed.find(self, x.valueType())(x.value)),
+    'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self))
   });
 });

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

@@ -1,9 +1,8 @@
-import { createAlgorithm03 } from '../../type/matrix/utils/algorithm03.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 { createAlgorithm05 } from '../../type/matrix/utils/algorithm05.js';
+import { createMatAlgo03xDSf } from '../../type/matrix/utils/matAlgo03xDSf.js';
+import { createMatAlgo12xSfs } from '../../type/matrix/utils/matAlgo12xSfs.js';
+import { createMatAlgo05xSfSf } from '../../type/matrix/utils/matAlgo05xSfSf.js';
 import { factory } from '../../utils/factory.js';
+import { createMatrixAlgorithmSuite } from '../../type/matrix/utils/matrixAlgorithmSuite.js';
 import { orNumber } from '../../plain/number/index.js';
 var name = 'or';
 var dependencies = ['typed', 'matrix', 'equalScalar', 'DenseMatrix'];
@@ -14,22 +13,20 @@ export var createOr = /* #__PURE__ */factory(name, dependencies, _ref => {
     equalScalar,
     DenseMatrix
   } = _ref;
-  var algorithm03 = createAlgorithm03({
+  var matAlgo03xDSf = createMatAlgo03xDSf({
     typed
   });
-  var algorithm05 = createAlgorithm05({
+  var matAlgo05xSfSf = createMatAlgo05xSfSf({
     typed,
     equalScalar
   });
-  var algorithm12 = createAlgorithm12({
+  var matAlgo12xSfs = createMatAlgo12xSfs({
     typed,
     DenseMatrix
   });
-  var algorithm13 = createAlgorithm13({
-    typed
-  });
-  var algorithm14 = createAlgorithm14({
-    typed
+  var matrixAlgorithmSuite = createMatrixAlgorithmSuite({
+    typed,
+    matrix
   });
   /**
    * Logical `or`. Test if at least one value is defined with a nonzero/nonempty value.
@@ -68,52 +65,10 @@ export var createOr = /* #__PURE__ */factory(name, dependencies, _ref => {
     'BigNumber, BigNumber': function BigNumberBigNumber(x, y) {
       return !x.isZero() && !x.isNaN() || !y.isZero() && !y.isNaN();
     },
-    'Unit, Unit': function UnitUnit(x, y) {
-      return this(x.value || 0, y.value || 0);
-    },
-    'SparseMatrix, SparseMatrix': function SparseMatrixSparseMatrix(x, y) {
-      return algorithm05(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();
-    }
-  });
+    'Unit, Unit': typed.referToSelf(self => (x, y) => self(x.value || 0, y.value || 0))
+  }, matrixAlgorithmSuite({
+    SS: matAlgo05xSfSf,
+    DS: matAlgo03xDSf,
+    Ss: matAlgo12xSfs
+  }));
 });

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

@@ -1,9 +1,8 @@
-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 { xorNumber } from '../../plain/number/index.js';
 var name = 'xor';
 var dependencies = ['typed', 'matrix', 'DenseMatrix'];
@@ -13,22 +12,20 @@ export var createXor = /* #__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
   });
   /**
    * Logical `xor`. Test whether one and only one value is defined with a nonzero/nonempty value.
@@ -67,52 +64,10 @@ export var createXor = /* #__PURE__ */factory(name, dependencies, _ref => {
     'BigNumber, BigNumber': function BigNumberBigNumber(x, y) {
       return (!x.isZero() && !x.isNaN()) !== (!y.isZero() && !y.isNaN());
     },
-    'Unit, Unit': function UnitUnit(x, y) {
-      return this(x.value || 0, y.value || 0);
-    },
-    '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();
-    }
-  });
+    'Unit, Unit': typed.referToSelf(self => (x, y) => self(x.value || 0, y.value || 0))
+  }, matrixAlgorithmSuite({
+    SS: matAlgo07xSSf,
+    DS: matAlgo03xDSf,
+    Ss: matAlgo12xSfs
+  }));
 });

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

@@ -75,9 +75,8 @@ export var createDiff = /* #__PURE__ */factory(name, dependencies, _ref => {
         return _recursive(arr, dim);
       }
     },
-    'Array | Matrix, BigNumber': function ArrayMatrixBigNumber(arr, dim) {
-      return this(arr, number(dim));
-    }
+    'Array, BigNumber': typed.referTo('Array,number', selfAn => (arr, dim) => selfAn(arr, number(dim))),
+    'Matrix, BigNumber': typed.referTo('Matrix,number', selfMn => (arr, dim) => selfMn(arr, number(dim)))
   });
   /**
    * Recursively find the correct dimension in the array/matrix
@@ -121,10 +120,6 @@ export var createDiff = /* #__PURE__ */factory(name, dependencies, _ref => {
     var result = [];
     var size = arr.length;
 
-    if (size < 2) {
-      return arr;
-    }
-
     for (var i = 1; i < size; i++) {
       result.push(_ElementDiff(arr[i - 1], arr[i]));
     }

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

@@ -29,6 +29,7 @@ export var createOnes = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    * Examples:
    *
+   *    math.ones()                    // returns []
    *    math.ones(3)                   // returns [1, 1, 1]
    *    math.ones(3, 2)                // returns [[1, 1], [1, 1], [1, 1]]
    *    math.ones(3, 2, 'dense')       // returns Dense Matrix [[1, 1], [1, 1], [1, 1]]
@@ -40,7 +41,7 @@ export var createOnes = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    *    zeros, identity, size, range
    *
-   * @param {...number | Array} size    The size of each dimension of the matrix
+   * @param {...(number|BigNumber) | Array} size    The size of each dimension of the matrix
    * @param {string} [format]           The Matrix storage format
    *
    * @return {Array | Matrix | number}  A matrix filled with ones

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

@@ -3,13 +3,14 @@ import { format } from '../../utils/string.js';
 import { arraySize } from '../../utils/array.js';
 import { factory } from '../../utils/factory.js';
 var name = 'sqrtm';
-var dependencies = ['typed', 'abs', 'add', 'multiply', 'sqrt', 'subtract', 'inv', 'size', 'max', 'identity'];
+var dependencies = ['typed', 'abs', 'add', 'multiply', 'map', 'sqrt', 'subtract', 'inv', 'size', 'max', 'identity'];
 export var createSqrtm = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     abs,
     add,
     multiply,
+    map,
     sqrt,
     subtract,
     inv,
@@ -79,7 +80,7 @@ export var createSqrtm = /* #__PURE__ */factory(name, dependencies, _ref => {
         case 1:
           // Single element Array | Matrix
           if (size[0] === 1) {
-            return sqrt(A);
+            return map(A, sqrt);
           } else {
             throw new RangeError('Matrix must be square ' + '(size: ' + format(size) + ')');
           }

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

@@ -31,59 +31,56 @@ export var createTranspose = /* #__PURE__ */factory(name, dependencies, _ref =>
    * @param {Array | Matrix} x  Matrix to be transposed
    * @return {Array | Matrix}   The transposed matrix
    */
-  return typed('transpose', {
-    Array: function Array(x) {
-      // use dense matrix implementation
-      return this(matrix(x)).valueOf();
-    },
-    Matrix: function Matrix(x) {
-      // matrix size
-      var size = x.size(); // result
-
-      var c; // process dimensions
-
-      switch (size.length) {
-        case 1:
-          // vector
-          c = x.clone();
-          break;
-
-        case 2:
-          {
-            // rows and columns
-            var rows = size[0];
-            var columns = size[1]; // check columns
-
-            if (columns === 0) {
-              // throw exception
-              throw new RangeError('Cannot transpose a 2D matrix with no columns (size: ' + format(size) + ')');
-            } // process storage format
-
-
-            switch (x.storage()) {
-              case 'dense':
-                c = _denseTranspose(x, rows, columns);
-                break;
-
-              case 'sparse':
-                c = _sparseTranspose(x, rows, columns);
-                break;
-            }
-          }
-          break;
+  return typed(name, {
+    Array: x => transposeMatrix(matrix(x)).valueOf(),
+    Matrix: transposeMatrix,
+    any: clone // scalars
 
-        default:
-          // multi dimensional
-          throw new RangeError('Matrix must be a vector or two dimensional (size: ' + format(this._size) + ')');
-      }
+  });
+
+  function transposeMatrix(x) {
+    // matrix size
+    var size = x.size(); // result
+
+    var c; // process dimensions
+
+    switch (size.length) {
+      case 1:
+        // vector
+        c = x.clone();
+        break;
+
+      case 2:
+        {
+          // rows and columns
+          var rows = size[0];
+          var columns = size[1]; // check columns
+
+          if (columns === 0) {
+            // throw exception
+            throw new RangeError('Cannot transpose a 2D matrix with no columns (size: ' + format(size) + ')');
+          } // process storage format
 
-      return c;
-    },
-    // scalars
-    any: function any(x) {
-      return clone(x);
+
+          switch (x.storage()) {
+            case 'dense':
+              c = _denseTranspose(x, rows, columns);
+              break;
+
+            case 'sparse':
+              c = _sparseTranspose(x, rows, columns);
+              break;
+          }
+        }
+        break;
+
+      default:
+        // multi dimensional
+        throw new RangeError('Matrix must be a vector or two dimensional (size: ' + format(size) + ')');
     }
-  });
+
+    return c;
+  }
 
   function _denseTranspose(m, rows, columns) {
     // matrix array

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

@@ -27,6 +27,7 @@ export var createZeros = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    * Examples:
    *
+   *    math.zeros()                   // returns []
    *    math.zeros(3)                  // returns [0, 0, 0]
    *    math.zeros(3, 2)               // returns [[0, 0], [0, 0], [0, 0]]
    *    math.zeros(3, 'dense')         // returns [0, 0, 0]
@@ -38,7 +39,7 @@ export var createZeros = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    *    ones, identity, size, range
    *
-   * @param {...number | Array} size    The size of each dimension of the matrix
+   * @param {...(number|BigNumber) | Array} size    The size of each dimension of the matrix
    * @param {string} [format]           The Matrix storage format
    *
    * @return {Array | Matrix}           A matrix filled with zeros

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

@@ -45,8 +45,6 @@ export var createFactorial = /* #__PURE__ */factory(name, dependencies, _ref =>
 
       return gamma(n.plus(1));
     },
-    'Array | Matrix': function ArrayMatrix(n) {
-      return deepMap(n, this);
-    }
+    'Array | Matrix': typed.referToSelf(self => n => deepMap(n, self))
   });
 });