mathjs 11.2.1 → 11.3.0

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

@@ -14,7 +14,6 @@ export function createRealSymmetric(_ref) {
     multiply,
     add
   } = _ref;
-
   /**
    * @param {number[] | BigNumber[]} arr
    * @param {number} N
@@ -24,33 +23,28 @@ export function createRealSymmetric(_ref) {
   function main(arr, N) {
     var prec = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : config.epsilon;
     var type = arguments.length > 3 ? arguments[3] : undefined;
-
     if (type === 'number') {
       return diag(arr, prec);
     }
-
     if (type === 'BigNumber') {
       return diagBig(arr, prec);
     }
-
     throw TypeError('Unsupported data type: ' + type);
-  } // diagonalization implementation for number (efficient)
-
+  }
 
+  // diagonalization implementation for number (efficient)
   function diag(x, precision) {
     var N = x.length;
     var e0 = Math.abs(precision / N);
     var psi;
-    var Sij = new Array(N); // Sij is Identity Matrix
-
+    var Sij = new Array(N);
+    // Sij is Identity Matrix
     for (var i = 0; i < N; i++) {
       Sij[i] = createArray(N, 0);
       Sij[i][i] = 1.0;
-    } // initial error
-
-
+    }
+    // initial error
     var Vab = getAij(x);
-
     while (Math.abs(Vab[1]) >= Math.abs(e0)) {
       var _i = Vab[0][0];
       var j = Vab[0][1];
@@ -59,31 +53,26 @@ export function createRealSymmetric(_ref) {
       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];
     }
-
     return sorting(clone(Ei), clone(Sij));
-  } // diagonalization implementation for bigNumber
-
+  }
 
+  // diagonalization implementation for bigNumber
   function diagBig(x, precision) {
     var N = x.length;
     var e0 = abs(precision / N);
     var psi;
-    var Sij = new Array(N); // Sij is Identity Matrix
-
+    var Sij = new Array(N);
+    // Sij is Identity Matrix
     for (var i = 0; i < N; i++) {
       Sij[i] = createArray(N, 0);
       Sij[i][i] = 1.0;
-    } // initial error
-
-
+    }
+    // initial error
     var Vab = getAijBig(x);
-
     while (abs(Vab[1]) >= abs(e0)) {
       var _i3 = Vab[0][0];
       var j = Vab[0][1];
@@ -92,82 +81,70 @@ export function createRealSymmetric(_ref) {
       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 [clone(Ei), clone(Sij)]
     return sorting(clone(Ei), clone(Sij));
-  } // get angle
-
+  }
 
+  // get angle
   function getTheta(aii, ajj, aij) {
     var denom = ajj - aii;
-
     if (Math.abs(denom) <= config.epsilon) {
       return Math.PI / 4.0;
     } else {
       return 0.5 * Math.atan(2.0 * aij / (ajj - aii));
     }
-  } // get angle
-
+  }
 
+  // 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.0, aij, inv(denom))));
     }
-  } // update eigvec
-
+  }
 
+  // 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
-
-
+  }
+  // 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];
     }
-
     return Sij;
-  } // update matrix
-
+  }
 
+  // update matrix
   function x1Big(Hij, theta, i, j) {
     var N = Hij.length;
     var c = bignumber(cos(theta));
@@ -175,24 +152,23 @@ export function createRealSymmetric(_ref) {
     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 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
-
+    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
-
-
+    }
+    // Modify Hij
     Hij[i][i] = Aii;
     Hij[j][j] = Ajj;
     Hij[i][j] = bignumber(0);
-    Hij[j][i] = bignumber(0); // 0  to i
-
+    Hij[j][i] = bignumber(0);
+    // 0  to i
     for (var _k3 = 0; _k3 < N; _k3++) {
       if (_k3 !== i && _k3 !== j) {
         Hij[i][_k3] = Aki[_k3];
@@ -201,11 +177,10 @@ export function createRealSymmetric(_ref) {
         Hij[_k3][j] = Akj[_k3];
       }
     }
-
     return Hij;
-  } // update matrix
-
+  }
 
+  // update matrix
   function x1(Hij, theta, i, j) {
     var N = Hij.length;
     var c = Math.cos(theta);
@@ -213,22 +188,21 @@ export function createRealSymmetric(_ref) {
     var c2 = c * c;
     var s2 = s * s;
     var Aki = createArray(N, 0);
-    var Akj = createArray(N, 0); //  Aii
-
+    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
-
+    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
-
-
+    }
+    // Modify Hij
     Hij[i][i] = Aii;
     Hij[j][j] = Ajj;
     Hij[i][j] = 0;
-    Hij[j][i] = 0; // 0  to i
-
+    Hij[j][i] = 0;
+    // 0  to i
     for (var _k4 = 0; _k4 < N; _k4++) {
       if (_k4 !== i && _k4 !== j) {
         Hij[i][_k4] = Aki[_k4];
@@ -237,16 +211,14 @@ export function createRealSymmetric(_ref) {
         Hij[_k4][j] = Akj[_k4];
       }
     }
-
     return Hij;
-  } // get max off-diagonal value from Upper Diagonal
-
+  }
 
+  // get max off-diagonal value from Upper Diagonal
   function getAij(Mij) {
     var N = Mij.length;
     var maxMij = 0;
     var maxIJ = [0, 1];
-
     for (var i = 0; i < N; i++) {
       for (var j = i + 1; j < N; j++) {
         if (Math.abs(maxMij) < Math.abs(Mij[i][j])) {
@@ -255,16 +227,14 @@ export function createRealSymmetric(_ref) {
         }
       }
     }
-
     return [maxIJ, maxMij];
-  } // get max off-diagonal value from Upper Diagonal
-
+  }
 
+  // get max off-diagonal value from Upper Diagonal
   function getAijBig(Mij) {
     var N = Mij.length;
     var maxMij = 0;
     var maxIJ = [0, 1];
-
     for (var i = 0; i < N; i++) {
       for (var j = i + 1; j < N; j++) {
         if (abs(maxMij) < abs(Mij[i][j])) {
@@ -273,63 +243,51 @@ export function createRealSymmetric(_ref) {
         }
       }
     }
-
     return [maxIJ, maxMij];
-  } // sort results
-
+  }
 
+  // sort results
   function sorting(E, S) {
     var N = E.length;
     var values = Array(N);
     var vectors = Array(N);
-
     for (var k = 0; k < N; k++) {
       vectors[k] = Array(N);
     }
-
     for (var i = 0; i < N; i++) {
       var minID = 0;
       var minE = E[0];
-
       for (var j = 0; j < E.length; j++) {
         if (abs(E[j]) < abs(minE)) {
           minID = j;
           minE = E[minID];
         }
       }
-
       values[i] = E.splice(minID, 1)[0];
-
       for (var _k5 = 0; _k5 < N; _k5++) {
         vectors[_k5][i] = S[_k5][minID];
-
         S[_k5].splice(minID, 1);
       }
     }
-
     return {
       values,
       vectors
     };
   }
+
   /**
    * 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);
-
     for (var i = 0; i < size; i++) {
       array[i] = value;
     }
-
     return array;
   }
-
   return main;
 }

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

@@ -3,8 +3,9 @@ import { format } from '../../utils/string.js';
 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 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', 'usolve', 'usolveAll', 'im', 're', 'smaller', 'matrixFromColumns', 'dot'];
 export var createEigs = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
@@ -81,6 +82,7 @@ export var createEigs = /* #__PURE__ */factory(name, dependencies, _ref => {
     matrixFromColumns,
     dot
   });
