ml-matrix 6.1.2 → 6.4.1

package/src/dc/nipals.js

@@ -0,0 +1,135 @@
+import WrapperMatrix2D from '../wrap/WrapperMatrix2D';
+import Matrix from '../matrix';
+
+export default class nipals {
+  constructor(X, options = {}) {
+    X = WrapperMatrix2D.checkMatrix(X);
+    let { Y } = options;
+    const {
+      scaleScores = false,
+      maxIterations = 1000,
+      terminationCriteria = 1e-10,
+    } = options;
+
+    let u;
+    if (Y) {
+      if (Array.isArray(Y) && typeof Y[0] === 'number') {
+        Y = Matrix.columnVector(Y);
+      } else {
+        Y = WrapperMatrix2D.checkMatrix(Y);
+      }
+      if (!Y.isColumnVector() || Y.rows !== X.rows) {
+        throw new Error('Y must be a column vector of length X.rows');
+      }
+      u = Y;
+    } else {
+      u = X.getColumnVector(0);
+    }
+
+    let diff = 1;
+    let t, q, w, tOld;
+
+    for (
+      let counter = 0;
+      counter < maxIterations && diff > terminationCriteria;
+      counter++
+    ) {
+      w = X.transpose()
+        .mmul(u)
+        .div(
+          u
+            .transpose()
+            .mmul(u)
+            .get(0, 0),
+        );
+      w = w.div(w.norm());
+
+      t = X.mmul(w).div(
+        w
+          .transpose()
+          .mmul(w)
+          .get(0, 0),
+      );
+
+      if (counter > 0) {
+        diff = t
+          .clone()
+          .sub(tOld)
+          .pow(2)
+          .sum();
+      }
+      tOld = t.clone();
+
+      if (Y) {
+        q = Y.transpose()
+          .mmul(t)
+          .div(
+            t
+              .transpose()
+              .mmul(t)
+              .get(0, 0),
+          );
+        q = q.div(q.norm());
+
+        u = Y.mmul(q).div(
+          q
+            .transpose()
+            .mmul(q)
+            .get(0, 0),
+        );
+      } else {
+        u = t;
+      }
+    }
+
+    if (Y) {
+      let p = X.transpose()
+        .mmul(t)
+        .div(
+          t
+            .transpose()
+            .mmul(t)
+            .get(0, 0),
+        );
+      p = p.div(p.norm());
+      let xResidual = X.clone().sub(t.clone().mmul(p.transpose()));
+      let residual = u
+        .transpose()
+        .mmul(t)
+        .div(
+          t
+            .transpose()
+            .mmul(t)
+            .get(0, 0),
+        );
+      let yResidual = Y.clone().sub(
+        t
+          .clone()
+          .mulS(residual.get(0, 0))
+          .mmul(q.transpose()),
+      );
+
+      this.t = t;
+      this.p = p.transpose();
+      this.w = w.transpose();
+      this.q = q;
+      this.u = u;
+      this.s = t.transpose().mmul(t);
+      this.xResidual = xResidual;
+      this.yResidual = yResidual;
+      this.betas = residual;
+    } else {
+      this.w = w.transpose();
+      this.s = t
+        .transpose()
+        .mmul(t)
+        .sqrt();
+      if (scaleScores) {
+        this.t = t.clone().div(this.s.get(0, 0));
+      } else {
+        this.t = t;
+      }
+      this.xResidual = X.sub(t.mmul(w.transpose()));
+    }
+  }
+}

package/src/dc/qr.js

