/**
* <p>
* Computes W from the householder reflectors stored in the columns of the row block
* submatrix Y.
* </p>
*
* <p>
* Y = v<sup>(1)</sup><br>
* W = -β<sub>1</sub>v<sup>(1)</sup><br>
* for j=2:r<br>
* z = -β(I +WY<sup>T</sup>)v<sup>(j)</sup> <br>
* W = [W z]<br>
* Y = [Y v<sup>(j)</sup>]<br>
* end<br>
* <br>
* where v<sup>(.)</sup> are the house holder vectors, and r is the block length. Note that
* Y already contains the householder vectors so it does not need to be modified.
* </p>
*
* <p>
* Y and W are assumed to have the same number of rows and columns.
* </p>
*/
public static void computeW_row(int blockLength,
FSubmatrixD1 Y, FSubmatrixD1 W,
float[] beta, int betaIndex)
{
int heightY = Y.row1 - Y.row0;
CommonOps_FDRM.fill(W.original, 0);
// W = -beta*v(1)
BlockHouseHolder_FDRB.scale_row(blockLength, Y, W, 0, 1, -beta[betaIndex++]);
int min = Math.Min(heightY, W.col1 - W.col0);
// set up rest of the rows
for (int i = 1; i < min; i++)
{
// w=-beta*(I + W*Y^T)*u
float b = -beta[betaIndex++];
// w = w -beta*W*(Y^T*u)
for (int j = 0; j < i; j++)
{
float yv = BlockHouseHolder_FDRB.innerProdRow(blockLength, Y, i, Y, j, 1);
VectorOps_FDRB.add_row(blockLength, W, i, 1, W, j, b * yv, W, i, 1, Y.col1 - Y.col0);
}
//w=w -beta*u + stuff above
BlockHouseHolder_FDRB.add_row(blockLength, Y, i, b, W, i, 1, W, i, 1, Y.col1 - Y.col0);
}
}
/**
* <p>
* Computes the 'y' vector and stores the result in 'v'<br>
* <br>
* y = -γ(A + U*V^T + V*U^T)u
* </p>
*
* @param blockLength
* @param A Contains the reflectors and the row being updated.
* @param V Contains previously computed 'v' vectors.
* @param row The row of 'A' that is to be updated.
*/
public static void computeY(int blockLength,
FSubmatrixD1 A,
FSubmatrixD1 V,
int row,
float gamma)
{
// Elements in 'y' before 'row' are known to be zero and the element at 'row'
// is not used. Thus only elements after row and after are computed.
// y = A*u
multA_u(blockLength, A, V, row);
for (int i = 0; i < row; i++)
{
// y = y + u_i*v_i^t*u + v_i*u_i^t*u
// v_i^t*u
float dot_v_u = BlockHouseHolder_FDRB.innerProdRow(blockLength, A, row, V, i, 1);
// u_i^t*u
float dot_u_u = BlockHouseHolder_FDRB.innerProdRow(blockLength, A, row, A, i, 1);
// y = y + u_i*(v_i^t*u)
// the ones in these 'u' are skipped over since the next submatrix of A
// is only updated
VectorOps_FDRB.add_row(blockLength, V, row, 1, A, i, dot_v_u, V, row, row + 1, A.col1 - A.col0);
// y = y + v_i*(u_i^t*u)
// the 1 in U is taken account above
VectorOps_FDRB.add_row(blockLength, V, row, 1, V, i, dot_u_u, V, row, row + 1, A.col1 - A.col0);
}
// y = -gamma*y
VectorOps_FDRB.scale_row(blockLength, V, row, -gamma, V, row, row + 1, V.col1 - V.col0);
}
/**
* <p>
* Applies the reflectors that have been computed previously to the specified row.
* <br>
* A = A + u*v^T + v*u^T only along the specified row in A.
* </p>
*
* @param blockLength
* @param A Contains the reflectors and the row being updated.
* @param V Contains previously computed 'v' vectors.
* @param row The row of 'A' that is to be updated.
*/
public static void applyReflectorsToRow(int blockLength,
FSubmatrixD1 A,
FSubmatrixD1 V,
int row)
{
int height = Math.Min(blockLength, A.row1 - A.row0);
float[] dataA = A.original.data;
float[] dataV = V.original.data;
int indexU, indexV;
// for each previously computed reflector
for (int i = 0; i < row; i++)
{
int width = Math.Min(blockLength, A.col1 - A.col0);
indexU = A.original.numCols * A.row0 + height * A.col0 + i * width + row;
indexV = V.original.numCols * V.row0 + height * V.col0 + i * width + row;
float u_row = (i + 1 == row) ? 1.0f : dataA[indexU];
float v_row = dataV[indexV];
// take in account the leading one
float before = A.get(i, i + 1);
A.set(i, i + 1, 1);
// grab only the relevant row from A = A + u*v^T + v*u^T
VectorOps_FDRB.add_row(blockLength, A, row, 1, V, i, u_row, A, row, row, A.col1 - A.col0);
VectorOps_FDRB.add_row(blockLength, A, row, 1, A, i, v_row, A, row, row, A.col1 - A.col0);
A.set(i, i + 1, before);
}
}
public static void add_row(int blockLength,
FSubmatrixD1 A, int rowA, float alpha,
FSubmatrixD1 B, int rowB, float beta,
FSubmatrixD1 C, int rowC,
int zeroOffset, int end)
{
int offset = rowA + zeroOffset;
if (C.col0 + offset >= C.col1)
{
return;
}
// handle leading one
C.set(rowC, offset, alpha + B.get(rowB, offset) * beta);
VectorOps_FDRB.add_row(blockLength, A, rowA, alpha, B, rowB, beta, C, rowC, offset + 1, end);
}
/**
* <p>
* Final computation for a single row of 'v':<br>
* <br>
* v = y -(1/2)γ(y^T*u)*u
* </p>
*
* @param blockLength
* @param A
* @param V
* @param row
* @param gamma
*/
public static void computeRowOfV(int blockLength,
FSubmatrixD1 A,
FSubmatrixD1 V,
int row,
float gamma)
{
// val=(y^T*u)
float val = BlockHouseHolder_FDRB.innerProdRow(blockLength, A, row, V, row, 1);
// take in account the one
float before = A.get(row, row + 1);
A.set(row, row + 1, 1);
// v = y - (1/2)gamma*val * u
VectorOps_FDRB.add_row(blockLength, V, row, 1, A, row, -0.5f * gamma * val, V, row, row + 1,
A.col1 - A.col0);
A.set(row, row + 1, before);
}