+
   /**
    * 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 –
@@ -113,7 +115,6 @@ export var createEigs = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @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) {
       var mat = matrix(x);
@@ -144,37 +145,28 @@ export var createEigs = /* #__PURE__ */factory(name, dependencies, _ref => {
       };
     }
   });
-
   function computeValuesAndVectors(mat, prec) {
     if (prec === undefined) {
       prec = config.epsilon;
     }
-
     var size = mat.size();
-
     if (size.length !== 2 || size[0] !== size[1]) {
       throw new RangeError('Matrix must be square (size: ' + format(size) + ')');
     }
-
     var arr = mat.toArray();
     var N = size[0];
-
     if (isReal(arr, N, prec)) {
       coerceReal(arr, N);
-
       if (isSymmetric(arr, N, prec)) {
         var _type = coerceTypes(mat, arr, N);
-
         return doRealSymetric(arr, N, prec, _type);
       }
     }
-
     var type = coerceTypes(mat, arr, N);
     return doComplexEigs(arr, N, prec, type);
   }
-  /** @return {boolean} */
-
 
+  /** @return {boolean} */
   function isSymmetric(arr, N, prec) {
     for (var i = 0; i < N; i++) {
       for (var j = i; j < N; j++) {
@@ -184,12 +176,10 @@ export var createEigs = /* #__PURE__ */factory(name, dependencies, _ref => {
         }
       }
     }
-
     return true;
   }
-  /** @return {boolean} */
-
 
+  /** @return {boolean} */
   function isReal(arr, N, prec) {
     for (var i = 0; i < N; i++) {
       for (var j = 0; j < N; j++) {
@@ -199,10 +189,8 @@ export var createEigs = /* #__PURE__ */factory(name, dependencies, _ref => {
         }
       }
     }
-
     return true;
   }
-
   function coerceReal(arr, N) {
     for (var i = 0; i < N; i++) {
       for (var j = 0; j < N; j++) {
@@ -210,25 +198,20 @@ export var createEigs = /* #__PURE__ */factory(name, dependencies, _ref => {
       }
     }
   }
-  /** @return {'number' | 'BigNumber' | 'Complex'} */
-
 
+  /** @return {'number' | 'BigNumber' | 'Complex'} */
   function coerceTypes(mat, arr, N) {
     /** @type {string} */
     var type = mat.datatype();
-
     if (type === 'number' || type === 'BigNumber' || type === 'Complex') {
       return type;
     }
-
     var hasNumber = false;
     var hasBig = false;
     var hasComplex = false;
-
     for (var i = 0; i < N; i++) {
       for (var j = 0; j < N; j++) {
         var el = arr[i][j];
-
         if (isNumber(el) || isFraction(el)) {
           hasNumber = true;
         } else if (isBigNumber(el)) {
@@ -240,38 +223,31 @@ export var createEigs = /* #__PURE__ */factory(name, dependencies, _ref => {
         }
       }
     }
-
     if (hasBig && hasComplex) {
       console.warn('Complex BigNumbers not supported, this operation will lose precission.');
     }
-
     if (hasComplex) {
       for (var _i = 0; _i < N; _i++) {
         for (var _j = 0; _j < N; _j++) {
           arr[_i][_j] = complex(arr[_i][_j]);
         }
       }
-
       return 'Complex';
     }
-
     if (hasBig) {
       for (var _i2 = 0; _i2 < N; _i2++) {
         for (var _j2 = 0; _j2 < N; _j2++) {
           arr[_i2][_j2] = bignumber(arr[_i2][_j2]);
         }
       }
-
       return 'BigNumber';
     }
-
     if (hasNumber) {
       for (var _i3 = 0; _i3 < N; _i3++) {
         for (var _j3 = 0; _j3 < N; _j3++) {
           arr[_i3][_j3] = number(arr[_i3][_j3]);
         }
       }
-
       return 'number';
     } else {
       throw TypeError('Matrix contains unsupported types only.');

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

@@ -12,7 +12,6 @@ export var createExpm = /* #__PURE__ */factory(name, dependencies, _ref => {
     inv,
     multiply
   } = _ref;
-
   /**
    * Compute the matrix exponential, expm(A) = e^A. The matrix must be square.
    * Not to be confused with exp(a), which performs element-wise
@@ -42,94 +41,89 @@ export var createExpm = /* #__PURE__ */factory(name, dependencies, _ref => {
     Matrix: function Matrix(A) {
       // Check matrix size
       var size = A.size();
-
       if (size.length !== 2 || size[0] !== size[1]) {
         throw new RangeError('Matrix must be square ' + '(size: ' + format(size) + ')');
       }
+      var n = size[0];
 
-      var n = size[0]; // Desired accuracy of the approximant (The actual accuracy
+      // Desired accuracy of the approximant (The actual accuracy
       // will be affected by round-off error)
+      var eps = 1e-15;
 
-      var eps = 1e-15; // The Padé approximant is not so accurate when the values of A
+      // The Padé approximant is not so accurate when the values of A
       // are "large", so scale A by powers of two. Then compute the
       // exponential, and square the result repeatedly according to
       // the identity e^A = (e^(A/m))^m
+
       // Compute infinity-norm of A, ||A||, to see how "big" it is
+      var infNorm = infinityNorm(A);
 
-      var infNorm = infinityNorm(A); // Find the optimal scaling factor and number of terms in the
+      // Find the optimal scaling factor and number of terms in the
       // Padé approximant to reach the desired accuracy
-
       var params = findParams(infNorm, eps);
       var q = params.q;
-      var j = params.j; // The Pade approximation to e^A is:
+      var j = params.j;
+
+      // The Pade approximation to e^A is:
       // Rqq(A) = Dqq(A) ^ -1 * Nqq(A)
       // where
       // Nqq(A) = sum(i=0, q, (2q-i)!p! / [ (2q)!i!(q-i)! ] A^i
       // Dqq(A) = sum(i=0, q, (2q-i)!q! / [ (2q)!i!(q-i)! ] (-A)^i
-      // Scale A by 1 / 2^j
 
-      var Apos = multiply(A, Math.pow(2, -j)); // The i=0 term is just the identity matrix
+      // Scale A by 1 / 2^j
+      var Apos = multiply(A, Math.pow(2, -j));
 
+      // The i=0 term is just the identity matrix
       var N = identity(n);
-      var D = identity(n); // Initialization (i=0)
+      var D = identity(n);
 
-      var factor = 1; // Initialization (i=1)
+      // Initialization (i=0)
+      var factor = 1;
 
+      // Initialization (i=1)
       var AposToI = Apos; // Cloning not necessary
-
       var alternate = -1;
-
       for (var i = 1; i <= q; i++) {
         if (i > 1) {
           AposToI = multiply(AposToI, Apos);
           alternate = -alternate;
         }
-
         factor = factor * (q - i + 1) / ((2 * q - i + 1) * i);
         N = add(N, multiply(factor, AposToI));
         D = add(D, multiply(factor * alternate, AposToI));
       }
+      var R = multiply(inv(D), N);
 
-      var R = multiply(inv(D), N); // Square j times
-
+      // Square j times
       for (var _i = 0; _i < j; _i++) {
         R = multiply(R, R);
       }
-
       return isSparseMatrix(A) ? A.createSparseMatrix(R) : R;
     }
   });
-
   function infinityNorm(A) {
     var n = A.size()[0];
     var infNorm = 0;
-
     for (var i = 0; i < n; i++) {
       var rowSum = 0;
-
       for (var j = 0; j < n; j++) {
         rowSum += abs(A.get([i, j]));
       }
-
       infNorm = Math.max(rowSum, infNorm);
     }
-
     return infNorm;
   }
+
   /**
    * Find the best parameters for the Pade approximant given
    * the matrix norm and desired accuracy. Returns the first acceptable
    * combination in order of increasing computational load.
    */
-
-
   function findParams(infNorm, eps) {
     var maxSearchSize = 30;
-
     for (var k = 0; k < maxSearchSize; k++) {
       for (var q = 0; q <= k; q++) {
         var j = k - q;
-
         if (errorEstimate(infNorm, q, j) < eps) {
           return {
             q,
@@ -138,28 +132,22 @@ export var createExpm = /* #__PURE__ */factory(name, dependencies, _ref => {
         }
       }
     }
-
     throw new Error('Could not find acceptable parameters to compute the matrix exponential (try increasing maxSearchSize in expm.js)');
   }
+
   /**
    * Returns the estimated error of the Pade approximant for the given
    * parameters.
    */
-
-
   function errorEstimate(infNorm, q, j) {
     var qfac = 1;
-
     for (var i = 2; i <= q; i++) {
       qfac *= i;
     }
-
     var twoqfac = qfac;
-
     for (var _i2 = q + 1; _i2 <= 2 * q; _i2++) {
       twoqfac *= _i2;
     }
-
     var twoqp1fac = twoqfac * (2 * q + 1);
     return 8.0 * Math.pow(infNorm / Math.pow(2, j), 2 * q) * qfac * qfac / (twoqfac * twoqp1fac);
   }