mathjs-min 11.7.2

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

@@ -0,0 +1,384 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+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', 'subtract', 'larger', 'equalScalar', 'unaryMinus', 'DenseMatrix', 'SparseMatrix', 'Spa'];
+var 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,
+    subtract = _ref.subtract,
+    larger = _ref.larger,
+    equalScalar = _ref.equalScalar,
+    unaryMinus = _ref.unaryMinus,
+    DenseMatrix = _ref.DenseMatrix,
+    SparseMatrix = _ref.SparseMatrix,
+    Spa = _ref.Spa;
+  /**
+   * 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`
+   *
+   * Syntax:
+   *
+   *    math.lup(A)
+   *
+   * Example:
+   *
+   *    const m = [[2, 1], [1, 4]]
+   *    const r = math.lup(m)
+   *    // r = {
+   *    //   L: [[1, 0], [0.5, 1]],
+   *    //   U: [[2, 1], [0, 3.5]],
+   *    //   P: [0, 1]
+   *    // }
+   *
+   * See also:
+   *
+   *    slu, lsolve, lusolve, usolve
+   *
+   * @param {Matrix | Array} A    A two dimensional matrix or array for which to get the LUP decomposition.
+   *
+   * @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) {
+      return _denseLUP(m);
+    },
+    SparseMatrix: function SparseMatrix(m) {
+      return _sparseLUP(m);
+    },
+    Array: function Array(a) {
+      // create dense matrix from array
+      var m = matrix(a);
+      // lup, use matrix implementation
+      var r = _denseLUP(m);
+      // result
+      return {
+        L: r.L.valueOf(),
+        U: r.U.valueOf(),
+        p: r.p
+      };
+    }
+  });
+  function _denseLUP(m) {
+    // rows & columns
+    var rows = m._size[0];
+    var columns = m._size[1];
+    // minimum rows and columns
+    var n = Math.min(rows, columns);
+    // matrix array, clone original data
+    var data = (0, _object.clone)(m._data);
+    // l matrix arrays
+    var ldata = [];
+    var lsize = [rows, n];
+    // u matrix arrays
+    var udata = [];
+    var usize = [n, columns];
+    // vars
+    var i, j, k;
+    // permutation vector
+    var p = [];
+    for (i = 0; i < rows; i++) {
+      p[i] = i;
+    }
+    // loop columns
+    for (j = 0; j < columns; j++) {
+      // skip first column in upper triangular matrix
+      if (j > 0) {
+        // loop rows
+        for (i = 0; i < rows; i++) {
+          // min i,j
+          var min = Math.min(i, j);
+          // v[i, j]
+          var s = 0;
+          // loop up to min
+          for (k = 0; k < min; k++) {
+            // s = l[i, k] - data[k, j]
+            s = addScalar(s, multiplyScalar(data[i][k], data[k][j]));
+          }
+          data[i][j] = subtract(data[i][j], s);
+        }
+      }
+      // row with larger value in cvector, row >= j
+      var pi = j;
+      var pabsv = 0;
+      var vjj = 0;
+      // loop rows
+      for (i = j; i < rows; i++) {
+        // data @ i, j
+        var v = data[i][j];
+        // absolute value
+        var absv = abs(v);
+        // value is greater than pivote value
+        if (larger(absv, pabsv)) {
+          // store row
+          pi = i;
+          // update max value
+          pabsv = absv;
+          // value @ [j, j]
+          vjj = v;
+        }
+      }
+      // swap rows (j <-> pi)
+      if (j !== pi) {
+        // swap values j <-> pi in p
+        p[j] = [p[pi], p[pi] = p[j]][0];
+        // swap j <-> pi in data
+        DenseMatrix._swapRows(j, pi, data);
+      }
+      // check column is in lower triangular matrix
+      if (j < rows) {
+        // loop rows (lower triangular matrix)
+        for (i = j + 1; i < rows; i++) {
+          // value @ i, j
+          var vij = data[i][j];
+          if (!equalScalar(vij, 0)) {
+            // update data
+            data[i][j] = divideScalar(data[i][j], vjj);
+          }
+        }
+      }
+    }
+    // loop columns
+    for (j = 0; j < columns; j++) {
+      // loop rows
+      for (i = 0; i < rows; i++) {
+        // initialize row in arrays
+        if (j === 0) {
+          // check row exists in upper triangular matrix
+          if (i < columns) {
+            // U
+            udata[i] = [];
+          }
+          // L
+          ldata[i] = [];
+        }
+        // check we are in the upper triangular matrix
+        if (i < j) {
+          // check row exists in upper triangular matrix
+          if (i < columns) {
+            // U
+            udata[i][j] = data[i][j];
+          }
+          // check column exists in lower triangular matrix
+          if (j < rows) {
+            // L
+            ldata[i][j] = 0;
+          }
+          continue;
+        }
+        // diagonal value
+        if (i === j) {
+          // check row exists in upper triangular matrix
+          if (i < columns) {
+            // U
+            udata[i][j] = data[i][j];
+          }
+          // check column exists in lower triangular matrix
+          if (j < rows) {
+            // L
+            ldata[i][j] = 1;
+          }
+          continue;
+        }
+        // check row exists in upper triangular matrix
+        if (i < columns) {
+          // U
+          udata[i][j] = 0;
+        }
+        // check column exists in lower triangular matrix
+        if (j < rows) {
+          // L
+          ldata[i][j] = data[i][j];
+        }
+      }
+    }
+    // l matrix
+    var l = new DenseMatrix({
+      data: ldata,
+      size: lsize
+    });
+    // u matrix
+    var u = new DenseMatrix({
+      data: udata,
+      size: usize
+    });
+    // p vector
+    var pv = [];
+    for (i = 0, n = p.length; i < n; i++) {
+      pv[p[i]] = i;
+    }
+    // return matrices
+    return {
+      L: l,
+      U: u,
+      p: pv,
+      toString: function toString() {
+        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];
+    // minimum rows and columns
+    var 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;
+    // l matrix arrays
+    var lvalues = [];
+    var lindex = [];
+    var lptr = [];
+    var lsize = [rows, n];
+    // u matrix arrays
+    var uvalues = [];
+    var uindex = [];
+    var uptr = [];
+    var usize = [n, columns];
+    // vars
+    var i, j, k;
+    // permutation vectors, (current index -> original index) and (original index -> current index)
+    var pvCo = [];
+    var 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) {
+      // find pv indeces getting data from x and y
+      var kx = pvOc[x];
+      var ky = pvOc[y];
+      // update permutation vector current -> original
+      pvCo[kx] = y;
+      pvCo[ky] = x;
+      // update permutation vector original -> current
+      pvOc[x] = ky;
+      pvOc[y] = kx;
+    };
+    // loop columns
+    var _loop = function _loop() {
+      // sparse accumulator
+      var spa = new Spa();
+      // check lower triangular matrix has a value @ column j
+      if (j < rows) {
+        // update ptr
+        lptr.push(lvalues.length);
+        // first value in j column for lower triangular matrix
+        lvalues.push(1);
+        lindex.push(j);
+      }
+      // 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];
+      // copy column j into sparse accumulator
+      for (k = k0; k < k1; k++) {
+        // row
+        i = index[k];
+        // copy column values into sparse accumulator (use permutation vector)
+        spa.set(pvCo[i], values[k]);
+      }
+      // skip first column in upper triangular matrix
+      if (j > 0) {
+        // loop rows in column j (above diagonal)
+        spa.forEach(0, j - 1, function (k, vkj) {
+          // loop rows in column k (L)
+          SparseMatrix._forEachRow(k, lvalues, lindex, lptr, function (i, vik) {
+            // check row is below k
+            if (i > k) {
+              // update spa value
+              spa.accumulate(i, unaryMinus(multiplyScalar(vik, vkj)));
+            }
+          });
+        });
+      }
+      // row with larger value in spa, row >= j
+      var pi = j;
+      var vjj = spa.get(j);
+      var 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);
+        // value is greater than pivote value
+        if (larger(absv, pabsv)) {
+          // store row
+          pi = x;
+          // update max value
+          pabsv = absv;
+          // value @ [j, j]
+          vjj = v;
+        }
+      });
+      // swap rows (j <-> pi)
+      if (j !== pi) {
+        // swap values j <-> pi in L
+        SparseMatrix._swapRows(j, pi, lsize[1], lvalues, lindex, lptr);
+        // swap values j <-> pi in U
+        SparseMatrix._swapRows(j, pi, usize[1], uvalues, uindex, uptr);
+        // swap values in spa
+        spa.swap(j, pi);
+        // update permutation vector (swap values @ j, pi)
+        swapIndeces(j, pi);
+      }
+      // loop values in spa (order by row)
+      spa.forEach(0, rows - 1, function (x, v) {
+        // check we are above diagonal
+        if (x <= j) {
+          // update upper triangular matrix
+          uvalues.push(v);
+          uindex.push(x);
+        } else {
+          // update value
+          v = divideScalar(v, vjj);
+          // check value is non zero
+          if (!equalScalar(v, 0)) {
+            // update lower triangular matrix
+            lvalues.push(v);
+            lindex.push(x);
+          }
+        }
+      });
+    };
+    for (j = 0; j < columns; j++) {
+      _loop();
+    }
+    // update ptrs
+    uptr.push(uvalues.length);
+    lptr.push(lvalues.length);
+
+    // return matrices
+    return {
+      L: new SparseMatrix({
+        values: lvalues,
+        index: lindex,
+        ptr: lptr,
+        size: lsize
+      }),
+      U: new SparseMatrix({
+        values: uvalues,
+        index: uindex,
+        ptr: uptr,
+        size: usize
+      }),
+      p: pvCo,
+      toString: function toString() {
+        return 'L: ' + this.L.toString() + '\nU: ' + this.U.toString() + '\nP: ' + this.p;
+      }
+    };
+  }
+});
+exports.createLup = createLup;

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

@@ -0,0 +1,228 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+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', 'subtract', 'complex'];
+var 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,
+    subtract = _ref.subtract,
+    complex = _ref.complex;
+  /**
+   * Calculate the Matrix QR decomposition. Matrix `A` is decomposed in
+   * two matrices (`Q`, `R`) where `Q` is an
+   * orthogonal matrix and `R` is an upper triangular matrix.
+   *
+   * Syntax:
+   *
+   *    math.qr(A)
+   *
+   * Example:
+   *
+   *    const m = [
+   *      [1, -1,  4],
+   *      [1,  4, -2],
+   *      [1,  4,  2],
+   *      [1,  -1, 0]
+   *    ]
+   *    const result = math.qr(m)
+   *    // r = {
+   *    //   Q: [
+   *    //     [0.5, -0.5,   0.5],
+   *    //     [0.5,  0.5,  -0.5],
+   *    //     [0.5,  0.5,   0.5],
+   *    //     [0.5, -0.5,  -0.5],
+   *    //   ],
+   *    //   R: [
+   *    //     [2, 3,  2],
+   *    //     [0, 5, -2],
+   *    //     [0, 0,  4],
+   *    //     [0, 0,  0]
+   *    //   ]
+   *    // }
+   *
+   * See also:
+   *
+   *    lup, lusolve
+   *
+   * @param {Matrix | Array} A    A two dimensional matrix or array
+   * for which to get the QR decomposition.
+   *
+   * @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 _denseQR(m);
+    },
+    SparseMatrix: function SparseMatrix(m) {
+      return _sparseQR(m);
+    },
+    Array: function Array(a) {
+      // create dense matrix from array
+      var m = matrix(a);
+      // lup, use matrix implementation
+      var r = _denseQR(m);
+      // result
+      return {
+        Q: r.Q.valueOf(),
+        R: r.R.valueOf()
+      };
+    }
+  }), {
+    _denseQRimpl: _denseQRimpl
+  });
+  function _denseQRimpl(m) {
+    // rows & columns (m x n)
+    var rows = m._size[0]; // m
+    var cols = m._size[1]; // n
+
+    var Q = identity([rows], 'dense');
+    var Qdata = Q._data;
+    var R = m.clone();
+    var Rdata = R._data;
+
+    // vars
+    var i, j, k;
+    var w = zeros([rows], '');
+    for (k = 0; k < Math.min(cols, rows); ++k) {
+      /*
+       * **k-th Household matrix**
+       *
+       * The matrix I - 2*v*transpose(v)
+       * x     = first column of A
+       * x1    = first element of x
+       * alpha = x1 / |x1| * |x|
+       * e1    = tranpose([1, 0, 0, ...])
+       * u     = x - alpha * e1
+       * v     = u / |u|
+       *
+       * Household matrix = I - 2 * v * tranpose(v)
+       *
+       *  * Initially Q = I and R = A.
+       *  * Household matrix is a reflection in a plane normal to v which
+       *    will zero out all but the top right element in R.
+       *  * Appplying reflection to both Q and R will not change product.
+       *  * Repeat this process on the (1,1) minor to get R as an upper
+       *    triangular matrix.
+       *  * Reflections leave the magnitude of the columns of Q unchanged
+       *    so Q remains othoganal.
+       *
+       */
+
+      var pivot = Rdata[k][k];
+      var sgn = unaryMinus(equal(pivot, 0) ? 1 : sign(pivot));
+      var conjSgn = conj(sgn);
+      var 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));
+      if (!isZero(alpha)) {
+        // first element in vector u
+        var u1 = subtract(pivot, alpha);
+
+        // w = v * u1 / |u|    (only elements k to (rows-1) are used)
+        w[k] = 1;
+        for (i = k + 1; i < rows; i++) {
+          w[i] = divideScalar(Rdata[i][k], u1);
+        }
+
+        // tau = - conj(u1 / alpha)
+        var tau = unaryMinus(conj(divideScalar(u1, alpha)));
+        var s = void 0;
+
+        /*
+         * tau and w have been choosen so that
+         *
+         * 2 * v * tranpose(v) = tau * w * tranpose(w)
+         */
+
+        /*
+         * -- calculate R = R - tau * w * tranpose(w) * R --
+         * Only do calculation with rows k to (rows-1)
+         * Additionally columns 0 to (k-1) will not be changed by this
+         *   multiplication so do not bother recalculating them
+         */
+        for (j = k; j < cols; j++) {
+          s = 0.0;
+
+          // calculate jth element of [tranpose(w) * R]
+          for (i = k; i < rows; i++) {
+            s = addScalar(s, multiplyScalar(conj(w[i]), Rdata[i][j]));
+          }
+
+          // calculate the jth element of [tau * transpose(w) * R]
+          s = multiplyScalar(s, tau);
+          for (i = k; i < rows; i++) {
+            Rdata[i][j] = multiplyScalar(subtract(Rdata[i][j], multiplyScalar(w[i], s)), conjSgn);
+          }
+        }
+        /*
+         * -- calculate Q = Q - tau * Q * w * transpose(w) --
+         * Q is a square matrix (rows x rows)
+         * Only do calculation with columns k to (rows-1)
+         * Additionally rows 0 to (k-1) will not be changed by this
+         *   multiplication so do not bother recalculating them
+         */
+        for (i = 0; i < rows; i++) {
+          s = 0.0;
+
+          // calculate ith element of [Q * w]
+          for (j = k; j < rows; j++) {
+            s = addScalar(s, multiplyScalar(Qdata[i][j], w[j]));
+          }
+
+          // calculate the ith element of [tau * Q * w]
+          s = multiplyScalar(s, tau);
+          for (j = k; j < rows; ++j) {
+            Qdata[i][j] = divideScalar(subtract(Qdata[i][j], multiplyScalar(s, conj(w[j]))), conjSgn);
+          }
+        }
+      }
+    }
+
+    // return matrices
+    return {
+      Q: Q,
+      R: R,
+      toString: function toString() {
+        return 'Q: ' + this.Q.toString() + '\nR: ' + this.R.toString();
+      }
+    };
+  }
+  function _denseQR(m) {
+    var ret = _denseQRimpl(m);
+    var 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) {
+          Rdata[i][j] = zero;
+        }
+      }
+    }
+    return ret;
+  }
+  function _sparseQR(m) {
+    throw new Error('qr not implemented for sparse matrices yet');
+  }
+});
+exports.createQr = createQr;

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

