public virtual bool decompose(FMatrixRBlock orig)
{
if (orig.numCols != orig.numRows)
{
throw new ArgumentException("Input matrix must be square.");
}
init(orig);
FSubmatrixD1 subA = new FSubmatrixD1(A);
FSubmatrixD1 subV = new FSubmatrixD1(V);
FSubmatrixD1 subU = new FSubmatrixD1(A);
int N = orig.numCols;
for (int i = 0; i < N; i += A.blockLength)
{
// Console.WriteLine("-------- triag i "+i);
int height = Math.Min(A.blockLength, A.numRows - i);
subA.col0 = subU.col0 = i;
subA.row0 = subU.row0 = i;
subU.row1 = subU.row0 + height;
subV.col0 = i;
subV.row1 = height;
subV.original.reshape(subV.row1, subV.col1, false);
// bidiagonalize the top row
TridiagonalHelper_FDRB.tridiagUpperRow(A.blockLength, subA, gammas, subV);
// apply Householder reflectors to the lower portion using block multiplication
if (subU.row1 < orig.numCols)
{
// take in account the 1 in the last row. The others are skipped over.
float before = subU.get(A.blockLength - 1, A.blockLength);
subU.set(A.blockLength - 1, A.blockLength, 1);
// A = A + U*V^T + V*U^T
multPlusTransA(A.blockLength, subU, subV, subA);
multPlusTransA(A.blockLength, subV, subU, subA);
subU.set(A.blockLength - 1, A.blockLength, before);
}
}
return(true);
}
public virtual FMatrixRBlock getQ(FMatrixRBlock Q, bool transposed)
{
Q = QRDecompositionHouseholder_FDRB.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);
FSubmatrixD1 subQ = new FSubmatrixD1(Q);
FSubmatrixD1 subU = new FSubmatrixD1(A);
FSubmatrixD1 subW = new FSubmatrixD1(V);
FSubmatrixD1 tmp = new FSubmatrixD1(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)
{
tmp.row0 = i;
tmp.row1 = A.numCols;
tmp.col0 = 0;
tmp.col1 = blockSize;
}
else
{
tmp.col0 = i;
tmp.row1 = blockSize;
}
tmp.original.reshape(tmp.row1, tmp.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_FDRB.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_FDRB.multTransB(A.blockLength, subQ, subU, tmp);
}
else
{
MatrixMult_FDRB.mult(A.blockLength, subU, subQ, tmp);
}
// Q(i+1) = Q(i) + W*F
if (transposed)
{
MatrixMult_FDRB.multPlus(A.blockLength, tmp, subW, subQ);
}
else
{
MatrixMult_FDRB.multPlusTransA(A.blockLength, subW, tmp, subQ);
}
replaceZeros(subU);
}
return(Q);
}