mathjs 12.4.3 → 13.0.1

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

@@ -11,86 +11,88 @@ var _string = require("../../utils/string.js");
 var _complexEigs = require("./eigs/complexEigs.js");
 var _realSymmetric = require("./eigs/realSymmetric.js");
 var _is = require("../../utils/is.js");
-var name = 'eigs';
+const 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', 'size', 'reshape', 'qr', 'usolve', 'usolveAll', 'im', 're', 'smaller', 'matrixFromColumns', 'dot'];
-var createEigs = exports.createEigs = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var config = _ref.config,
-    typed = _ref.typed,
-    matrix = _ref.matrix,
-    addScalar = _ref.addScalar,
-    subtract = _ref.subtract,
-    equal = _ref.equal,
-    abs = _ref.abs,
-    atan = _ref.atan,
-    cos = _ref.cos,
-    sin = _ref.sin,
-    multiplyScalar = _ref.multiplyScalar,
-    divideScalar = _ref.divideScalar,
-    inv = _ref.inv,
-    bignumber = _ref.bignumber,
-    multiply = _ref.multiply,
-    add = _ref.add,
-    larger = _ref.larger,
-    column = _ref.column,
-    flatten = _ref.flatten,
-    number = _ref.number,
-    complex = _ref.complex,
-    sqrt = _ref.sqrt,
-    diag = _ref.diag,
-    size = _ref.size,
-    reshape = _ref.reshape,
-    qr = _ref.qr,
-    usolve = _ref.usolve,
-    usolveAll = _ref.usolveAll,
-    im = _ref.im,
-    re = _ref.re,
-    smaller = _ref.smaller,
-    matrixFromColumns = _ref.matrixFromColumns,
-    dot = _ref.dot;
-  var doRealSymmetric = (0, _realSymmetric.createRealSymmetric)({
-    config: config,
-    addScalar: addScalar,
-    subtract: subtract,
-    column: column,
-    flatten: flatten,
-    equal: equal,
-    abs: abs,
-    atan: atan,
-    cos: cos,
-    sin: sin,
-    multiplyScalar: multiplyScalar,
-    inv: inv,
-    bignumber: bignumber,
-    complex: complex,
-    multiply: multiply,
-    add: add
+const dependencies = ['config', 'typed', 'matrix', 'addScalar', 'equal', 'subtract', 'abs', 'atan', 'cos', 'sin', 'multiplyScalar', 'divideScalar', 'inv', 'bignumber', 'multiply', 'add', 'larger', 'column', 'flatten', 'number', 'complex', 'sqrt', 'diag', 'size', 'reshape', 'qr', 'usolve', 'usolveAll', 'im', 're', 'smaller', 'matrixFromColumns', 'dot'];
+const createEigs = exports.createEigs = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    config,
+    typed,
+    matrix,
+    addScalar,
+    subtract,
+    equal,
+    abs,
+    atan,
+    cos,
+    sin,
+    multiplyScalar,
+    divideScalar,
+    inv,
+    bignumber,
+    multiply,
+    add,
+    larger,
+    column,
+    flatten,
+    number,
+    complex,
+    sqrt,
+    diag,
+    size,
+    reshape,
+    qr,
+    usolve,
+    usolveAll,
+    im,
+    re,
+    smaller,
+    matrixFromColumns,
+    dot
+  } = _ref;
+  const doRealSymmetric = (0, _realSymmetric.createRealSymmetric)({
+    config,
+    addScalar,
+    subtract,
+    column,
+    flatten,
+    equal,
+    abs,
+    atan,
+    cos,
+    sin,
+    multiplyScalar,
+    inv,
+    bignumber,
+    complex,
+    multiply,
+    add
   });
-  var doComplexEigs = (0, _complexEigs.createComplexEigs)({
-    config: config,
-    addScalar: addScalar,
-    subtract: subtract,
-    multiply: multiply,
-    multiplyScalar: multiplyScalar,
-    flatten: flatten,
-    divideScalar: divideScalar,
-    sqrt: sqrt,
-    abs: abs,
-    bignumber: bignumber,
-    diag: diag,
-    size: size,
-    reshape: reshape,
-    qr: qr,
-    inv: inv,
-    usolve: usolve,
-    usolveAll: usolveAll,
-    equal: equal,
-    complex: complex,
-    larger: larger,
-    smaller: smaller,
-    matrixFromColumns: matrixFromColumns,
-    dot: dot
+  const doComplexEigs = (0, _complexEigs.createComplexEigs)({
+    config,
+    addScalar,
+    subtract,
+    multiply,
+    multiplyScalar,
+    flatten,
+    divideScalar,
+    sqrt,
+    abs,
+    bignumber,
+    diag,
+    size,
+    reshape,
+    qr,
+    inv,
+    usolve,
+    usolveAll,
+    equal,
+    complex,
+    larger,
+    smaller,
+    matrixFromColumns,
+    dot
   });
 
   /**
@@ -149,7 +151,7 @@ var createEigs = exports.createEigs = /* #__PURE__ */(0, _factory.factory)(name,
    *
    * @param {Array | Matrix} x  Matrix to be diagonalized
    *
-   * @param {number | BigNumber | OptsObject} [opts] Object with keys `precision`, defaulting to config.epsilon, and `eigenvectors`, defaulting to true and specifying whether to compute eigenvectors. If just a number, specifies precision.
+   * @param {number | BigNumber | OptsObject} [opts] Object with keys `precision`, defaulting to config.relTol, and `eigenvectors`, defaulting to true and specifying whether to compute eigenvectors. If just a number, specifies precision.
    * @return {{values: Array|Matrix, eigenvectors?: Array<EVobj>}} Object containing an array of eigenvalues and an array of {value: number|BigNumber, vector: Array|Matrix} objects. The eigenvectors property is undefined if eigenvectors were not requested.
    *
    */
@@ -160,50 +162,52 @@ var createEigs = exports.createEigs = /* #__PURE__ */(0, _factory.factory)(name,
     // streamlined. It is done because the Matrix object carries some
     // type information about its entries, and so constructing the matrix
     // is a roundabout way of doing type detection.
-    Array: function Array(x) {
+    Array: function (x) {
       return doEigs(matrix(x));
     },
-    'Array, number|BigNumber': function ArrayNumberBigNumber(x, prec) {
+    'Array, number|BigNumber': function (x, prec) {
       return doEigs(matrix(x), {
         precision: prec
       });
     },
-    'Array, Object': function ArrayObject(x, opts) {
+    'Array, Object'(x, opts) {
       return doEigs(matrix(x), opts);
     },
-    Matrix: function Matrix(mat) {
+    Matrix: function (mat) {
       return doEigs(mat, {
         matricize: true
       });
     },
-    'Matrix, number|BigNumber': function MatrixNumberBigNumber(mat, prec) {
+    'Matrix, number|BigNumber': function (mat, prec) {
       return doEigs(mat, {
         precision: prec,
         matricize: true
       });
     },
-    'Matrix, Object': function MatrixObject(mat, opts) {
-      var useOpts = {
+    'Matrix, Object': function (mat, opts) {
+      const useOpts = {
         matricize: true
       };
-      (0, _extends2["default"])(useOpts, opts);
+      (0, _extends2.default)(useOpts, opts);
       return doEigs(mat, useOpts);
     }
   });
   function doEigs(mat) {
     var _opts$precision;
-    var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    var computeVectors = 'eigenvectors' in opts ? opts.eigenvectors : true;
-    var prec = (_opts$precision = opts.precision) !== null && _opts$precision !== void 0 ? _opts$precision : config.epsilon;
-    var result = computeValuesAndVectors(mat, prec, computeVectors);
+    let opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    const computeVectors = 'eigenvectors' in opts ? opts.eigenvectors : true;
+    const prec = (_opts$precision = opts.precision) !== null && _opts$precision !== void 0 ? _opts$precision : config.relTol;
+    const result = computeValuesAndVectors(mat, prec, computeVectors);
     if (opts.matricize) {
       result.values = matrix(result.values);
       if (computeVectors) {
-        result.eigenvectors = result.eigenvectors.map(function (_ref2) {
-          var value = _ref2.value,
-            vector = _ref2.vector;
+        result.eigenvectors = result.eigenvectors.map(_ref2 => {
+          let {
+            value,
+            vector
+          } = _ref2;
           return {
-            value: value,
+            value,
             vector: matrix(vector)
           };
         });
@@ -214,7 +218,7 @@ var createEigs = exports.createEigs = /* #__PURE__ */(0, _factory.factory)(name,
         enumerable: false,
         // to make sure that the eigenvectors can still be
         // converted to string.
-        get: function get() {
+        get: () => {
           throw new Error('eigs(M).vectors replaced with eigs(M).eigenvectors');
         }
       });
@@ -222,29 +226,29 @@ var createEigs = exports.createEigs = /* #__PURE__ */(0, _factory.factory)(name,
     return result;
   }
   function computeValuesAndVectors(mat, prec, computeVectors) {
-    var arr = mat.toArray(); // NOTE: arr is guaranteed to be unaliased
+    const arr = mat.toArray(); // NOTE: arr is guaranteed to be unaliased
     // and so safe to modify in place
-    var asize = mat.size();
+    const asize = mat.size();
     if (asize.length !== 2 || asize[0] !== asize[1]) {
-      throw new RangeError("Matrix must be square (size: ".concat((0, _string.format)(asize), ")"));
+      throw new RangeError(`Matrix must be square (size: ${(0, _string.format)(asize)})`);
     }
-    var N = asize[0];
+    const N = asize[0];
     if (isReal(arr, N, prec)) {
       coerceReal(arr, N); // modifies arr by side effect
 
       if (isSymmetric(arr, N, prec)) {
-        var _type = coerceTypes(mat, arr, N); // modifies arr by side effect
-        return doRealSymmetric(arr, N, prec, _type, computeVectors);
+        const type = coerceTypes(mat, arr, N); // modifies arr by side effect
+        return doRealSymmetric(arr, N, prec, type, computeVectors);
       }
     }
-    var type = coerceTypes(mat, arr, N); // modifies arr by side effect
+    const type = coerceTypes(mat, arr, N); // modifies arr by side effect
     return doComplexEigs(arr, N, prec, type, computeVectors);
   }
 
   /** @return {boolean} */
   function isSymmetric(arr, N, prec) {
-    for (var i = 0; i < N; i++) {
-      for (var j = i; j < N; j++) {
+    for (let i = 0; i < N; i++) {
+      for (let 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;
@@ -256,8 +260,8 @@ var createEigs = exports.createEigs = /* #__PURE__ */(0, _factory.factory)(name,
 
   /** @return {boolean} */
   function isReal(arr, N, prec) {
-    for (var i = 0; i < N; i++) {
-      for (var j = 0; j < N; j++) {
+    for (let i = 0; i < N; i++) {
+      for (let j = 0; j < N; j++) {
         // TODO proper comparison of bignum and frac
         if (larger(bignumber(abs(im(arr[i][j]))), prec)) {
           return false;
@@ -267,8 +271,8 @@ var createEigs = exports.createEigs = /* #__PURE__ */(0, _factory.factory)(name,
     return true;
   }
   function coerceReal(arr, N) {
-    for (var i = 0; i < N; i++) {
-      for (var j = 0; j < N; j++) {
+    for (let i = 0; i < N; i++) {
+      for (let j = 0; j < N; j++) {
         arr[i][j] = re(arr[i][j]);
       }
     }
@@ -277,16 +281,16 @@ var createEigs = exports.createEigs = /* #__PURE__ */(0, _factory.factory)(name,
   /** @return {'number' | 'BigNumber' | 'Complex'} */
   function coerceTypes(mat, arr, N) {
     /** @type {string} */
-    var type = mat.datatype();
+    const 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];
+    let hasNumber = false;
+    let hasBig = false;
+    let hasComplex = false;
+    for (let i = 0; i < N; i++) {
+      for (let j = 0; j < N; j++) {
+        const el = arr[i][j];
         if ((0, _is.isNumber)(el) || (0, _is.isFraction)(el)) {
           hasNumber = true;
         } else if ((0, _is.isBigNumber)(el)) {
@@ -302,25 +306,25 @@ var createEigs = exports.createEigs = /* #__PURE__ */(0, _factory.factory)(name,
       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]);
+      for (let i = 0; i < N; i++) {
+        for (let 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]);
+      for (let i = 0; i < N; i++) {
+        for (let j = 0; j < N; j++) {
+          arr[i][j] = bignumber(arr[i][j]);
         }
       }
       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]);
+      for (let i = 0; i < N; i++) {
+        for (let j = 0; j < N; j++) {
+          arr[i][j] = number(arr[i][j]);
         }
       }
       return 'number';

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

@@ -7,15 +7,17 @@ exports.createExpm = void 0;
 var _is = require("../../utils/is.js");
 var _string = require("../../utils/string.js");
 var _factory = require("../../utils/factory.js");
-var name = 'expm';
-var dependencies = ['typed', 'abs', 'add', 'identity', 'inv', 'multiply'];
-var createExpm = exports.createExpm = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed,
-    abs = _ref.abs,
-    add = _ref.add,
-    identity = _ref.identity,
-    inv = _ref.inv,
-    multiply = _ref.multiply;
+const name = 'expm';
+const dependencies = ['typed', 'abs', 'add', 'identity', 'inv', 'multiply'];
+const createExpm = exports.createExpm = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    abs,
+    add,
+    identity,
+    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,17 +44,17 @@ var createExpm = exports.createExpm = /* #__PURE__ */(0, _factory.factory)(name,
    * @return {Matrix}   The exponential of x
    */
   return typed(name, {
-    Matrix: function Matrix(A) {
+    Matrix: function (A) {
       // Check matrix size
-      var size = A.size();
+      const size = A.size();
       if (size.length !== 2 || size[0] !== size[1]) {
         throw new RangeError('Matrix must be square ' + '(size: ' + (0, _string.format)(size) + ')');
       }
-      var n = size[0];
+      const n = size[0];
 
       // Desired accuracy of the approximant (The actual accuracy
       // will be affected by round-off error)
-      var eps = 1e-15;
+      const eps = 1e-15;
 
       // The Padé approximant is not so accurate when the values of A
       // are "large", so scale A by powers of two. Then compute the
@@ -60,13 +62,13 @@ var createExpm = exports.createExpm = /* #__PURE__ */(0, _factory.factory)(name,
       // the identity e^A = (e^(A/m))^m
 
       // Compute infinity-norm of A, ||A||, to see how "big" it is
-      var infNorm = infinityNorm(A);
+      const infNorm = infinityNorm(A);
 
       // 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;
+      const params = findParams(infNorm, eps);
+      const q = params.q;
+      const j = params.j;
 
       // The Pade approximation to e^A is:
       // Rqq(A) = Dqq(A) ^ -1 * Nqq(A)
@@ -75,19 +77,19 @@ var createExpm = exports.createExpm = /* #__PURE__ */(0, _factory.factory)(name,
       // 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));
+      const Apos = multiply(A, Math.pow(2, -j));
 
       // The i=0 term is just the identity matrix
-      var N = identity(n);
-      var D = identity(n);
+      let N = identity(n);
+      let D = identity(n);
 
       // Initialization (i=0)
-      var factor = 1;
+      let factor = 1;
 
       // Initialization (i=1)
-      var AposToI = Apos; // Cloning not necessary
-      var alternate = -1;
-      for (var i = 1; i <= q; i++) {
+      let AposToI = Apos; // Cloning not necessary
+      let alternate = -1;
+      for (let i = 1; i <= q; i++) {
         if (i > 1) {
           AposToI = multiply(AposToI, Apos);
           alternate = -alternate;
@@ -96,21 +98,21 @@ var createExpm = exports.createExpm = /* #__PURE__ */(0, _factory.factory)(name,
         N = add(N, multiply(factor, AposToI));
         D = add(D, multiply(factor * alternate, AposToI));
       }
-      var R = multiply(inv(D), N);
+      let R = multiply(inv(D), N);
 
       // Square j times
-      for (var _i = 0; _i < j; _i++) {
+      for (let i = 0; i < j; i++) {
         R = multiply(R, R);
       }
       return (0, _is.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++) {
+    const n = A.size()[0];
+    let infNorm = 0;
+    for (let i = 0; i < n; i++) {
+      let rowSum = 0;
+      for (let j = 0; j < n; j++) {
         rowSum += abs(A.get([i, j]));
       }
       infNorm = Math.max(rowSum, infNorm);
@@ -124,14 +126,14 @@ var createExpm = exports.createExpm = /* #__PURE__ */(0, _factory.factory)(name,
    * 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;
+    const maxSearchSize = 30;
+    for (let k = 0; k < maxSearchSize; k++) {
+      for (let q = 0; q <= k; q++) {
+        const j = k - q;
         if (errorEstimate(infNorm, q, j) < eps) {
           return {
-            q: q,
-            j: j
+            q,
+            j
           };
         }
       }
@@ -144,15 +146,15 @@ var createExpm = exports.createExpm = /* #__PURE__ */(0, _factory.factory)(name,
    * parameters.
    */
   function errorEstimate(infNorm, q, j) {
-    var qfac = 1;
-    for (var i = 2; i <= q; i++) {
+    let qfac = 1;
+    for (let i = 2; i <= q; i++) {
       qfac *= i;
     }
-    var twoqfac = qfac;
-    for (var _i2 = q + 1; _i2 <= 2 * q; _i2++) {
-      twoqfac *= _i2;
+    let twoqfac = qfac;
+    for (let i = q + 1; i <= 2 * q; i++) {
+      twoqfac *= i;
     }
-    var twoqp1fac = twoqfac * (2 * q + 1);
+    const twoqp1fac = twoqfac * (2 * q + 1);
     return 8.0 * Math.pow(infNorm / Math.pow(2, j), 2 * q) * qfac * qfac / (twoqfac * twoqp1fac);
   }
 });