@@ -0,0 +1,75 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createSchur = void 0;
+var _factory = require("../../../utils/factory.js");
+var name = 'schur';
+var dependencies = ['typed', 'matrix', 'identity', 'multiply', 'qr', 'norm', 'subtract'];
+var 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;
+  /**
+   *
+   * Performs a real Schur decomposition of the real matrix A = UTU' where U is orthogonal
+   * and T is upper quasi-triangular.
+   * https://en.wikipedia.org/wiki/Schur_decomposition
+   *
+   * Syntax:
+   *
+   *     math.schur(A)
+   *
+   * Examples:
+   *
+   *     const A = [[1, 0], [-4, 3]]
+   *     math.schur(A) // returns {T: [[3, 4], [0, 1]], R: [[0, 1], [-1, 0]]}
+   *
+   * See also:
+   *
+   *     sylvester, lyap, qr
+   *
+   * @param {Array | Matrix} A  Matrix A
+   * @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));
+      return {
+        U: r.U.valueOf(),
+        T: r.T.valueOf()
+      };
+    },
+    Matrix: function Matrix(X) {
+      return _schur(X);
+    }
+  });
+  function _schur(X) {
+    var n = X.size()[0];
+    var A = X;
+    var U = identity(n);
+    var k = 0;
+    var A0;
+    do {
+      A0 = A;
+      var QR = qr(A);
+      var Q = QR.Q;
+      var R = QR.R;
+      A = multiply(R, Q);
+      U = multiply(U, Q);
+      if (k++ > 100) {
+        break;
+      }
+    } while (norm(subtract(A, A0)) > 1e-4);
+    return {
+      U: U,
+      T: A
+    };
+  }
+});
+exports.createSchur = createSchur;