node-red-contrib-prib-functions 0.19.2 → 0.20.4

package/dataAnalysis/pca.js

@@ -1,32 +1,40 @@
-function PCA() {
+require("./arrayAllRowsSwap");
+require("./arrayForEachRange.js");
+require("./arrayReduceRange.js");
+require("./arrayScale.js");
+require("./arraySwap.js");
+require("./arraySum.js");
+require("./arraySumSquared.js");
+const generatedMatrixFunction = require("./generateMatrixFunction");
+const generateVectorFunction=require("./generateVectorFunction.js")
+
+function PCA() { //Principal Component Analysis 
 }
-PCA.prototype.computeDeviationMatrix=function(matrix) {
-    return this.subtract(matrix, this.scale(this.multiply(this.unitSquareMatrix(matrix.length), matrix), 1 / matrix.length));
+PCA.prototype.rowType=Array;
+PCA.prototype.getDeviationMatrix=function(matrix) {
+    const rows=matrix.length;
+    const onesMatrix=this.getMatrix(rows,rows,1);
+    const scaled=this.scale(this.multiply(onesMatrix, matrix),1/rows)
+    return this.subtract(matrix, scaled);
 }
-PCA.prototype.computeDeviationScores=function(deviation) {
-    return this.multiply(this.transpose(deviation), deviation);
+PCA.prototype.getDeviationScores=function(deviation) {
+    const transposed=this.transpose(deviation)
+    return this.multiply(transposed, deviation);
 }
-PCA.prototype.computeVarianceCovariance=function(devSumOfSquares, sample) {
-    return this.scale(devSumOfSquares, 1 / (devSumOfSquares.length - sample?1:0));
+PCA.prototype.getVarianceCovariance=function(devSumOfSquares, sample) {
+    return this.scale(devSumOfSquares, 1/devSumOfSquares.length);
 }
-PCA.prototype.computeSVD=function((atrix){
-    const result = svd(matrix);
-    const eigenvectors = result.U;
-    const eigenvalues = result.S;
-    return eigenvalues.map((value,i)=>{
-        return {
-            eigenvalue:value,
-            vector:eigenvectors.map((vector,j)=>-vector[i]) //HACK prevent completely negative vectors
-        }
-    });
+PCA.prototype.getVarianceCovarianceSample=function(devSumOfSquares) {
+    const factor=devSumOfSquares.length-1
+    return this.scale(devSumOfSquares, 1/factor);
 }
-//     Get reduced dataset after removing some dimensions
-PCA.prototype.computeAdjustedData=function(data, ...vectorObjs){
+
+PCA.prototype.getAdjustedData=function(data, ...vectorObjs){ //  reduced after removing some dimensions
     const vectors = vectorObjs.map((v)=>v.vector);
-    const matrixMinusMean = this.computeDeviationMatrix(data);
+    const matrixMinusMean = this.getDeviationMatrix(data);
     const adjustedData = this.multiply(vectors, this.transpose(matrixMinusMean));
-    const unit = this.unitSquareMatrix(data.length);
-    const avgData = this.scale(multiply(unit, data), -1 / data.length); //NOTE get the averages to add back
+    const rows=data.length
+    const avgData =this.scale(multiply(this.getMatrix(rows,rows,1),data), -1/rows); //NOTE get the averages to add back
     return {
         adjustedData: adjustedData,
         formattedAdjustedData:formatData(adjustedData, 2),
@@ -35,365 +43,504 @@ PCA.prototype.computeAdjustedData=function(data, ...vectorObjs){
     };
 }
 // Get original data set from reduced data set (decompress)
-PCA.prototype.computeOriginalData=function(adjustedData, vectors, avgData) {
+PCA.prototype.getOriginalData=function(adjustedData, vectors, avgData) {
     const originalWithoutMean = this.transpose(multiply(transpose(vectors), adjustedData));
     const originalWithMean = this.subtract(originalWithoutMean, avgData);
     return {
         originalData: originalWithMean,
         formattedOriginalData: this.formatData(originalWithMean, 2)
     }
-PCA.prototype.computePercentageExplained=function(vectors, ...selected) {
-    const total = vectors.map((v)=>v.eigenvalue).reduce((a,b)=>a+b);
-    const explained = selected.map((v)=>v.eigenvalue).reduce((a,b)=>a+b);
+}
+PCA.prototype.getPercentageExplained=function(vectors, ...selected) {
+    const total = vectors.map((v)=>v.eigenvalue).sum();
+    const explained = selected.map((v)=>v.eigenvalue).sum();
     return (explained / total);
 }
 PCA.prototype.getEigenVectors=function(data) {
-   return this.computeSVD(this.computeVarianceCovariance(this.computeDeviationScores(this.computeDeviationMatrix(data)), false));
+    const deviationMatrix=this.getDeviationMatrix(data);
+    const deviationScores=this.getDeviationScores(deviationMatrix)
+    const matrix=this.getVarianceCovariance(deviationScores)
+    const result = this.svd(matrix);
+    const eigenvectors = result.U;
+    const eigenvalues = result.S;
+    return eigenvalues.map((value,i)=>{
+        return {
+            eigenvalue:value,
+            vector:eigenvectors.map((vector,j)=>-vector[i]) //prevent completely negative vectors
+        }
+    });
 }
-PCA.prototype.analyseTopResult=function(data){
+PCA.prototype.getTopResult=function(data){
     const eigenVectors = this.getEigenVectors(data);
-    const sorted = this.eigenVectors.sort((a, b)=>b.eigenvalue-a.eigenvalue);
+    const sorted = eigenVectors.sort((a, b)=>b.eigenvalue-a.eigenvalue);
     const selected = sorted[0].vector;
-    return this.computeAdjustedData(data, selected);
+    return this.getAdjustedData(data, selected);
 }
 PCA.prototype.formatData=function(data, precision) {
     const factor= Math.pow(10, precision || 2);
     return data.map((d,i)=>d.map((n)=>Math.round(n * factor) / factor))
 }
-PCA.prototype.testMatrix=function(a){
-    if(!a[0] || !a.length) throw Error("Not matrix")
+PCA.prototype.testIsMatrix=(a)=>{
+    if(!(a instanceof Array)) throw Error("Not matrix at row level, found type of "+typeof a)
+    const row=a[0];
+    if(row instanceof Array) return; 
+    if(row instanceof this.rowType) return; 
+    throw Error("Not matrix at column level, found type of "+typeof a[0])
 }
+const sumVector1=generateVectorFunction({
+    code:"returnValue+=vector[index]*matrix[index][col]",
+    args:["matrix","col"],
+    returnValue:0
+})
+const multiplyMatrix=generatedMatrixFunction({
+    code:"setElement(sumVector1(element,bMatrix,columnOffset));",
+    args:["bMatrix"],
+    returnValue:"Object.create(Object.getPrototypeOf(matrix))"
+})
+
 PCA.prototype.multiply=function(a, b){
-    this.testMatrix(a);
-    this.testMatrix(b);
-    if(b.length !== a[0].length) throw new Error('Columns in A should be the same as the number of rows in B');
-    const product = [];
-    for(let i = 0; i < a.length; i++) {
-        product[i] = []; //initialize a new row
-        for (var j = 0; j < b[0].length; j++) {
-            for (var k = 0; k < a[0].length; k++) {
-                (product[i])[j] = !!(product[i])[j] ? (product[i])[j] + (a[i])[k] * (b[k])[j] : (a[i])[k] * (b[k])[j];
-            }
+    this.testIsMatrix(a);
+    this.testIsMatrix(b);
+    const rows=a.length;
+    if(a[0].length !== b.length) throw Error("Non-conformable matrices, left columns: "+a[0].length+" != right rows "+b.length);
+    const columns=b[0].length;
+    const result=this.getMatrix(rows,columns);
+    for(let ri=0;ri<rows;ri++){
+        for(let ci=0;ci<columns;ci++){
+            result[ri][ci]=sumVector1(a[ri],b,ci);
+//            result[ri][ci]=a[ri].reduce((sum,value,rci)=>sum+value*b[rci][ci],0);
         }
     }
-    return product;
+    return result
 }
+
 PCA.prototype.subtract=function(a,b) {
     if(!(a.length === b.length && a[0].length === b[0].length)) throw Error('Both A and B should have the same dimensions');
-    const result=[];
-    for(let i=0;i< a.length;i++){
-        result[i]=[];
-        for (let j = 0; j < b[0].length; j++) {
-            (result[i])[j] = (a[i])[j] - (b[i])[j];
-       }
+    const rows=a.length;
+    const columns=a[0].length;
+    const result=this.getMatrix(rows,columns);
+    for(let ri=0;ri<rows;ri++){
+        for(let ci=0;ci<columns;ci++){
+            result[ri][ci]=a[ri][ci]-b[ri][ci];
+        }
     }
-    return result;
+    return result
 }
-PCA.prototype.scale=function(matrix, factor) {
-    const result = [];
-    for(let i = 0; i < matrix.length; i++) {
-        result[i] = [];
-        for(let j = 0; j < matrix[0].length; j++) {
-            (result[i])[j] = (matrix[i])[j] * factor;
-        }
+function mapMatrix(matrix,callFunction) {
+    if(callFunction)
+        return matrix.map((row,ri)=>row.map((cell,ci)=>callFunction(cell,ri,ci,matrix)));
+    return this.cloneMatrix(matrix);
+};
+
+const mapVector=generateVectorFunction({
+    code:"vector[index]=fromVector[index]",
+    args:["fromVector"],
+});
+
+const cloneVector=generateVectorFunction({
+    code:"returnValue[index]=vector[index]",
+    args:["type=Array"],
+});
+
+function cloneMatrix(matrix){
+    const columns=matrix.length
+    const rows=matrix[0].length
+    const result=new Array(rows)
+    for(let ri=0;ri<rows;ri++){
+        const row=new this.rowType(columns);
+        mapVector(row,matrix[ri]);
+        result[ri]=row;
     }
     return result;
 }
-PCA.prototype.unitSquareMatrix=function(rows) {
-    const result = [];
-    for(let i = 0; i < rows; i++) {
-        result[i] = [];
-        for (var j = 0; j < rows; j++) {
-            (result[i])[j] = 1;
-        }
+const transposeVector=generateVectorFunction({
+    code:"vector[index]=fromVector[index][column]",
+    args:["fromVector","column"],
+});
+//const mapVector=generateVectorFunction("returnValue[index]=vector[index]",[])
+PCA.prototype.map=mapMatrix;
+PCA.prototype.cloneMatrix=cloneMatrix;
+PCA.prototype.mapTranspose=function(matrix) {
+    const columns=matrix.length
+    const rows=matrix[0].length
+    const result=new this.rowType(rows)
+    for(let ri=0;ri<rows;ri++){
+        const row=new this.rowType(columns);
+        transposeVector(row,matrix,ri)
+        result[ri]=row;
     }
     return result;
 }
-PCA.prototype.transpose=function(matrix) {
-    const operated = this.clone(matrix);
-    return operated[0].map((m,c)=>matrix.map((r)=>r[c]));
+PCA.prototype.transpose=PCA.prototype.mapTranspose
+PCA.prototype.forEachRow=function(matrix,callFunction) {
+    matrix.forEach(row,RowIndex=>callFunction(row,rowIndex,matrix))
+    return this
+}
+PCA.prototype.forEachRowColumn=function(matrix,rowIndex,callFunction) {
+    const row=matrix[rowIndex];
+    const columns=row[0].length;
+    for(let columnIndex=0;columnIndex<columns;columnIndex++)
+        callFunction(row[columnIndex],rowIndex,columnIndex,matrix)
+    return this
+}
+
+PCA.prototype.forEachColumn=function(matrix,columnIndex,callFunction) {
+    const rows=matrix.length;
+    for(let rowIndex=0;rowIndex<rows;rowIndex++)
+        callFunction(matrix[rowIndex][columnIndex],rowIndex,columnIndex,matrix)
+    return this
+}
+PCA.prototype.forEachCell=function(matrix,callFunction) {
+    const rows=matrix.length;
+    const columns=matrix[0].length;
+    for(let rowIndex=0;rowIndex<rows;rowIndex++){
+        const row=matrix[rowIndex];
+        for(let columnIndex=0;columnIndex<columns;columnIndex++)
+            callFunction(row[columnIndex],rowIndex,columnIndex,matrix)
+    }
+    return this
 }
-PCA.prototype.clone=function(m) {
-    return m.map(r=>r.map(c=>c));
+PCA.prototype.forEachSetCell=function(matrix,callFunction) {
+    const rows=matrix.length;
+    const columns=matrix[0].length;
+    for(let rowIndex=0;rowIndex<rows;rowIndex++){
+        const row=matrix[rowIndex];
+        for(let columnIndex=0;columnIndex<columns;columnIndex++)
+            row[columnIndex]=callFunction(rowIndex,columnIndex,cell,row,matrix)
+    }
+    return this
 }
-PCA.prototype.svd=function(A) {
-        let temp;
-        const prec = Math.pow(2, -52) // double presision
-        const tolerance = 1.e-64 // precision;
-        const itmax = 50;
-        let c = 0;
-        let i = 0;
-        let j = 0;
-        let k = 0;
-        let l = 0;
-        const u = this.clone(A);
-        const m = u.length;
-        const n = u[0].length;
-        if (m < n) throw "Need more rows than columns"
+PCA.prototype.scale=function(matrix,factor){return this.map(matrix,c=>c*factor)};
 
-        const e = new Array(n); //vector1
-        const q = new Array(n); //vector2
-        for (i = 0; i < n; i++) e[i] = q[i] = 0.0;
-        var v = rep([n, n], 0);
+function getMatrix(rows=2,columns=rows,fill=0) {
+    const matrix=new Array(rows);
+    for(let i=0; i<rows; i++) matrix[i]=new this.rowType(columns).fill(fill);
+    return matrix;
+}
 
-        function pythag(a, b) {
-            a = Math.abs(a)
-            b = Math.abs(b)
-            if(a > b) return a * Math.sqrt(1.0 + (b * b / a / a))
-            if(b == 0.0) return a
-            return b * Math.sqrt(1.0 + (a * a / b / b))
-        }
-        function rep(s, v, k=0) {
-            const n=s[k],
-                ret=Array(n);
-            let i;
-            if(k === s.length - 1) {
-                for(i=n-2; i >= 0; i-=2) {
-                    ret[i+1] = v;
-                    ret[i] = v;
-                }
-                if(i === -1) ret[0] = v;
-                return ret;
-            }
-            const kPlusOne=k++;
-            for (i= n-1; i>=0; i--) {
-                ret[i] = rep(s, v, kPlusOne);
-            }
-            return ret;
-        }
-        let f = 0.0;
-        let g = 0.0;
-        let h = 0.0;
-        let x = 0.0;
-        let y = 0.0;
-        let z = 0.0;
-        let s = 0.0;
+PCA.prototype.getMatrix=getMatrix
 
-        for(i=0; i<n; i++) {
-            e[i] = g; //vector
-            s = 0.0; //sum
-            l = i+1; //stays i+1
-            for(j=i; j<m; j++)
-                s += (u[j][i] * u[j][i]);
-            if(s <= tolerance)
-                g = 0.0;
-            else {
-                f = u[i][i];
-                g = Math.sqrt(s);
-                if(f >= 0.0) g = -g;
-                h = f * g - s
-                u[i][i] = f - g;
-                for(j=l; j<n; j++) {
-                    s = 0.0
-                    for(k=i; k < m; k++)
-                        s += u[k][i] * u[k][j]
-                    f = s / h
-                    for(k=i; k<m; k++)
-                        u[k][j] += f * u[k][i]
-                }
+PCA.prototype.pythag=(a,b)=>{
+    if(b == 0.0) return a
+    const a2 = a**2
+    const b2 = b**2
+    return a > b ? a * Math.sqrt(1.0 + b2/a2) : b * Math.sqrt(1.0 + a2/b2)
+};
+PCA.prototype.rep=function(s,v,k=0){
+    const n=s[k],returnVector=new this.rowType(n).fill(0);
+    if(k === s.length-1){
+        returnVector.fill(v,0,n-1)
+    } else {
+        const kPlusOne=k+1;
+        for(let i=n-1;i>=0;i--) returnVector[i]=this.rep(s,v,kPlusOne);
+    }
+    return returnVector;
+ }
+module.exports = PCA;
+
+PCA.prototype.getDeterminant=function(matrix){
+  const result = this.getDecomposed(matrix);
+  return result.lum.product()*result.toggle;
+}
+PCA.prototype.getDecomposed=function(matrix){
+  // Crout's LU decomposition for matrix determinant and inverse
+  // lum is lower & upper matrix
+  // perm is row permuations vector
+  const rows = matrix.length, rowsMinus1 = rows-1;
+  const perm = new this.rowType(rows).fill(0.0);
+  let toggle = +1; // even (+1) or odd (-1) row permutatuions
+  const result=Object.assign([],matrix);
+  const lum=Object.assign([],matrix);
+
+  for(let ri=0; ri<rows; ++ri) perm[ri]=ri
+  let piv=rows;
+  for(let j=0; j<rowsMinus1; ++j) { 
+    const lumRowJ=lum[j];
+    let max = Math.abs(lumRowJ[j]);
+    for(let ri=j+1; ri<rows; ++ri) {  // pivot index
+      const xrij = Math.abs(lum[ri][j]);
+      if(xrij > max) {
+        max = xrij;
+        piv = ri;
+      }
+    }
+
+    if(piv != j) {
+      lum.swap(piv,j)
+      perm.swap(piv,j);
+      toggle = -toggle;
+    }
+    const xjj = lumRowJ[j];
+    if(xjj !== 0.0) {  
+      for(let i=j+1; i<rows; ++i) {
+        const lumRow=lum[i]
+        const xij = lumRow[j]/xjj;
+        lumRow[j] = xij;
+        for(let ci=0; ci<columns; ++ci) lumRow[ci] -= xij*lumRowJ[ci]
+      }
+    }
+  }
+  return {toggle:toggle,lum:lum,perm:perm}
+}
+
+PCA.prototype.getReduced=function(lum, b){
+  const rows = lum.length, rowsMinus1 = rows-1;
+  const x=new this.rowType(n).fill(0.0)
+  let sum;
+  for(let ri=0; ri<rows; ++ri) x[ri]=b[ri];
+  for(let ri=1; ri<rows; ++ri) {
+    const lumRow=lum[ri];
+    sum=x[ri];
+    for(let ci=0;ci<columns;ci++) sum-=lumRow[ci]*x[ci];
+    x[ri]=sum;
+  }
+  x[rowsMinus1] /= lum[rowsMinus1][rowsMinus1];
+  for (let ri=rows-2; ri>0; --ri) {
+    sum=x[ri];
+    for(let ci=0;ci<columns;ci++) sum-=lumRow[ci]*x[ci];
+    x[ri]=sum/lumRow[ri];
+  }
+  return x;
+}
+
+function svd(matrix) {//singular value decomposition 
+    const eps=this.rowType instanceof Float64Array?
+        2**-52:
+        this.rowType instanceof Float32Array?2**-23:Number.EPSILON;
+    let precision = eps;
+    const tolerance = 1.e-64;
+    const itmax = 50;
+    const rows=matrix.length
+    const rowOffsetEnd=rows-1;
+    const columns=matrix[0].length;
+    const columnOffsetEnd=columns-1;
+    if (rows < columns) throw "Need more rows than columns"
+    let temp;
+    let c= 0;
+    let i = 0;
+    let j = 0;
+    let k = 0;
+    let l = 0;
+    const u = this.cloneMatrix(matrix);
+    const e = new this.rowType(columns).fill(0.0); //vector1
+    const q = new this.rowType(columns).fill(0.0); //vector2
+    const v = this.rep([columns, columns], 0);
+                    //Householder's reduction to bidiagonal form
+    let f = 0.0;
+    let g = 0.0;
+    let h = 0.0;
+    let x = 0.0;
+    let y = 0.0;
+    let z = 0.0;
+    let s = 0.0;
+
+    for(i=0; i<columns; i++) {
+        e[i] = g; //vector
+        const uRow=u[i]
+        const iPlus1=i+1;
+        const sum=u.reduceRange(i,rowOffsetEnd,(previousValue,row)=>previousValue+row[i]**2)
+        if(sum <= tolerance)
+            g = 0.0;
+        else {
+            f = uRow[i];
+            g = Math.sqrt(sum)*(f<0?1:-1);
+            h = f * g - sum
+            uRow[i] = f - g;
+            for(j=iPlus1; j<columns; j++) {
+                const factor=u.reduceRange(i,rowOffsetEnd,(previousValue,row)=>previousValue+row[i]*row[j])/h;
+                for(let ri=i;ri<=rowOffsetEnd;ri++) u[ri][j]+=factor*u[ri][i]
             }
-            q[i] = g
-            s = 0.0
-            for(j=l; j<n; j++)
-                s = s + u[i][j] * u[i][j]
-            if (s <= tolerance)
-                g = 0.0
-            else {
-                f = u[i][i + 1]
-                g = Math.sqrt(s)
-                if (f >= 0.0) g = -g
-                h = f * g - s
-                u[i][i + 1] = f - g;
-                for(j=l; j < n; j++) e[j] = u[i][j] / h
-                for(j=l; j < m; j++) {
-                    s = 0.0
-                    for(k=l; k<n; k++)
-                        s += (u[j][k] * u[i][k])
-                    for(k=l; k<n; k++)
-                        u[j][k] += s * e[k]
+        }
+        q[i] = g
+        const sumCols=u.reduceRange(iPlus1,columnOffsetEnd,(previousValue,cell,ci)=>previousValue+u[i][ci]**2)
+        if(sumCols <= tolerance)
+            g = 0.0
+        else {
+            f = uRow[iPlus1]
+            g = Math.sqrt(sumCols) * (f<0? 1:-1)
+            h = f * g - sumCols
+            uRow[iPlus1] = f - g;
+            for(let ci=iPlus1;ci<=columnOffsetEnd;ci++) e[ci]=uRow[ci]/h;
+            for(j = iPlus1; j < rows; j++) {
+                const uj=u[j];
+                const sum=uj.reduceRange(iPlus1,columnOffsetEnd,(previousValue,column,ci)=>previousValue+column*uRow[ci]);
+                for(let ci=iPlus1;ci<=columnOffsetEnd;ci++) uj[ci]+=sum*e[ci];           }
+        }
+        y = Math.abs(q[i]) + Math.abs(e[i])
+        if(y>x) x=y
+    }
+    l=columns;
+    // accumulation of right hand transformations
+    for(i=columnOffsetEnd; i != -1; i += -1) {
+        if (g != 0.0) {
+            const uRow=u[i]
+            h = g * uRow[i+1]
+            for(j=l; j<columns; j++)
+                v[j][i] = uRow[j] / h //u is array, v is square of columns
+            for(j=l; j < columns; j++) {
+                const sum=v.reduceRange(l,columnOffsetEnd,(previousValue,row,ri)=>previousValue+u[i][ri] * row[j])
+                for(let ci=l;ci<columns;ci++){
+                    const vRow=v[ci];
+                    vRow[j]+=vRow[i]*sum
                 }
             }
-            y = Math.abs(q[i]) + Math.abs(e[i])
-            if(y > x)
-                x = y
         }
+        const vRow=v[i]
+        for(j=l; j<columns; j++) {
+            vRow[j] = 0;
+            v[j][i] = 0;
+        }
+        vRow[i] = 1;
+        g = e[i]
+        l = i
+    }
 
-        // accumulation of right hand transformations
-        for(i = n-1; i!=-1; i--) {
-            if (g != 0.0) {
-                h = g * u[i][i + 1]
-                for (j = l; j < n; j++)
-                    v[j][i] = u[i][j] / h //u is array, v is square of columns
-                for (j = l; j < n; j++) {
-                    s = 0.0
-                    for (k = l; k < n; k++)
-                        s += u[i][k] * v[k][j]
-                    for (k = l; k < n; k++)
-                        v[k][j] += (s * v[k][i])
+    // accumulation of left hand transformations
+    for (i = columns - 1; i != -1; i += -1) {
+        l = i + 1
+        g = q[i]
+        const uRow=u[i];
+        for(j=l; j<columns; j++) uRow[j]=0;
+        if (g != 0.0)
+            for(let i=0;i<rows;i++) u[i][i];
+        else {
+            h = uRow[i] * g
+            for (j = l; j < columns; j++) {
+                const factor=u.reduceRange(l,rowOffsetEnd,(previousValue,row)=>previousValue+row[i]*row[j])/h;
+                for(let ci=i;ci<=rowOffsetEnd;ci++){
+                    const row=u[ci];
+                    row[j]+=row[i]*factor
                 }
             }
-            for (j = l; j < n; j++) {
-                v[i][j] = 0;
-                v[j][i] = 0;
-            }
-            v[i][i] = 1;
-            g = e[i]
-            l = i
-        }
+            for(let ri=i;ri<=rowOffsetEnd;ri++) u[ri][i]/=g;
+        } 
+        uRow[i]++;
+    }
 
-        // accumulation of left hand transformations
-        for(i=n-1; i != -1; i += -1) {
-            l = i + 1
-            g = q[i]
-            for (j = l; j < n; j++)
-                u[i][j] = 0;
-            if (g != 0.0) {
-                h = u[i][i] * g
-                for (j = l; j < n; j++) {
-                    s = 0.0
-                    for (k = l; k < m; k++) s += u[k][i] * u[k][j];
-                    f = s / h
-                    for (k = i; k < m; k++) u[k][j] += f * u[k][i];
+    // diagonalization of the bidiagonal form
+    precision = precision * x;
+    for (k = columns - 1; k != -1; k += -1) {
+        for (var iteration = 0; iteration < itmax; iteration++) { // test f splitting
+            let test_convergence = false
+            for (l=k; l>=0; l--) {
+                if (Math.abs(e[l]) <= precision) {
+                    test_convergence = true
+                    break
                 }
-                for (j = i; j < m; j++) u[j][i] = u[j][i] / g;
-            } else
-                for (j = i; j < m; j++) u[j][i] = 0;
-            u[i][i] += 1;
-        }
-
-        // diagonalization of the bidiagonal form
-        prec = prec * x
-        for(k=n-1; k != -1; k--) {
-            const kPlusOne=k+1;
-            const kMinusOne=k-1;
-            for(let iteration = 0; iteration < itmax; iteration++) { // test f splitting
-                let test_convergence = false
-                for(l=k; l != -1; l--) {
-                    if(Math.abs(e[l]) <= prec) {
-                        test_convergence = true
+                if (Math.abs(q[l - 1]) <= precision)
+                    break
+            }
+            if (!test_convergence) { // cancellation of e[l] if l>0
+                c = 0.0
+                s = 1.0
+                const l1 = l - 1
+                for(i=l; i<=k; i++) {
+                    const ei=e[i];
+                    f = s * ei
+                    e[i] = c * ei
+                    if (Math.abs(f) <= precision)
                         break
+                    g = q[i]
+                    h = this.pythag(f, g)
+                    q[i] = h
+                    c = g / h
+                    s = -f / h
+                    for(let ci=l;ci<=columnOffsetEnd;ci++){
+                        const row=u[ci];
+                        const cl1 = row[l1]
+                        const ci = row[i]
+                        row[l1] = cl1 * c + (ci * s)
+                        row[i] = -cl1 * s + (ci * c)
                     }
-                    if (Math.abs(q[l - 1]) <= prec)
-                        break
                 }
-                if (!test_convergence) { // cancellation of e[l] if l>0
-                    c = 0.0
-                    s = 1.0
-                    const l1 = l - 1
-                    for(i=l; i<kPlusOne; i++) {
-                        f = s * e[i]
-                        e[i] = c * e[i]
-                        if (Math.abs(f) <= prec)
-                            break
-                        g = q[i]
-                        h = pythag(f, g)
-                        q[i] = h
-                        c = g / h
-                        s = -f / h
-                        for(j = 0; j<m; j++) {
-                            y = u[j][l1]
-                            z = u[j][i]
-                            u[j][l1] = y * c + (z * s)
-                            u[j][i] = -y * s + (z * c)
-                        }
-                    }
+            }
+            // test f convergence
+            z = q[k]
+            if(l == k) { //convergence
+                if(z < 0.0) { //q[k] is made non-negative
+                    q[k] = -z
+                    for(let ci=l;ci<=columnOffsetEnd;ci++) v[ci][k]*=-1;
                 }
-                // test f convergence
-                z = q[k]
-                if(l == k) { //convergence
-                    if(z < 0.0) { //q[k] is made non-negative
-                        q[k] = -z
-                        for (j=0; j<n; j++)
-                            v[j][k] = -v[j][k]
-                    }
-                    break //break out of iteration loop and move on to next k value
+                break //break out of iteration loop and move on to next k value
+            }
+            if(iteration >= itmax - 1)
+                throw 'Error: no convergence.'
+            // shift from bottom 2x2 minor
+            x = q[l]
+            const kMinus1=k-1;
+            y = q[kMinus1]
+            g = e[kMinus1]
+            h = e[k]
+            const z2=z**2
+            f = ((y**2 - z2 + g**2 - h*h)) / (2.0 * h * y)
+            g = this.pythag(f, 1.0)
+            const fg=f+f< 0.0?-g:g;
+            f = (x**2 - z2 + h * (y / fg - h)) / x
+            // next QR transformation
+            c = 1.0
+            s = 1.0
+            for(i=l+1; i <= k; i++) {
+                const iMinus1=i-1;
+                g = e[i]
+                y = q[i]
+                h = s * g
+                g = c * g
+                z = this.pythag(f, h)
+                e[iMinus1] = z
+                c = f / z
+                s = h / z
+                f = x * c + g * s
+                g = -x * s + g * c
+                h = y * s
+                y = y * c
+                for(j=0; j<columns; j++) {
+                    const row=v[j];
+                    x = row[iMinus1]
+                    z = row[i]
+                    row[iMinus1] = x * c + z * s
+                    row[i] = -x * s + z * c
                 }
-                if (iteration >= itmax - 1)
-                    throw 'Error: no convergence.'
-                // shift from bottom 2x2 minor
-                x = q[l]
-                y = q[kMinusOne]
-                g = e[kMinusOne]
-                h = e[k]
-                f = ((y - z) * (y + z) + (g - h) * (g + h)) / (2.0 * h * y)
-                g = pythag(f, 1.0)
-                if(f < 0.0)
-                    f = ((x - z) * (x + z) + h * (y / (f - g) - h)) / x
-                else
-                    f = ((x - z) * (x + z) + h * (y / (f + g) - h)) / x
-                // next QR transformation
-                c = 1.0
-                s = 1.0
-                for(i=l+1; i<kPlusOne; i++) {
-                    g = e[i]
-                    y = q[i]
-                    h = s * g
-                    g = c * g
-                    z = pythag(f, h)
-                    e[i - 1] = z
-                    c = f / z
-                    s = h / z
-                    f = x * c + g * s
-                    g = -x * s + g * c
-                    h = y * s
-                    y = y * c
-                    for (j = 0; j < n; j++) {
-                        x = v[j][i - 1]
-                        z = v[j][i]
-                        v[j][i - 1] = x * c + z * s
-                        v[j][i] = -x * s + z * c
-                    }
-                    z = pythag(f, h)
-                    q[i - 1] = z
-                    c = f / z
-                    s = h / z
-                    f = c * g + s * y
-                    x = -s * g + c * y
-                    for (j = 0; j < m; j++) {
-                        y = u[j][i - 1]
-                        z = u[j][i]
-                        u[j][i - 1] = y * c + z * s
-                        u[j][i] = -y * s + z * c
-                    }
+                z = this.pythag(f, h)
+                q[iMinus1] = z
+                c = f / z
+                s = h / z
+                f = c * g + s * y
+                x = -s * g + c * y
+                for(j=0; j<rows; j++) {
+                    const row=u[j];
+                    y = row[iMinus1]
+                    z = row[i]
+                    row[iMinus1] = y * c + z * s
+                    row[i] = -y * s + z * c
                 }
-                e[l] = 0.0
-                e[k] = f
-                q[k] = x
             }
+            e[l] = 0.0
+            e[k] = f
+            q[k] = x
         }
-        const ql=q.length;
-        for(i=0; i<ql; i++)
-            if (q[i] < prec) q[i] = 0
+    }
+    const ql=q.length;
+    for(i=0; i<ql; i++) if(q[i]<precision) q[i]=0;
 
-        //sort eigenvalues	
-        for(i=0; i<n; i++) {
-            for(j=i-1; j>=0; j--) {
-                if(q[j] < q[i]) {
-                    c = q[j]
-                    q[j] = q[i]
-                    q[i] = c
-                    const ul=u.length;
-                    for(k = 0; k< ul; k++) {
-                        temp = u[k][i];
-                        u[k][i] = u[k][j];
-                        u[k][j] = temp;
-                    }
-                    const vl=v.length;
-                    for(k=0; k<vl; k++) {
-                        temp = v[k][i];
-                        v[k][i] = v[k][j];
-                        v[k][j] = temp;
-                    }
-                    i = j
-                }
+    //sort eigenvalues	
+    for(i=0; i<columns; i++) {
+        for(j=i-1; j>=0; j--) {
+            const qj=q[j];
+            const qi=q[i]
+            if(qj < qi) {
+                c = qj
+                q[j] = qi
+                q[i] = c
+                u.allRowsSwap(i,j);
+                v.allRowsSwap(i,j);
+                i=j
             }
         }
-        return {
-            U: u,
-            S: q,
-            V: v
-        }
+    }
+    return {
+        U: u,
+        S: q,
+        V: v
     }
 }
-
-module.exports = PCA;
+PCA.prototype.svd=svd;