public virtual DMatrixRBlock getQ(DMatrixRBlock Q, bool transposed)
        {
            Q = QRDecompositionHouseholder_DDRB.initializeQ(Q, A.numRows, A.numCols, A.blockLength, false);

            int height = Math.Min(A.blockLength, A.numRows);

            V.reshape(height, A.numCols, false);
            this.tmp.reshape(height, A.numCols, false);

            DSubmatrixD1 subQ = new DSubmatrixD1(Q);
            DSubmatrixD1 subU = new DSubmatrixD1(A);
            DSubmatrixD1 subW = new DSubmatrixD1(V);
            DSubmatrixD1 temp = new DSubmatrixD1(this.tmp);


            int N = A.numRows;

            int start = N - N % A.blockLength;

            if (start == N)
            {
                start -= A.blockLength;
            }
            if (start < 0)
            {
                start = 0;
            }

            // (Q1^T * (Q2^T * (Q3^t * A)))
            for (int i = start; i >= 0; i -= A.blockLength)
            {
                int blockSize = Math.Min(A.blockLength, N - i);

                subW.col0 = i;
                subW.row1 = blockSize;
                subW.original.reshape(subW.row1, subW.col1, false);

                if (transposed)
                {
                    temp.row0 = i;
                    temp.row1 = A.numCols;
                    temp.col0 = 0;
                    temp.col1 = blockSize;
                }
                else
                {
                    temp.col0 = i;
                    temp.row1 = blockSize;
                }
                temp.original.reshape(temp.row1, temp.col1, false);

                subU.col0 = i;
                subU.row0 = i;
                subU.row1 = subU.row0 + blockSize;

                // zeros and ones are saved and overwritten in U so that standard matrix multiplication can be used
                copyZeros(subU);

                // compute W for Q(i) = ( I + W*Y^T)
                TridiagonalHelper_DDRB.computeW_row(A.blockLength, subU, subW, gammas, i);

                subQ.col0 = i;
                subQ.row0 = i;

                // Apply the Qi to Q
                // Qi = I + W*U^T

                // Note that U and V are really row vectors.  but standard notation assumed they are column vectors.
                // which is why the functions called don't match the math above

                // (I + W*U^T)*Q
                // F=U^T*Q(i)
                if (transposed)
                {
                    MatrixMult_DDRB.multTransB(A.blockLength, subQ, subU, temp);
                }
                else
                {
                    MatrixMult_DDRB.mult(A.blockLength, subU, subQ, temp);
                }
                // Q(i+1) = Q(i) + W*F
                if (transposed)
                {
                    MatrixMult_DDRB.multPlus(A.blockLength, temp, subW, subQ);
                }
                else
                {
                    MatrixMult_DDRB.multPlusTransA(A.blockLength, subW, temp, subQ);
                }

                replaceZeros(subU);
            }

            return(Q);
        }