mathjs 12.4.3 → 13.0.0

package/lib/cjs/function/algebra/decomposition/lup.js

@@ -6,22 +6,24 @@ Object.defineProperty(exports, "__esModule", {
 exports.createLup = void 0;
 var _object = require("../../../utils/object.js");
 var _factory = require("../../../utils/factory.js");
-var name = 'lup';
-var dependencies = ['typed', 'matrix', 'abs', 'addScalar', 'divideScalar', 'multiplyScalar', 'subtractScalar', 'larger', 'equalScalar', 'unaryMinus', 'DenseMatrix', 'SparseMatrix', 'Spa'];
-var createLup = exports.createLup = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed,
-    matrix = _ref.matrix,
-    abs = _ref.abs,
-    addScalar = _ref.addScalar,
-    divideScalar = _ref.divideScalar,
-    multiplyScalar = _ref.multiplyScalar,
-    subtractScalar = _ref.subtractScalar,
-    larger = _ref.larger,
-    equalScalar = _ref.equalScalar,
-    unaryMinus = _ref.unaryMinus,
-    DenseMatrix = _ref.DenseMatrix,
-    SparseMatrix = _ref.SparseMatrix,
-    Spa = _ref.Spa;
+const name = 'lup';
+const dependencies = ['typed', 'matrix', 'abs', 'addScalar', 'divideScalar', 'multiplyScalar', 'subtractScalar', 'larger', 'equalScalar', 'unaryMinus', 'DenseMatrix', 'SparseMatrix', 'Spa'];
+const createLup = exports.createLup = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    matrix,
+    abs,
+    addScalar,
+    divideScalar,
+    multiplyScalar,
+    subtractScalar,
+    larger,
+    equalScalar,
+    unaryMinus,
+    DenseMatrix,
+    SparseMatrix,
+    Spa
+  } = _ref;
   /**
    * Calculate the Matrix LU decomposition with partial pivoting. Matrix `A` is decomposed in two matrices (`L`, `U`) and a
    * row permutation vector `p` where `A[p,:] = L * U`
@@ -49,17 +51,17 @@ var createLup = exports.createLup = /* #__PURE__ */(0, _factory.factory)(name, d
    * @return {{L: Array | Matrix, U: Array | Matrix, P: Array.<number>}} The lower triangular matrix, the upper triangular matrix and the permutation matrix.
    */
   return typed(name, {
-    DenseMatrix: function DenseMatrix(m) {
+    DenseMatrix: function (m) {
       return _denseLUP(m);
     },
-    SparseMatrix: function SparseMatrix(m) {
+    SparseMatrix: function (m) {
       return _sparseLUP(m);
     },
-    Array: function Array(a) {
+    Array: function (a) {
       // create dense matrix from array
-      var m = matrix(a);
+      const m = matrix(a);
       // lup, use matrix implementation
-      var r = _denseLUP(m);
+      const r = _denseLUP(m);
       // result
       return {
         L: r.L.valueOf(),
@@ -70,22 +72,22 @@ var createLup = exports.createLup = /* #__PURE__ */(0, _factory.factory)(name, d
   });
   function _denseLUP(m) {
     // rows & columns
-    var rows = m._size[0];
-    var columns = m._size[1];
+    const rows = m._size[0];
+    const columns = m._size[1];
     // minimum rows and columns
-    var n = Math.min(rows, columns);
+    let n = Math.min(rows, columns);
     // matrix array, clone original data
-    var data = (0, _object.clone)(m._data);
+    const data = (0, _object.clone)(m._data);
     // l matrix arrays
-    var ldata = [];
-    var lsize = [rows, n];
+    const ldata = [];
+    const lsize = [rows, n];
     // u matrix arrays
-    var udata = [];
-    var usize = [n, columns];
+    const udata = [];
+    const usize = [n, columns];
     // vars
-    var i, j, k;
+    let i, j, k;
     // permutation vector
-    var p = [];
+    const p = [];
     for (i = 0; i < rows; i++) {
       p[i] = i;
     }
@@ -96,9 +98,9 @@ var createLup = exports.createLup = /* #__PURE__ */(0, _factory.factory)(name, d
         // loop rows
         for (i = 0; i < rows; i++) {
           // min i,j
-          var min = Math.min(i, j);
+          const min = Math.min(i, j);
           // v[i, j]
-          var s = 0;
+          let s = 0;
           // loop up to min
           for (k = 0; k < min; k++) {
             // s = l[i, k] - data[k, j]
@@ -108,15 +110,15 @@ var createLup = exports.createLup = /* #__PURE__ */(0, _factory.factory)(name, d
         }
       }
       // row with larger value in cvector, row >= j
-      var pi = j;
-      var pabsv = 0;
-      var vjj = 0;
+      let pi = j;
+      let pabsv = 0;
+      let vjj = 0;
       // loop rows
       for (i = j; i < rows; i++) {
         // data @ i, j
-        var v = data[i][j];
+        const v = data[i][j];
         // absolute value
-        var absv = abs(v);
+        const absv = abs(v);
         // value is greater than pivote value
         if (larger(absv, pabsv)) {
           // store row
@@ -139,7 +141,7 @@ var createLup = exports.createLup = /* #__PURE__ */(0, _factory.factory)(name, d
         // loop rows (lower triangular matrix)
         for (i = j + 1; i < rows; i++) {
           // value @ i, j
-          var vij = data[i][j];
+          const vij = data[i][j];
           if (!equalScalar(vij, 0)) {
             // update data
             data[i][j] = divideScalar(data[i][j], vjj);
@@ -202,17 +204,17 @@ var createLup = exports.createLup = /* #__PURE__ */(0, _factory.factory)(name, d
       }
     }
     // l matrix
-    var l = new DenseMatrix({
+    const l = new DenseMatrix({
       data: ldata,
       size: lsize
     });
     // u matrix
-    var u = new DenseMatrix({
+    const u = new DenseMatrix({
       data: udata,
       size: usize
     });
     // p vector
-    var pv = [];
+    const pv = [];
     for (i = 0, n = p.length; i < n; i++) {
       pv[p[i]] = i;
     }
@@ -221,45 +223,45 @@ var createLup = exports.createLup = /* #__PURE__ */(0, _factory.factory)(name, d
       L: l,
       U: u,
       p: pv,
-      toString: function toString() {
+      toString: function () {
         return 'L: ' + this.L.toString() + '\nU: ' + this.U.toString() + '\nP: ' + this.p;
       }
     };
   }
   function _sparseLUP(m) {
     // rows & columns
-    var rows = m._size[0];
-    var columns = m._size[1];
+    const rows = m._size[0];
+    const columns = m._size[1];
     // minimum rows and columns
-    var n = Math.min(rows, columns);
+    const n = Math.min(rows, columns);
     // matrix arrays (will not be modified, thanks to permutation vector)
-    var values = m._values;
-    var index = m._index;
-    var ptr = m._ptr;
+    const values = m._values;
+    const index = m._index;
+    const ptr = m._ptr;
     // l matrix arrays
-    var lvalues = [];
-    var lindex = [];
-    var lptr = [];
-    var lsize = [rows, n];
+    const lvalues = [];
+    const lindex = [];
+    const lptr = [];
+    const lsize = [rows, n];
     // u matrix arrays
-    var uvalues = [];
-    var uindex = [];
-    var uptr = [];
-    var usize = [n, columns];
+    const uvalues = [];
+    const uindex = [];
+    const uptr = [];
+    const usize = [n, columns];
     // vars
-    var i, j, k;
+    let i, j, k;
     // permutation vectors, (current index -> original index) and (original index -> current index)
-    var pvCo = [];
-    var pvOc = [];
+    const pvCo = [];
+    const pvOc = [];
     for (i = 0; i < rows; i++) {
       pvCo[i] = i;
       pvOc[i] = i;
     }
     // swap indices in permutation vectors (condition x < y)!
-    var swapIndeces = function swapIndeces(x, y) {
+    const swapIndeces = function (x, y) {
       // find pv indeces getting data from x and y
-      var kx = pvOc[x];
-      var ky = pvOc[y];
+      const kx = pvOc[x];
+      const ky = pvOc[y];
       // update permutation vector current -> original
       pvCo[kx] = y;
       pvCo[ky] = x;
@@ -268,9 +270,9 @@ var createLup = exports.createLup = /* #__PURE__ */(0, _factory.factory)(name, d
       pvOc[y] = kx;
     };
     // loop columns
-    var _loop = function _loop() {
+    for (j = 0; j < columns; j++) {
       // sparse accumulator
-      var spa = new Spa();
+      const spa = new Spa();
       // check lower triangular matrix has a value @ column j
       if (j < rows) {
         // update ptr
@@ -282,8 +284,8 @@ var createLup = exports.createLup = /* #__PURE__ */(0, _factory.factory)(name, d
       // update ptr
       uptr.push(uvalues.length);
       // k0 <= k < k1 where k0 = _ptr[j] && k1 = _ptr[j+1]
-      var k0 = ptr[j];
-      var k1 = ptr[j + 1];
+      const k0 = ptr[j];
+      const k1 = ptr[j + 1];
       // copy column j into sparse accumulator
       for (k = k0; k < k1; k++) {
         // row
@@ -306,13 +308,13 @@ var createLup = exports.createLup = /* #__PURE__ */(0, _factory.factory)(name, d
         });
       }
       // row with larger value in spa, row >= j
-      var pi = j;
-      var vjj = spa.get(j);
-      var pabsv = abs(vjj);
+      let pi = j;
+      let vjj = spa.get(j);
+      let pabsv = abs(vjj);
       // loop values in spa (order by row, below diagonal)
       spa.forEach(j + 1, rows - 1, function (x, v) {
         // absolute value
-        var absv = abs(v);
+        const absv = abs(v);
         // value is greater than pivote value
         if (larger(absv, pabsv)) {
           // store row
@@ -352,9 +354,6 @@ var createLup = exports.createLup = /* #__PURE__ */(0, _factory.factory)(name, d
           }
         }
       });
-    };
-    for (j = 0; j < columns; j++) {
-      _loop();
     }
     // update ptrs
     uptr.push(uvalues.length);
@@ -375,7 +374,7 @@ var createLup = exports.createLup = /* #__PURE__ */(0, _factory.factory)(name, d
         size: usize
       }),
       p: pvCo,
-      toString: function toString() {
+      toString: function () {
         return 'L: ' + this.L.toString() + '\nU: ' + this.U.toString() + '\nP: ' + this.p;
       }
     };

package/lib/cjs/function/algebra/decomposition/qr.js

@@ -7,24 +7,26 @@ Object.defineProperty(exports, "__esModule", {
 exports.createQr = void 0;
 var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
 var _factory = require("../../../utils/factory.js");
-var name = 'qr';
-var dependencies = ['typed', 'matrix', 'zeros', 'identity', 'isZero', 'equal', 'sign', 'sqrt', 'conj', 'unaryMinus', 'addScalar', 'divideScalar', 'multiplyScalar', 'subtractScalar', 'complex'];
-var createQr = exports.createQr = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed,
-    matrix = _ref.matrix,
-    zeros = _ref.zeros,
-    identity = _ref.identity,
-    isZero = _ref.isZero,
-    equal = _ref.equal,
-    sign = _ref.sign,
-    sqrt = _ref.sqrt,
-    conj = _ref.conj,
-    unaryMinus = _ref.unaryMinus,
-    addScalar = _ref.addScalar,
-    divideScalar = _ref.divideScalar,
-    multiplyScalar = _ref.multiplyScalar,
-    subtractScalar = _ref.subtractScalar,
-    complex = _ref.complex;
+const name = 'qr';
+const dependencies = ['typed', 'matrix', 'zeros', 'identity', 'isZero', 'equal', 'sign', 'sqrt', 'conj', 'unaryMinus', 'addScalar', 'divideScalar', 'multiplyScalar', 'subtractScalar', 'complex'];
+const createQr = exports.createQr = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    matrix,
+    zeros,
+    identity,
+    isZero,
+    equal,
+    sign,
+    sqrt,
+    conj,
+    unaryMinus,
+    addScalar,
+    divideScalar,
+    multiplyScalar,
+    subtractScalar,
+    complex
+  } = _ref;
   /**
    * Calculate the Matrix QR decomposition. Matrix `A` is decomposed in
    * two matrices (`Q`, `R`) where `Q` is an
@@ -68,18 +70,18 @@ var createQr = exports.createQr = /* #__PURE__ */(0, _factory.factory)(name, dep
    * @return {{Q: Array | Matrix, R: Array | Matrix}} Q: the orthogonal
    * matrix and R: the upper triangular matrix
    */
-  return (0, _extends2["default"])(typed(name, {
-    DenseMatrix: function DenseMatrix(m) {
+  return (0, _extends2.default)(typed(name, {
+    DenseMatrix: function (m) {
       return _denseQR(m);
     },
-    SparseMatrix: function SparseMatrix(m) {
+    SparseMatrix: function (m) {
       return _sparseQR(m);
     },
-    Array: function Array(a) {
+    Array: function (a) {
       // create dense matrix from array
-      var m = matrix(a);
+      const m = matrix(a);
       // lup, use matrix implementation
-      var r = _denseQR(m);
+      const r = _denseQR(m);
       // result
       return {
         Q: r.Q.valueOf(),
@@ -87,21 +89,21 @@ var createQr = exports.createQr = /* #__PURE__ */(0, _factory.factory)(name, dep
       };
     }
   }), {
-    _denseQRimpl: _denseQRimpl
+    _denseQRimpl
   });
   function _denseQRimpl(m) {
     // rows & columns (m x n)
-    var rows = m._size[0]; // m
-    var cols = m._size[1]; // n
+    const rows = m._size[0]; // m
+    const cols = m._size[1]; // n
 
-    var Q = identity([rows], 'dense');
-    var Qdata = Q._data;
-    var R = m.clone();
-    var Rdata = R._data;
+    const Q = identity([rows], 'dense');
+    const Qdata = Q._data;
+    const R = m.clone();
+    const Rdata = R._data;
 
     // vars
-    var i, j, k;
-    var w = zeros([rows], '');
+    let i, j, k;
+    const w = zeros([rows], '');
     for (k = 0; k < Math.min(cols, rows); ++k) {
       /*
        * **k-th Household matrix**
@@ -127,17 +129,17 @@ var createQr = exports.createQr = /* #__PURE__ */(0, _factory.factory)(name, dep
        *
        */
 
-      var pivot = Rdata[k][k];
-      var sgn = unaryMinus(equal(pivot, 0) ? 1 : sign(pivot));
-      var conjSgn = conj(sgn);
-      var alphaSquared = 0;
+      const pivot = Rdata[k][k];
+      const sgn = unaryMinus(equal(pivot, 0) ? 1 : sign(pivot));
+      const conjSgn = conj(sgn);
+      let alphaSquared = 0;
       for (i = k; i < rows; i++) {
         alphaSquared = addScalar(alphaSquared, multiplyScalar(Rdata[i][k], conj(Rdata[i][k])));
       }
-      var alpha = multiplyScalar(sgn, sqrt(alphaSquared));
+      const alpha = multiplyScalar(sgn, sqrt(alphaSquared));
       if (!isZero(alpha)) {
         // first element in vector u
-        var u1 = subtractScalar(pivot, alpha);
+        const u1 = subtractScalar(pivot, alpha);
 
         // w = v * u1 / |u|    (only elements k to (rows-1) are used)
         w[k] = 1;
@@ -146,8 +148,8 @@ var createQr = exports.createQr = /* #__PURE__ */(0, _factory.factory)(name, dep
         }
 
         // tau = - conj(u1 / alpha)
-        var tau = unaryMinus(conj(divideScalar(u1, alpha)));
-        var s = void 0;
+        const tau = unaryMinus(conj(divideScalar(u1, alpha)));
+        let s;
 
         /*
          * tau and w have been choosen so that
@@ -201,20 +203,20 @@ var createQr = exports.createQr = /* #__PURE__ */(0, _factory.factory)(name, dep
 
     // return matrices
     return {
-      Q: Q,
-      R: R,
-      toString: function toString() {
+      Q,
+      R,
+      toString: function () {
         return 'Q: ' + this.Q.toString() + '\nR: ' + this.R.toString();
       }
     };
   }
   function _denseQR(m) {
-    var ret = _denseQRimpl(m);
-    var Rdata = ret.R._data;
+    const ret = _denseQRimpl(m);
+    const Rdata = ret.R._data;
     if (m._data.length > 0) {
-      var zero = Rdata[0][0].type === 'Complex' ? complex(0) : 0;
-      for (var i = 0; i < Rdata.length; ++i) {
-        for (var j = 0; j < i && j < (Rdata[0] || []).length; ++j) {
+      const zero = Rdata[0][0].type === 'Complex' ? complex(0) : 0;
+      for (let i = 0; i < Rdata.length; ++i) {
+        for (let j = 0; j < i && j < (Rdata[0] || []).length; ++j) {
           Rdata[i][j] = zero;
         }
       }

package/lib/cjs/function/algebra/decomposition/schur.js

@@ -5,16 +5,18 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.createSchur = void 0;
 var _factory = require("../../../utils/factory.js");
-var name = 'schur';
-var dependencies = ['typed', 'matrix', 'identity', 'multiply', 'qr', 'norm', 'subtract'];
-var createSchur = exports.createSchur = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed,
-    matrix = _ref.matrix,
-    identity = _ref.identity,
-    multiply = _ref.multiply,
-    qr = _ref.qr,
-    norm = _ref.norm,
-    subtract = _ref.subtract;
+const name = 'schur';
+const dependencies = ['typed', 'matrix', 'identity', 'multiply', 'qr', 'norm', 'subtract'];
+const createSchur = exports.createSchur = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    matrix,
+    identity,
+    multiply,
+    qr,
+    norm,
+    subtract
+  } = _ref;
   /**
    *
    * Performs a real Schur decomposition of the real matrix A = UTU' where U is orthogonal
@@ -38,28 +40,28 @@ var createSchur = exports.createSchur = /* #__PURE__ */(0, _factory.factory)(nam
    * @return {{U: Array | Matrix, T: Array | Matrix}} Object containing both matrix U and T of the Schur Decomposition A=UTU'
    */
   return typed(name, {
-    Array: function Array(X) {
-      var r = _schur(matrix(X));
+    Array: function (X) {
+      const r = _schur(matrix(X));
       return {
         U: r.U.valueOf(),
         T: r.T.valueOf()
       };
     },
-    Matrix: function Matrix(X) {
+    Matrix: function (X) {
       return _schur(X);
     }
   });
   function _schur(X) {
-    var n = X.size()[0];
-    var A = X;
-    var U = identity(n);
-    var k = 0;
-    var A0;
+    const n = X.size()[0];
+    let A = X;
+    let U = identity(n);
+    let k = 0;
+    let A0;
     do {
       A0 = A;
-      var QR = qr(A);
-      var Q = QR.Q;
-      var R = QR.R;
+      const QR = qr(A);
+      const Q = QR.Q;
+      const R = QR.R;
       A = multiply(R, Q);
       U = multiply(U, Q);
       if (k++ > 100) {
@@ -67,7 +69,7 @@ var createSchur = exports.createSchur = /* #__PURE__ */(0, _factory.factory)(nam
       }
     } while (norm(subtract(A, A0)) > 1e-4);
     return {
-      U: U,
+      U,
       T: A
     };
   }

package/lib/cjs/function/algebra/decomposition/slu.js

@@ -8,32 +8,34 @@ var _number = require("../../../utils/number.js");
 var _factory = require("../../../utils/factory.js");
 var _csSqr = require("../sparse/csSqr.js");
 var _csLu = require("../sparse/csLu.js");
-var name = 'slu';
-var dependencies = ['typed', 'abs', 'add', 'multiply', 'transpose', 'divideScalar', 'subtract', 'larger', 'largerEq', 'SparseMatrix'];
-var createSlu = exports.createSlu = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed,
-    abs = _ref.abs,
-    add = _ref.add,
-    multiply = _ref.multiply,
-    transpose = _ref.transpose,
-    divideScalar = _ref.divideScalar,
-    subtract = _ref.subtract,
-    larger = _ref.larger,
-    largerEq = _ref.largerEq,
-    SparseMatrix = _ref.SparseMatrix;
-  var csSqr = (0, _csSqr.createCsSqr)({
-    add: add,
-    multiply: multiply,
-    transpose: transpose
+const name = 'slu';
+const dependencies = ['typed', 'abs', 'add', 'multiply', 'transpose', 'divideScalar', 'subtract', 'larger', 'largerEq', 'SparseMatrix'];
+const createSlu = exports.createSlu = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    abs,
+    add,
+    multiply,
+    transpose,
+    divideScalar,
+    subtract,
+    larger,
+    largerEq,
+    SparseMatrix
+  } = _ref;
+  const csSqr = (0, _csSqr.createCsSqr)({
+    add,
+    multiply,
+    transpose
   });
-  var csLu = (0, _csLu.createCsLu)({
-    abs: abs,
-    divideScalar: divideScalar,
-    multiply: multiply,
-    subtract: subtract,
-    larger: larger,
-    largerEq: largerEq,
-    SparseMatrix: SparseMatrix
+  const csLu = (0, _csLu.createCsLu)({
+    abs,
+    divideScalar,
+    multiply,
+    subtract,
+    larger,
+    largerEq,
+    SparseMatrix
   });
 
   /**
@@ -74,7 +76,7 @@ var createSlu = exports.createSlu = /* #__PURE__ */(0, _factory.factory)(name, d
    * @return {Object} The lower triangular matrix, the upper triangular matrix and the permutation vectors.
    */
   return typed(name, {
-    'SparseMatrix, number, number': function SparseMatrixNumberNumber(a, order, threshold) {
+    'SparseMatrix, number, number': function (a, order, threshold) {
       // verify order
       if (!(0, _number.isInteger)(order) || order < 0 || order > 3) {
         throw new Error('Symbolic Ordering and Analysis order must be an integer number in the interval [0, 3]');
@@ -85,10 +87,10 @@ var createSlu = exports.createSlu = /* #__PURE__ */(0, _factory.factory)(name, d
       }
 
       // perform symbolic ordering and analysis
-      var s = csSqr(order, a, false);
+      const s = csSqr(order, a, false);
 
       // perform lu decomposition
-      var f = csLu(a, s, threshold);
+      const f = csLu(a, s, threshold);
 
       // return decomposition
       return {
@@ -96,7 +98,7 @@ var createSlu = exports.createSlu = /* #__PURE__ */(0, _factory.factory)(name, d
         U: f.U,
         p: f.pinv,
         q: s.q,
-        toString: function toString() {
+        toString: function () {
           return 'L: ' + this.L.toString() + '\nU: ' + this.U.toString() + '\np: ' + this.p.toString() + (this.q ? '\nq: ' + this.q.toString() : '') + '\n';
         }
       };