Question

So I am trying to model Gram-Schmidt for any size N×N matrix, and I have officially hit a roadblock I can’t get past. I know it’s a matter of looping this correctly, but I can’t figure out what the problem is. Remember I do not want to just pass in a 3×3 matrix, but any size N×N.

The course notes QR Decomposition with Gram-Schmidt explains exactly what I want to do. Very simple calculation by the way. In the course notes ||u|| means that it is the sum of the square of the elements, so sqrt(x₁² + x₂² + x₃² + …. + x_n²).

The multiplication symbol is actually the dot product.

The code I wrote so far is listed below. What is wrong with it?

function qrProjection(arr) {
    var qProjected = [];
    var tempArray = [];
    var aTemp = arr;
    var uTemp = new Array(arr.length);
    var uSquareSqrt = new Array(arr.length);
    var eTemp = [];
    var sum = 0;
    var sumOfSquares = 0;
    var breakCondition = 0;
    var secondBreakCondition = 0;
    var iterationCounter = 0;

    //Build uTemp Array
    for (i = 0; i < arr.length; i++) {
        uTemp[i] = new Array(arr[i].length);
    }
    for (i = 0; i < arr.length; i++) {
        eTemp[i] = new Array(arr[i].length);
    }

    uTemp[0] = aTemp[0];

    for (j = 0; j <= arr.length; j++) {

        for (l = 0; l < arr[j].length; l++) {
            if (breakCondition == 1) break;
            sumOfSquares = Math.pow(uTemp[j][l], 2) + sumOfSquares;
        }

        if (breakCondition == 0) {
            uSquareSqrt[j] = Math.sqrt(sumOfSquares);
            sumOfSquares = 0;
        }

        for (i = 0; i < arr[j].length; i++) {
            if (breakCondition == 1) break;
            eTemp[j][i] = (1 / (uSquareSqrt[j])) * (uTemp[j][i]);
        }

        breakCondition = 1;

        if (iterationCounter == 0) {
            for (m = 0; m < arr[j].length; m++) {
                matrixDotProduct = aTemp[j + 1][m] * eTemp[j][m] + matrixDotProduct;
            }
        }
        else {
            for (m = 0; m < arr[j].length; m++) {
                for (s = 0; s <= iterationCounter; s++) {

                    matrixDotProduct = aTemp[j + 1][s] * eTemp[m][s] + matrixDotProduct;
                }
                for (t = 0; t < arr[j].length; t++) {
                    uTemp[j + 1][t] = aTemp[j + 1][t] - eTemp[j][t] * matrixDotProduct;

                }
            }
        }

        if (iterationCounter == 0) {
            for (m = 0; m < arr[j].length; m++) {
                uTemp[j + 1][m] = aTemp[j + 1][m] - eTemp[j][m] * matrixDotProduct;
            }
        }

        matrixDotProduct = 0;

        for (l = 0; l < arr[j].length; l++) {
            sumOfSquares = Math.pow(uTemp[j + 1][l], 2) + sumOfSquares;
        }

        uSquareSqrt[j + 1] = Math.sqrt(sumOfSquares);
        sumOfSquares = 0;

        for (i = 0; i < arr[j].length; i++) {
            eTemp[j + 1][i] = (1 / (uSquareSqrt[j + 1])) * (uTemp[j + 1][i]);
        }

        iterationCounter++;
    }
    qProjected = eTemp;
    return qProjected;
}

Answer 1

I must apologize that instead of tweaking your code, I wrote my own from scratch:

/* Main function of interest */

// Each entry of a matrix object represents a column
function gramSchmidt(matrixA, n) {        
    var totalVectors = matrixA.length;

    for (var i = 0; i < totalVectors; i++) {
        var tempVector = matrixA[i];
        for (var j = 0; j < i; j++) {
            var dotProd = dot(matrixA[i], matrixA[j], n);
            var toSubtract = multiply(dotProd, matrixA[j], n);
            tempVector = subtract(tempVector, toSubtract, n);
        }
        var nrm = norm(tempVector, n);
        matrixA[i] = multiply(1 / nrm, tempVector, n);
    }
}

/*
 * Example usage:
 * var myMatrix = [[1,0,0],[2,3,0],[5,4,7]];
 * gramSchmidt(myMatrix, 3);
 *   ==> myMatrix now equals [[1,0,0],[0,1,0],[0,0,1]]
 * 3 here equals the number of dimensions per vector
 */


/* Simple vector arithmetic */

function subtract(vectorX, vectorY, n) {
    var result = new Array(n);
    for (var i = 0; i < n; i++)
        result[i] = vectorX[i] - vectorY[i];
    return result;
}

function multiply(scalarC, vectorX, n) {
    var result = new Array(n);
    for (var i = 0; i < n; i++)
        result[i] = scalarC * vectorX[i];
    return result;
}

function dot(vectorX, vectorY, n) {
    var sum = 0;
    for (var i = 0; i < n; i++)
        sum += vectorX[i] * vectorY[i];
    return sum;
}

function norm(vectorX, n) {
    return Math.sqrt(dot(vectorX, vectorX, n));
}

Note that the algorithm above computes the Gram-Schmidt orthogonalization, which is the matrix [e₁ | e₂ | … | e_n], not the QR factorization!