@@ -7,14 +7,14 @@ export default class QrDecomposition {
   constructor(value) {
     value = WrapperMatrix2D.checkMatrix(value);
 
-    var qr = value.clone();
-    var m = value.rows;
-    var n = value.columns;
-    var rdiag = new Float64Array(n);
-    var i, j, k, s;
+    let qr = value.clone();
+    let m = value.rows;
+    let n = value.columns;
+    let rdiag = new Float64Array(n);
+    let i, j, k, s;
 
     for (k = 0; k < n; k++) {
-      var nrm = 0;
+      let nrm = 0;
       for (i = k; i < m; i++) {
         nrm = hypotenuse(nrm, qr.get(i, k));
       }
@@ -47,8 +47,8 @@ export default class QrDecomposition {
   solve(value) {
     value = Matrix.checkMatrix(value);
 
-    var qr = this.QR;
-    var m = qr.rows;
+    let qr = this.QR;
+    let m = qr.rows;
 
     if (value.rows !== m) {
       throw new Error('Matrix row dimensions must agree');
@@ -57,10 +57,10 @@ export default class QrDecomposition {
       throw new Error('Matrix is rank deficient');
     }
 
-    var count = value.columns;
-    var X = value.clone();
-    var n = qr.columns;
-    var i, j, k, s;
+    let count = value.columns;
+    let X = value.clone();
+    let n = qr.columns;
+    let i, j, k, s;
 
     for (k = 0; k < n; k++) {
       for (j = 0; j < count; j++) {
@@ -89,8 +89,8 @@ export default class QrDecomposition {
   }
 
   isFullRank() {
-    var columns = this.QR.columns;
-    for (var i = 0; i < columns; i++) {
+    let columns = this.QR.columns;
+    for (let i = 0; i < columns; i++) {
       if (this.Rdiag[i] === 0) {
         return false;
       }
@@ -99,10 +99,10 @@ export default class QrDecomposition {
   }
 
   get upperTriangularMatrix() {
-    var qr = this.QR;
-    var n = qr.columns;
-    var X = new Matrix(n, n);
-    var i, j;
+    let qr = this.QR;
+    let n = qr.columns;
+    let X = new Matrix(n, n);
+    let i, j;
     for (i = 0; i < n; i++) {
       for (j = 0; j < n; j++) {
         if (i < j) {
@@ -118,11 +118,11 @@ export default class QrDecomposition {
   }
 
   get orthogonalMatrix() {
-    var qr = this.QR;
-    var rows = qr.rows;
-    var columns = qr.columns;
-    var X = new Matrix(rows, columns);
-    var i, j, k, s;
+    let qr = this.QR;
+    let rows = qr.rows;
+    let columns = qr.columns;
+    let X = new Matrix(rows, columns);
+    let i, j, k, s;
 
     for (k = columns - 1; k >= 0; k--) {
       for (i = 0; i < rows; i++) {
@@ -136,7 +136,7 @@ export default class QrDecomposition {
             s += qr.get(i, k) * X.get(i, j);
           }
 
-          s = -s / qr[k][k];
+          s = -s / qr.get(k, k);
 
           for (i = k; i < rows; i++) {
             X.set(i, j, X.get(i, j) + s * qr.get(i, k));

package/src/dc/svd.js

@@ -7,33 +7,33 @@ export default class SingularValueDecomposition {
   constructor(value, options = {}) {
     value = WrapperMatrix2D.checkMatrix(value);
 
-    var m = value.rows;
-    var n = value.columns;
+    let m = value.rows;
+    let n = value.columns;
 
     const {
       computeLeftSingularVectors = true,
       computeRightSingularVectors = true,
-      autoTranspose = false
+      autoTranspose = false,
     } = options;
 
-    var wantu = Boolean(computeLeftSingularVectors);
-    var wantv = Boolean(computeRightSingularVectors);
+    let wantu = Boolean(computeLeftSingularVectors);
+    let wantv = Boolean(computeRightSingularVectors);
 
-    var swapped = false;
-    var a;
+    let swapped = false;
+    let a;
     if (m < n) {
       if (!autoTranspose) {
         a = value.clone();
         // eslint-disable-next-line no-console
         console.warn(
-          'Computing SVD on a matrix with more columns than rows. Consider enabling autoTranspose'
+          'Computing SVD on a matrix with more columns than rows. Consider enabling autoTranspose',
         );
       } else {
         a = value.transpose();
         m = a.rows;
         n = a.columns;
         swapped = true;
-        var aux = wantu;
+        let aux = wantu;
         wantu = wantv;
         wantv = aux;
       }
@@ -41,21 +41,21 @@ export default class SingularValueDecomposition {
       a = value.clone();
     }
 
-    var nu = Math.min(m, n);
-    var ni = Math.min(m + 1, n);
-    var s = new Float64Array(ni);
-    var U = new Matrix(m, nu);
-    var V = new Matrix(n, n);
+    let nu = Math.min(m, n);
+    let ni = Math.min(m + 1, n);
+    let s = new Float64Array(ni);
+    let U = new Matrix(m, nu);
+    let V = new Matrix(n, n);
 
-    var e = new Float64Array(n);
-    var work = new Float64Array(m);
+    let e = new Float64Array(n);
+    let work = new Float64Array(m);
 
-    var si = new Float64Array(ni);
+    let si = new Float64Array(ni);
     for (let i = 0; i < ni; i++) si[i] = i;
 
-    var nct = Math.min(m - 1, n);
-    var nrt = Math.max(0, Math.min(n - 2, m));
-    var mrc = Math.max(nct, nrt);
+    let nct = Math.min(m - 1, n);
+    let nrt = Math.max(0, Math.min(n - 2, m));
+    let mrc = Math.max(nct, nrt);
 
     for (let k = 0; k < mrc; k++) {
       if (k < nct) {
@@ -202,9 +202,9 @@ export default class SingularValueDecomposition {
       }
     }
 
-    var pp = p - 1;
-    var iter = 0;
-    var eps = Number.EPSILON;
+    let pp = p - 1;
+    let iter = 0;
+    let eps = Number.EPSILON;
     while (p > 0) {
       let k, kase;
       for (k = p - 2; k >= -1; k--) {
@@ -295,7 +295,7 @@ export default class SingularValueDecomposition {
             Math.abs(s[p - 2]),
             Math.abs(e[p - 2]),
             Math.abs(s[k]),
-            Math.abs(e[k])
+            Math.abs(e[k]),
           );
           const sp = s[p - 1] / scale;
           const spm1 = s[p - 2] / scale;
@@ -396,7 +396,7 @@ export default class SingularValueDecomposition {
     }
 
     if (swapped) {
-      var tmp = V;
+      let tmp = V;
       V = U;
       U = tmp;
     }
@@ -409,10 +409,10 @@ export default class SingularValueDecomposition {
   }
 
   solve(value) {
-    var Y = value;
-    var e = this.threshold;
-    var scols = this.s.length;
-    var Ls = Matrix.zeros(scols, scols);
+    let Y = value;
+    let e = this.threshold;
+    let scols = this.s.length;
+    let Ls = Matrix.zeros(scols, scols);
 
     for (let i = 0; i < scols; i++) {
       if (Math.abs(this.s[i]) <= e) {
@@ -422,13 +422,13 @@ export default class SingularValueDecomposition {
       }
     }
 
-    var U = this.U;
-    var V = this.rightSingularVectors;
+    let U = this.U;
+    let V = this.rightSingularVectors;
 
-    var VL = V.mmul(Ls);
-    var vrows = V.rows;
-    var urows = U.rows;
-    var VLU = Matrix.zeros(vrows, urows);
+    let VL = V.mmul(Ls);
+    let vrows = V.rows;
+    let urows = U.rows;
+    let VLU = Matrix.zeros(vrows, urows);
 
     for (let i = 0; i < vrows; i++) {
       for (let j = 0; j < urows; j++) {
@@ -448,11 +448,11 @@ export default class SingularValueDecomposition {
   }
 
   inverse() {
-    var V = this.V;
-    var e = this.threshold;
-    var vrows = V.rows;
-    var vcols = V.columns;
-    var X = new Matrix(vrows, this.s.length);
+    let V = this.V;
+    let e = this.threshold;
+    let vrows = V.rows;
+    let vcols = V.columns;
+    let X = new Matrix(vrows, this.s.length);
 
     for (let i = 0; i < vrows; i++) {
       for (let j = 0; j < vcols; j++) {
@@ -462,11 +462,11 @@ export default class SingularValueDecomposition {
       }
     }
 
-    var U = this.U;
+    let U = this.U;
 
-    var urows = U.rows;
-    var ucols = U.columns;
-    var Y = new Matrix(vrows, urows);
+    let urows = U.rows;
+    let ucols = U.columns;
+    let Y = new Matrix(vrows, urows);
 
     for (let i = 0; i < vrows; i++) {
       for (let j = 0; j < urows; j++) {
@@ -490,10 +490,10 @@ export default class SingularValueDecomposition {
   }
 
   get rank() {
-    var tol = Math.max(this.m, this.n) * this.s[0] * Number.EPSILON;
-    var r = 0;
-    var s = this.s;
-    for (var i = 0, ii = s.length; i < ii; i++) {
+    let tol = Math.max(this.m, this.n) * this.s[0] * Number.EPSILON;
+    let r = 0;
+    let s = this.s;
+    for (let i = 0, ii = s.length; i < ii; i++) {
       if (s[i] > tol) {
         r++;
       }

package/src/dc/util.js

@@ -1,5 +1,5 @@
 export function hypotenuse(a, b) {
-  var r = 0;
+  let r = 0;
   if (Math.abs(a) > Math.abs(b)) {
     r = b / a;
     return Math.abs(a) * Math.sqrt(1 + r * r);

package/src/determinant.js

@@ -5,7 +5,7 @@ import MatrixSelectionView from './views/selection';
 export function determinant(matrix) {
   matrix = Matrix.checkMatrix(matrix);
   if (matrix.isSquare()) {
-    var a, b, c, d;
+    let a, b, c, d;
     if (matrix.columns === 2) {
       // 2 x 2 matrix
       a = matrix.get(0, 0);
@@ -16,7 +16,7 @@ export function determinant(matrix) {
       return a * d - b * c;
     } else if (matrix.columns === 3) {
       // 3 x 3 matrix
-      var subMatrix0, subMatrix1, subMatrix2;
+      let subMatrix0, subMatrix1, subMatrix2;
       subMatrix0 = new MatrixSelectionView(matrix, [1, 2], [1, 2]);
       subMatrix1 = new MatrixSelectionView(matrix, [1, 2], [0, 2]);
       subMatrix2 = new MatrixSelectionView(matrix, [1, 2], [0, 1]);

package/src/index.js

@@ -14,15 +14,16 @@ export { correlation } from './correlation';
 
 export {
   default as SingularValueDecomposition,
-  default as SVD
+  default as SVD,
 } from './dc/svd.js';
 export {
   default as EigenvalueDecomposition,
-  default as EVD
+  default as EVD,
 } from './dc/evd.js';
 export {
   default as CholeskyDecomposition,
-  default as CHO
+  default as CHO,
 } from './dc/cholesky.js';
 export { default as LuDecomposition, default as LU } from './dc/lu.js';
 export { default as QrDecomposition, default as QR } from './dc/qr.js';
+export { default as Nipals, default as NIPALS } from './dc/nipals.js';

package/src/inspect.js

@@ -19,9 +19,9 @@ function inspectData(matrix, indent) {
   const maxI = Math.min(rows, maxRows);
   const maxJ = Math.min(columns, maxColumns);
   const result = [];
-  for (var i = 0; i < maxI; i++) {
+  for (let i = 0; i < maxI; i++) {
     let line = [];
-    for (var j = 0; j < maxJ; j++) {
+    for (let j = 0; j < maxJ; j++) {
       line.push(formatNumber(matrix.get(i, j)));
     }
     result.push(`${line.join(' ')}`);

package/src/linearDependencies.js

@@ -2,8 +2,8 @@ import Matrix from './matrix';
 import SingularValueDecomposition from './dc/svd';
 
 function xrange(n, exception) {
-  var range = [];
-  for (var i = 0; i < n; i++) {
+  let range = [];
+  for (let i = 0; i < n; i++) {
     if (i !== exception) {
       range.push(i);
     }
@@ -16,13 +16,13 @@ function dependenciesOneRow(
   matrix,
   index,
   thresholdValue = 10e-10,
-  thresholdError = 10e-10
+  thresholdError = 10e-10,
 ) {
   if (error > thresholdError) {
     return new Array(matrix.rows + 1).fill(0);
   } else {
-    var returnArray = matrix.addRow(index, [0]);
-    for (var i = 0; i < returnArray.rows; i++) {
+    let returnArray = matrix.addRow(index, [0]);
+    for (let i = 0; i < returnArray.rows; i++) {
       if (Math.abs(returnArray.get(i, 0)) < thresholdValue) {
         returnArray.set(i, 0, 0);
       }
@@ -35,20 +35,20 @@ export function linearDependencies(matrix, options = {}) {
   const { thresholdValue = 10e-10, thresholdError = 10e-10 } = options;
   matrix = Matrix.checkMatrix(matrix);
 
-  var n = matrix.rows;
-  var results = new Matrix(n, n);
+  let n = matrix.rows;
+  let results = new Matrix(n, n);
 
-  for (var i = 0; i < n; i++) {
-    var b = Matrix.columnVector(matrix.getRow(i));
-    var Abis = matrix.subMatrixRow(xrange(n, i)).transpose();
-    var svd = new SingularValueDecomposition(Abis);
-    var x = svd.solve(b);
-    var error = Matrix.sub(b, Abis.mmul(x))
+  for (let i = 0; i < n; i++) {
+    let b = Matrix.columnVector(matrix.getRow(i));
+    let Abis = matrix.subMatrixRow(xrange(n, i)).transpose();
+    let svd = new SingularValueDecomposition(Abis);
+    let x = svd.solve(b);
+    let error = Matrix.sub(b, Abis.mmul(x))
       .abs()
       .max();
     results.setRow(
       i,
-      dependenciesOneRow(error, x, i, thresholdValue, thresholdError)
+      dependenciesOneRow(error, x, i, thresholdValue, thresholdError),
     );
   }
   return results;