mathjs 11.2.1 → 11.3.0

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

@@ -18,7 +18,6 @@ export var createLup = /* #__PURE__ */factory(name, dependencies, _ref => {
     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`
@@ -54,11 +53,10 @@ export var createLup = /* #__PURE__ */factory(name, dependencies, _ref => {
     },
     Array: function Array(a) {
       // create dense matrix from array
-      var m = matrix(a); // lup, use matrix implementation
-
-      var r = _denseLUP(m); // result
-
-
+      var m = matrix(a);
+      // lup, use matrix implementation
+      var r = _denseLUP(m);
+      // result
       return {
         L: r.L.valueOf(),
         U: r.U.valueOf(),
@@ -66,95 +64,86 @@ export var createLup = /* #__PURE__ */factory(name, dependencies, _ref => {
       };
     }
   });
-
   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 = clone(m._data); // l matrix arrays
-
+    var columns = m._size[1];
+    // minimum rows and columns
+    var n = Math.min(rows, columns);
+    // matrix array, clone original data
+    var data = clone(m._data);
+    // l matrix arrays
     var ldata = [];
-    var lsize = [rows, n]; // u matrix arrays
-
+    var lsize = [rows, n];
+    // u matrix arrays
     var udata = [];
-    var usize = [n, columns]; // vars
-
-    var i, j, k; // permutation vector
-
+    var usize = [n, columns];
+    // vars
+    var i, j, k;
+    // permutation vector
     var p = [];
-
     for (i = 0; i < rows; i++) {
       p[i] = i;
-    } // loop columns
-
-
+    }
+    // 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
-
+          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
-
-
+      }
+      // row with larger value in cvector, row >= j
       var pi = j;
       var pabsv = 0;
-      var vjj = 0; // loop rows
-
+      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
-
+        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]
-
+          pi = i;
+          // update max value
+          pabsv = absv;
+          // value @ [j, j]
           vjj = v;
         }
-      } // swap rows (j <-> pi)
-
-
+      }
+      // 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
-
+        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
-
-
+      }
+      // 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
-
-
+    }
+    // loop columns
     for (j = 0; j < columns; j++) {
       // loop rows
       for (i = 0; i < rows; i++) {
@@ -164,78 +153,66 @@ export var createLup = /* #__PURE__ */factory(name, dependencies, _ref => {
           if (i < columns) {
             // U
             udata[i] = [];
-          } // L
-
-
+          }
+          // L
           ldata[i] = [];
-        } // check we are in the upper triangular matrix
-
-
+        }
+        // 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
-
-
+          }
+          // check column exists in lower triangular matrix
           if (j < rows) {
             // L
             ldata[i][j] = 0;
           }
-
           continue;
-        } // diagonal value
-
-
+        }
+        // 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
-
-
+          }
+          // check column exists in lower triangular matrix
           if (j < rows) {
             // L
             ldata[i][j] = 1;
           }
-
           continue;
-        } // check row exists in upper triangular matrix
-
-
+        }
+        // check row exists in upper triangular matrix
         if (i < columns) {
           // U
           udata[i][j] = 0;
-        } // check column exists in lower triangular matrix
-
-
+        }
+        // check column exists in lower triangular matrix
         if (j < rows) {
           // L
           ldata[i][j] = data[i][j];
         }
       }
-    } // l matrix
-
-
+    }
+    // l matrix
     var l = new DenseMatrix({
       data: ldata,
       size: lsize
-    }); // u matrix
-
+    });
+    // u matrix
     var u = new DenseMatrix({
       data: udata,
       size: usize
-    }); // p vector
-
+    });
+    // p vector
     var pv = [];
-
     for (i = 0, n = p.length; i < n; i++) {
       pv[p[i]] = i;
-    } // return matrices
-
-
+    }
+    // return matrices
     return {
       L: l,
       U: u,
@@ -245,78 +222,72 @@ export var createLup = /* #__PURE__ */factory(name, dependencies, _ref => {
       }
     };
   }
-
   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 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 ptr = m._ptr;
+    // l matrix arrays
     var lvalues = [];
     var lindex = [];
     var lptr = [];
-    var lsize = [rows, n]; // u matrix arrays
-
+    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 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)!
-
-
+    }
+    // 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
-
+      var ky = pvOc[y];
+      // update permutation vector current -> original
       pvCo[kx] = y;
-      pvCo[ky] = x; // update permutation vector original -> current
-
+      pvCo[ky] = x;
+      // update permutation vector original -> current
       pvOc[x] = ky;
       pvOc[y] = kx;
-    }; // loop columns
-
-
+    };
+    // loop columns
     var _loop = function _loop() {
       // sparse accumulator
-      var spa = new Spa(); // check lower triangular matrix has a value @ column j
-
+      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
-
+        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]
-
+      }
+      // 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
-
+      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)
-
+        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
-
-
+      }
+      // 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) {
@@ -329,41 +300,37 @@ export var createLup = /* #__PURE__ */factory(name, dependencies, _ref => {
             }
           });
         });
-      } // row with larger value in spa, row >= j
-
-
+      }
+      // 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)
-
+      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
-
+        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]
-
+          pi = x;
+          // update max value
+          pabsv = absv;
+          // value @ [j, j]
           vjj = v;
         }
-      }); // swap rows (j <-> pi)
-
+      });
+      // 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)
-
+        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)
-
-
+      }
+      // loop values in spa (order by row)
       spa.forEach(0, rows - 1, function (x, v) {
         // check we are above diagonal
         if (x <= j) {
@@ -372,8 +339,8 @@ export var createLup = /* #__PURE__ */factory(name, dependencies, _ref => {
           uindex.push(x);
         } else {
           // update value
-          v = divideScalar(v, vjj); // check value is non zero
-
+          v = divideScalar(v, vjj);
+          // check value is non zero
           if (!equalScalar(v, 0)) {
             // update lower triangular matrix
             lvalues.push(v);
@@ -382,15 +349,14 @@ export var createLup = /* #__PURE__ */factory(name, dependencies, _ref => {
         }
       });
     };
-
     for (j = 0; j < columns; j++) {
       _loop();
-    } // update ptrs
-
-
+    }
+    // update ptrs
     uptr.push(uvalues.length);
-    lptr.push(lvalues.length); // return matrices
+    lptr.push(lvalues.length);
 
+    // return matrices
     return {
       L: new SparseMatrix({
         values: lvalues,

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

@@ -20,7 +20,6 @@ export var createQr = /* #__PURE__ */factory(name, dependencies, _ref => {
     subtract,
     complex
   } = _ref;
-
   /**
    * Calculate the Matrix QR decomposition. Matrix `A` is decomposed in
    * two matrices (`Q`, `R`) where `Q` is an
@@ -73,11 +72,10 @@ export var createQr = /* #__PURE__ */factory(name, dependencies, _ref => {
     },
     Array: function Array(a) {
       // create dense matrix from array
-      var m = matrix(a); // lup, use matrix implementation
-
-      var r = _denseQR(m); // result
-
-
+      var m = matrix(a);
+      // lup, use matrix implementation
+      var r = _denseQR(m);
+      // result
       return {
         Q: r.Q.valueOf(),
         R: r.R.valueOf()
@@ -86,21 +84,19 @@ export var createQr = /* #__PURE__ */factory(name, dependencies, _ref => {
   }), {
     _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 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**
@@ -125,30 +121,29 @@ export var createQr = /* #__PURE__ */factory(name, dependencies, _ref => {
        *    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)
+        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)
-
+        }
 
+        // tau = - conj(u1 / alpha)
         var tau = unaryMinus(conj(divideScalar(u1, alpha)));
         var s = void 0;
+
         /*
          * tau and w have been choosen so that
          *
@@ -161,17 +156,16 @@ export var createQr = /* #__PURE__ */factory(name, dependencies, _ref => {
          * 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]
+          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]
-
+          }
 
+          // 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);
           }
@@ -183,26 +177,24 @@ export var createQr = /* #__PURE__ */factory(name, dependencies, _ref => {
          * 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]
+          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]
-
+          }
 
+          // 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 matrices
     return {
       Q,
       R,
@@ -211,25 +203,19 @@ export var createQr = /* #__PURE__ */factory(name, dependencies, _ref => {
       }
     };
   }
-
   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');
   }

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

@@ -31,6 +31,7 @@ export var createSlu = /* #__PURE__ */factory(name, dependencies, _ref => {
     largerEq,
     SparseMatrix
   });
+
   /**
    * Calculate the Sparse Matrix LU decomposition with full pivoting. Sparse Matrix `A` is decomposed in two matrices (`L`, `U`) and two permutation vectors (`pinv`, `q`) where
    *
@@ -68,24 +69,24 @@ export var createSlu = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    * @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) {
       // verify order
       if (!isInteger(order) || order < 0 || order > 3) {
         throw new Error('Symbolic Ordering and Analysis order must be an integer number in the interval [0, 3]');
-      } // verify threshold
-
-
+      }
+      // verify threshold
       if (threshold < 0 || threshold > 1) {
         throw new Error('Partial pivoting threshold must be a number from 0 to 1');
-      } // perform symbolic ordering and analysis
-
+      }
 
-      var s = csSqr(order, a, false); // perform lu decomposition
+      // perform symbolic ordering and analysis
+      var s = csSqr(order, a, false);
 
-      var f = csLu(a, s, threshold); // return decomposition
+      // perform lu decomposition
+      var f = csLu(a, s, threshold);
 
+      // return decomposition
       return {
         L: f.L,
         U: f.U,