mathjs 9.2.0 → 9.4.0

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

@@ -1,9 +1,12 @@
-import { clone } from '../../utils/object.js';
 import { factory } from '../../utils/factory.js';
 import { format } from '../../utils/string.js';
-var name = 'eigs';
-var dependencies = ['config', 'typed', 'matrix', 'addScalar', 'equal', 'subtract', 'abs', 'atan', 'cos', 'sin', 'multiplyScalar', 'inv', 'bignumber', 'multiply', 'add'];
-export var createEigs = /* #__PURE__ */factory(name, dependencies, (_ref) => {
+import { createComplexEigs } from './eigs/complexEigs.js';
+import { createRealSymmetric } from './eigs/realSymetric.js';
+import { typeOf, isNumber, isBigNumber, isComplex, isFraction } from '../../utils/is.js';
+var name = 'eigs'; // The absolute state of math.js's dependency system:
+
+var dependencies = ['config', 'typed', 'matrix', 'addScalar', 'equal', 'subtract', 'abs', 'atan', 'cos', 'sin', 'multiplyScalar', 'divideScalar', 'inv', 'bignumber', 'multiply', 'add', 'larger', 'column', 'flatten', 'number', 'complex', 'sqrt', 'diag', 'qr', 'usolveAll', 'im', 're', 'smaller', 'round', 'log10', 'transpose', 'matrixFromColumns'];
+export var createEigs = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     config,
     typed,
@@ -16,415 +19,264 @@ export var createEigs = /* #__PURE__ */factory(name, dependencies, (_ref) => {
     cos,
     sin,
     multiplyScalar,
+    divideScalar,
     inv,
     bignumber,
     multiply,
-    add
+    add,
+    larger,
+    column,
+    flatten,
+    number,
+    complex,
+    sqrt,
+    diag,
+    qr,
+    usolveAll,
+    im,
+    re,
+    smaller,
+    round,
+    log10,
+    transpose,
+    matrixFromColumns
   } = _ref;
-
+  var doRealSymetric = createRealSymmetric({
+    config,
+    addScalar,
+    subtract,
+    column,
+    flatten,
+    equal,
+    abs,
+    atan,
+    cos,
+    sin,
+    multiplyScalar,
+    inv,
+    bignumber,
+    complex,
+    multiply,
+    add
+  });
+  var doComplexEigs = createComplexEigs({
+    config,
+    addScalar,
+    subtract,
+    multiply,
+    multiplyScalar,
+    flatten,
+    divideScalar,
+    sqrt,
+    abs,
+    bignumber,
+    diag,
+    qr,
+    inv,
+    usolveAll,
+    equal,
+    complex,
+    larger,
+    smaller,
+    round,
+    log10,
+    transpose,
+    matrixFromColumns
+  });
   /**
-   * Compute eigenvalue and eigenvector of a real symmetric matrix.
-   * Only applicable to two dimensional symmetric matrices. Uses Jacobi
-   * Algorithm. Matrix containing mixed type ('number', 'bignumber', 'fraction')
-   * of elements are not supported. Input matrix or 2D array should contain all elements
-   * of either 'number', 'bignumber' or 'fraction' type. For 'number' and 'fraction', the
-   * eigenvalues are of 'number' type. For 'bignumber' the eigenvalues are of ''bignumber' type.
-   * Eigenvectors are always of 'number' type.
+   * Compute eigenvalues and eigenvectors of a matrix. The eigenvalues are sorted by their absolute value, ascending.
+   * An eigenvalue with multiplicity k will be listed k times. The eigenvectors are returned as columns of a matrix –
+   * the eigenvector that belongs to the j-th eigenvalue in the list (eg. `values[j]`) is the j-th column (eg. `column(vectors, j)`).
+   * If the algorithm fails to converge, it will throw an error – in that case, however, you may still find useful information
+   * in `err.values` and `err.vectors`.
    *
    * Syntax:
    *
-   *     math.eigs(x)
+   *     math.eigs(x, [prec])
    *
    * Examples:
    *
+   *     const { eigs, multiply, column, transpose } = math
    *     const H = [[5, 2.3], [2.3, 1]]
-   *     const ans = math.eigs(H) // returns {values: [E1,E2...sorted], vectors: [v1,v2.... corresponding vectors as columns]}
+   *     const ans = eigs(H) // returns {values: [E1,E2...sorted], vectors: [v1,v2.... corresponding vectors as columns]}
    *     const E = ans.values
    *     const U = ans.vectors
-   *     math.multiply(H, math.column(U, 0)) // returns math.multiply(E[0], math.column(U, 0))
-   *     const UTxHxU = math.multiply(math.transpose(U), H, U) // rotates H to the eigen-representation
+   *     multiply(H, column(U, 0)) // returns multiply(E[0], column(U, 0))
+   *     const UTxHxU = multiply(transpose(U), H, U) // diagonalizes H
    *     E[0] == UTxHxU[0][0]  // returns true
+   *
    * See also:
    *
    *     inv
    *
    * @param {Array | Matrix} x  Matrix to be diagonalized
-   * @return {{values: Array, vectors: Array} | {values: Matrix, vectors: Matrix}} Object containing eigenvalues (Array or Matrix) and eigenvectors (2D Array/Matrix with eigenvectors as columns).
+   *
+   * @param {number | BigNumber} [prec] Precision, default value: 1e-15
+   * @return {{values: Array|Matrix, vectors: Array|Matrix}} Object containing an array of eigenvalues and a matrix with eigenvectors as columns.
+   *
    */
+
   return typed('eigs', {
     Array: function Array(x) {
-      // check array size
       var mat = matrix(x);
-      var size = mat.size();
-
-      if (size.length !== 2 || size[0] !== size[1]) {
-        throw new RangeError('Matrix must be square ' + '(size: ' + format(size) + ')');
-      } // use dense 2D matrix implementation
-
-
-      var ans = checkAndSubmit(mat, size[0]);
+      return computeValuesAndVectors(mat);
+    },
+    'Array, number|BigNumber': function ArrayNumberBigNumber(x, prec) {
+      var mat = matrix(x);
+      return computeValuesAndVectors(mat, prec);
+    },
+    Matrix: function Matrix(mat) {
+      var {
+        values,
+        vectors
+      } = computeValuesAndVectors(mat);
       return {
-        values: ans[0],
-        vectors: ans[1]
+        values: matrix(values),
+        vectors: matrix(vectors)
       };
     },
-    Matrix: function Matrix(x) {
-      // use dense 2D array implementation
-      // dense matrix
-      var size = x.size();
-
-      if (size.length !== 2 || size[0] !== size[1]) {
-        throw new RangeError('Matrix must be square ' + '(size: ' + format(size) + ')');
-      }
-
-      var ans = checkAndSubmit(x, size[0]);
+    'Matrix, number|BigNumber': function MatrixNumberBigNumber(mat, prec) {
+      var {
+        values,
+        vectors
+      } = computeValuesAndVectors(mat, prec);
       return {
-        values: matrix(ans[0]),
-        vectors: matrix(ans[1])
+        values: matrix(values),
+        vectors: matrix(vectors)
       };
     }
-  }); // Is the matrix
-  // symmetric ?
+  });
 
-  function isSymmetric(x, n) {
-    for (var i = 0; i < n; i++) {
-      for (var j = i; j < n; j++) {
-        // not symmtric
-        if (!equal(x[i][j], x[j][i])) {
-          throw new TypeError('Input matrix is not symmetric');
-        }
-      }
+  function computeValuesAndVectors(mat, prec) {
+    if (prec === undefined) {
+      prec = config.epsilon;
     }
-  } // check input for possible problems
-  // and perform diagonalization efficiently for
-  // specific type of number
 
+    var size = mat.size();
 
-  function checkAndSubmit(x, n) {
-    var type = x.datatype(); // type check
-
-    if (type === undefined) {
-      type = x.getDataType();
+    if (size.length !== 2 || size[0] !== size[1]) {
+      throw new RangeError('Matrix must be square (size: ' + format(size) + ')');
     }
 
-    if (type !== 'number' && type !== 'BigNumber' && type !== 'Fraction') {
-      if (type === 'mixed') {
-        throw new TypeError('Mixed matrix element type is not supported');
-      } else {
-        throw new TypeError('Matrix element type not supported (' + type + ')');
-      }
-    } else {
-      isSymmetric(x.toArray(), n);
-    } // perform efficient calculation for 'numbers'
+    var arr = mat.toArray();
+    var N = size[0];
 
+    if (isReal(arr, N, prec)) {
+      coerceReal(arr, N);
 
-    if (type === 'number') {
-      return diag(x.toArray());
-    } else if (type === 'Fraction') {
-      var xArr = x.toArray(); // convert fraction to numbers
+      if (isSymmetric(arr, N, prec)) {
+        var _type = coerceTypes(mat, arr, N);
 
-      for (var i = 0; i < n; i++) {
-        for (var j = i; j < n; j++) {
-          xArr[i][j] = xArr[i][j].valueOf();
-          xArr[j][i] = xArr[i][j];
-        }
+        return doRealSymetric(arr, N, prec, _type);
       }
-
-      return diag(x.toArray());
-    } else if (type === 'BigNumber') {
-      return diagBig(x.toArray());
     }
-  } // diagonalization implementation for number (efficient)
 
+    var type = coerceTypes(mat, arr, N);
+    return doComplexEigs(arr, N, prec, type);
+  }
+  /** @return {boolean} */
 
-  function diag(x) {
-    var N = x.length;
-    var e0 = Math.abs(config.epsilon / N);
-    var psi;
-    var Sij = new Array(N); // Sij is Identity Matrix
 
+  function isSymmetric(arr, N, prec) {
     for (var i = 0; i < N; i++) {
-      Sij[i] = createArray(N, 0);
-      Sij[i][i] = 1.0;
-    } // initial error
-
-
-    var Vab = getAij(x);
-
-    while (Math.abs(Vab[1]) >= Math.abs(e0)) {
-      var _i = Vab[0][0];
-      var j = Vab[0][1];
-      psi = getTheta(x[_i][_i], x[j][j], x[_i][j]);
-      x = x1(x, psi, _i, j);
-      Sij = Sij1(Sij, psi, _i, j);
-      Vab = getAij(x);
-    }
-
-    var Ei = createArray(N, 0); // eigenvalues
-
-    for (var _i2 = 0; _i2 < N; _i2++) {
-      Ei[_i2] = x[_i2][_i2];
+      for (var j = i; j < N; j++) {
+        // TODO proper comparison of bignum and frac
+        if (larger(bignumber(abs(subtract(arr[i][j], arr[j][i]))), prec)) {
+          return false;
+        }
+      }
     }
 
-    return sorting(clone(Ei), clone(Sij));
-  } // diagonalization implementation for bigNumber
-
+    return true;
+  }
+  /** @return {boolean} */
 
-  function diagBig(x) {
-    var N = x.length;
-    var e0 = abs(config.epsilon / N);
-    var psi;
-    var Sij = new Array(N); // Sij is Identity Matrix
 
+  function isReal(arr, N, prec) {
     for (var i = 0; i < N; i++) {
-      Sij[i] = createArray(N, 0);
-      Sij[i][i] = 1.0;
-    } // initial error
-
-
-    var Vab = getAijBig(x);
-
-    while (abs(Vab[1]) >= abs(e0)) {
-      var _i3 = Vab[0][0];
-      var j = Vab[0][1];
-      psi = getThetaBig(x[_i3][_i3], x[j][j], x[_i3][j]);
-      x = x1Big(x, psi, _i3, j);
-      Sij = Sij1Big(Sij, psi, _i3, j);
-      Vab = getAijBig(x);
-    }
-
-    var Ei = createArray(N, 0); // eigenvalues
-
-    for (var _i4 = 0; _i4 < N; _i4++) {
-      Ei[_i4] = x[_i4][_i4];
-    } // return [clone(Ei), clone(Sij)]
-
-
-    return sorting(clone(Ei), clone(Sij));
-  } // get angle
-
-
-  function getTheta(aii, ajj, aij) {
-    var denom = ajj - aii;
-
-    if (Math.abs(denom) <= config.epsilon) {
-      return Math.PI / 4;
-    } else {
-      return 0.5 * Math.atan(2 * aij / (ajj - aii));
-    }
-  } // get angle
-
-
-  function getThetaBig(aii, ajj, aij) {
-    var denom = subtract(ajj, aii);
-
-    if (abs(denom) <= config.epsilon) {
-      return bignumber(-1).acos().div(4);
-    } else {
-      return multiplyScalar(0.5, atan(multiply(2, aij, inv(denom))));
-    }
-  } // update eigvec
-
-
-  function Sij1(Sij, theta, i, j) {
-    var N = Sij.length;
-    var c = Math.cos(theta);
-    var s = Math.sin(theta);
-    var Ski = createArray(N, 0);
-    var Skj = createArray(N, 0);
-
-    for (var k = 0; k < N; k++) {
-      Ski[k] = c * Sij[k][i] - s * Sij[k][j];
-      Skj[k] = s * Sij[k][i] + c * Sij[k][j];
-    }
-
-    for (var _k = 0; _k < N; _k++) {
-      Sij[_k][i] = Ski[_k];
-      Sij[_k][j] = Skj[_k];
-    }
-
-    return Sij;
-  } // update eigvec for overlap
-
-
-  function Sij1Big(Sij, theta, i, j) {
-    var N = Sij.length;
-    var c = cos(theta);
-    var s = sin(theta);
-    var Ski = createArray(N, bignumber(0));
-    var Skj = createArray(N, bignumber(0));
-
-    for (var k = 0; k < N; k++) {
-      Ski[k] = subtract(multiplyScalar(c, Sij[k][i]), multiplyScalar(s, Sij[k][j]));
-      Skj[k] = addScalar(multiplyScalar(s, Sij[k][i]), multiplyScalar(c, Sij[k][j]));
-    }
-
-    for (var _k2 = 0; _k2 < N; _k2++) {
-      Sij[_k2][i] = Ski[_k2];
-      Sij[_k2][j] = Skj[_k2];
+      for (var j = 0; j < N; j++) {
+        // TODO proper comparison of bignum and frac
+        if (larger(bignumber(abs(im(arr[i][j]))), prec)) {
+          return false;
+        }
+      }
     }
 
-    return Sij;
-  } // update matrix
-
-
-  function x1Big(Hij, theta, i, j) {
-    var N = Hij.length;
-    var c = bignumber(cos(theta));
-    var s = bignumber(sin(theta));
-    var c2 = multiplyScalar(c, c);
-    var s2 = multiplyScalar(s, s);
-    var Aki = createArray(N, bignumber(0));
-    var Akj = createArray(N, bignumber(0)); // 2cs Hij
-
-    var csHij = multiply(bignumber(2), c, s, Hij[i][j]); //  Aii
-
-    var Aii = addScalar(subtract(multiplyScalar(c2, Hij[i][i]), csHij), multiplyScalar(s2, Hij[j][j]));
-    var Ajj = add(multiplyScalar(s2, Hij[i][i]), csHij, multiplyScalar(c2, Hij[j][j])); // 0  to i
-
-    for (var k = 0; k < N; k++) {
-      Aki[k] = subtract(multiplyScalar(c, Hij[i][k]), multiplyScalar(s, Hij[j][k]));
-      Akj[k] = addScalar(multiplyScalar(s, Hij[i][k]), multiplyScalar(c, Hij[j][k]));
-    } // Modify Hij
-
-
-    Hij[i][i] = Aii;
-    Hij[j][j] = Ajj;
-    Hij[i][j] = bignumber(0);
-    Hij[j][i] = bignumber(0); // 0  to i
+    return true;
+  }
 
-    for (var _k3 = 0; _k3 < N; _k3++) {
-      if (_k3 !== i && _k3 !== j) {
-        Hij[i][_k3] = Aki[_k3];
-        Hij[_k3][i] = Aki[_k3];
-        Hij[j][_k3] = Akj[_k3];
-        Hij[_k3][j] = Akj[_k3];
+  function coerceReal(arr, N) {
+    for (var i = 0; i < N; i++) {
+      for (var j = 0; j < N; j++) {
+        arr[i][j] = re(arr[i][j]);
       }
     }
-
-    return Hij;
-  } // update matrix
-
-
-  function x1(Hij, theta, i, j) {
-    var N = Hij.length;
-    var c = Math.cos(theta);
-    var s = Math.sin(theta);
-    var c2 = c * c;
-    var s2 = s * s;
-    var Aki = createArray(N, 0);
-    var Akj = createArray(N, 0); //  Aii
-
-    var Aii = c2 * Hij[i][i] - 2 * c * s * Hij[i][j] + s2 * Hij[j][j];
-    var Ajj = s2 * Hij[i][i] + 2 * c * s * Hij[i][j] + c2 * Hij[j][j]; // 0  to i
-
-    for (var k = 0; k < N; k++) {
-      Aki[k] = c * Hij[i][k] - s * Hij[j][k];
-      Akj[k] = s * Hij[i][k] + c * Hij[j][k];
-    } // Modify Hij
+  }
+  /** @return {'number' | 'BigNumber' | 'Complex'} */
 
 
-    Hij[i][i] = Aii;
-    Hij[j][j] = Ajj;
-    Hij[i][j] = 0;
-    Hij[j][i] = 0; // 0  to i
+  function coerceTypes(mat, arr, N) {
+    /** @type {string} */
+    var type = mat.datatype();
 
-    for (var _k4 = 0; _k4 < N; _k4++) {
-      if (_k4 !== i && _k4 !== j) {
-        Hij[i][_k4] = Aki[_k4];
-        Hij[_k4][i] = Aki[_k4];
-        Hij[j][_k4] = Akj[_k4];
-        Hij[_k4][j] = Akj[_k4];
-      }
+    if (type === 'number' || type === 'BigNumber' || type === 'Complex') {
+      return type;
     }
 
-    return Hij;
-  } // get max off-diagonal value from Upper Diagonal
-
-
-  function getAij(Mij) {
-    var N = Mij.length;
-    var maxMij = 0;
-    var maxIJ = [0, 1];
+    var hasNumber = false;
+    var hasBig = false;
+    var hasComplex = false;
 
     for (var i = 0; i < N; i++) {
-      for (var j = i + 1; j < N; j++) {
-        if (Math.abs(maxMij) < Math.abs(Mij[i][j])) {
-          maxMij = Math.abs(Mij[i][j]);
-          maxIJ = [i, j];
+      for (var j = 0; j < N; j++) {
+        var el = arr[i][j];
+
+        if (isNumber(el) || isFraction(el)) {
+          hasNumber = true;
+        } else if (isBigNumber(el)) {
+          hasBig = true;
+        } else if (isComplex(el)) {
+          hasComplex = true;
+        } else {
+          throw TypeError('Unsupported type in Matrix: ' + typeOf(el));
         }
       }
     }
 
-    return [maxIJ, maxMij];
-  } // get max off-diagonal value from Upper Diagonal
-
-
-  function getAijBig(Mij) {
-    var N = Mij.length;
-    var maxMij = 0;
-    var maxIJ = [0, 1];
+    if (hasBig && hasComplex) {
+      console.warn('Complex BigNumbers not supported, this operation will lose precission.');
+    }
 
-    for (var i = 0; i < N; i++) {
-      for (var j = i + 1; j < N; j++) {
-        if (abs(maxMij) < abs(Mij[i][j])) {
-          maxMij = abs(Mij[i][j]);
-          maxIJ = [i, j];
+    if (hasComplex) {
+      for (var _i = 0; _i < N; _i++) {
+        for (var _j = 0; _j < N; _j++) {
+          arr[_i][_j] = complex(arr[_i][_j]);
         }
       }
-    }
-
-    return [maxIJ, maxMij];
-  } // sort results
 
-
-  function sorting(E, S) {
-    var N = E.length;
-    var Ef = Array(N);
-    var Sf = Array(N);
-
-    for (var k = 0; k < N; k++) {
-      Sf[k] = Array(N);
+      return 'Complex';
     }
 
-    for (var i = 0; i < N; i++) {
-      var minID = 0;
-      var minE = E[0];
-
-      for (var j = 0; j < E.length; j++) {
-        if (E[j] < minE) {
-          minID = j;
-          minE = E[minID];
+    if (hasBig) {
+      for (var _i2 = 0; _i2 < N; _i2++) {
+        for (var _j2 = 0; _j2 < N; _j2++) {
+          arr[_i2][_j2] = bignumber(arr[_i2][_j2]);
         }
       }
 
-      Ef[i] = E.splice(minID, 1)[0];
-
-      for (var _k5 = 0; _k5 < N; _k5++) {
-        Sf[_k5][i] = S[_k5][minID];
-
-        S[_k5].splice(minID, 1);
-      }
+      return 'BigNumber';
     }
 
-    return [clone(Ef), clone(Sf)];
-  }
-  /**
-   * Create an array of a certain size and fill all items with an initial value
-   * @param {number} size
-   * @param {number} value
-   * @return {number[]}
-   */
-
-
-  function createArray(size, value) {
-    // TODO: as soon as all browsers support Array.fill, use that instead (IE doesn't support it)
-    var array = new Array(size);
+    if (hasNumber) {
+      for (var _i3 = 0; _i3 < N; _i3++) {
+        for (var _j3 = 0; _j3 < N; _j3++) {
+          arr[_i3][_j3] = number(arr[_i3][_j3]);
+        }
+      }
 
-    for (var i = 0; i < size; i++) {
-      array[i] = value;
+      return 'number';
+    } else {
+      throw TypeError('Matrix contains unsupported types only.');
     }
-
-    return array;
   }
 });

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

@@ -3,7 +3,7 @@ import { format } from '../../utils/string.js';
 import { factory } from '../../utils/factory.js';
 var name = 'expm';
 var dependencies = ['typed', 'abs', 'add', 'identity', 'inv', 'multiply'];
-export var createExpm = /* #__PURE__ */factory(name, dependencies, (_ref) => {
+export var createExpm = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     abs,

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

@@ -3,7 +3,7 @@ import { maxArgumentCount } from '../../utils/function.js';
 import { factory } from '../../utils/factory.js';
 var name = 'filter';
 var dependencies = ['typed'];
-export var createFilter = /* #__PURE__ */factory(name, dependencies, (_ref) => {
+export var createFilter = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed
   } = _ref;

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

@@ -3,7 +3,7 @@ import { flatten as flattenArray } from '../../utils/array.js';
 import { factory } from '../../utils/factory.js';
 var name = 'flatten';
 var dependencies = ['typed', 'matrix'];
-export var createFlatten = /* #__PURE__ */factory(name, dependencies, (_ref) => {
+export var createFlatten = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     matrix
@@ -11,6 +11,7 @@ export var createFlatten = /* #__PURE__ */factory(name, dependencies, (_ref) =>
 
   /**
    * Flatten a multi dimensional matrix into a single dimensional matrix.
+   * It is guaranteed to always return a clone of the argument.
    *
    * Syntax:
    *

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

@@ -3,7 +3,7 @@ import { forEach as forEachArray } from '../../utils/array.js';
 import { factory } from '../../utils/factory.js';
 var name = 'forEach';
 var dependencies = ['typed'];
-export var createForEach = /* #__PURE__ */factory(name, dependencies, (_ref) => {
+export var createForEach = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed
   } = _ref;

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

@@ -3,7 +3,7 @@ import { getArrayDataType } from '../../utils/array.js';
 import { typeOf } from '../../utils/is.js';
 var name = 'getMatrixDataType';
 var dependencies = ['typed'];
-export var createGetMatrixDataType = /* #__PURE__ */factory(name, dependencies, (_ref) => {
+export var createGetMatrixDataType = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed
   } = _ref;

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

@@ -4,7 +4,7 @@ import { isInteger } from '../../utils/number.js';
 import { factory } from '../../utils/factory.js';
 var name = 'identity';
 var dependencies = ['typed', 'config', 'matrix', 'BigNumber', 'DenseMatrix', 'SparseMatrix'];
-export var createIdentity = /* #__PURE__ */factory(name, dependencies, (_ref) => {
+export var createIdentity = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     config,