public /**/ double quality()
{
return(SpecializedOps_FDRM.qualityTriangular(LU));
}
/**
* a specialized version of solve that avoid additional checks that are not needed.
*/
public void _solveVectorInternal(float[] vv)
{
// Solve L*Y = B
int ii = 0;
for (int i = 0; i < n; i++)
{
int ip = indx[i];
float sum = vv[ip];
vv[ip] = vv[i];
if (ii != 0)
{
// for( int j = ii-1; j < i; j++ )
// sum -= dataLU[i* n +j]*vv[j];
int index = i * n + ii - 1;
for (int j = ii - 1; j < i; j++)
{
sum -= dataLU[index++] * vv[j];
}
}
else if (sum != 0.0f)
{
ii = i + 1;
}
vv[i] = sum;
}
// Solve U*X = Y;
TriangularSolver_FDRM.solveU(dataLU, vv, n);
}
/**
* Used internally to find the solution to a single column vector.
*/
private void solveInternalL()
{
// solve L*y=b storing y in x
TriangularSolver_FDRM.solveL(t, vv, n);
// solve L^T*x=y
TriangularSolver_FDRM.solveTranL(t, vv, n);
}
public override /**/ double quality()
{
return(SpecializedOps_FDRM.qualityTriangular(QR));
}
/**
* Solves for X using the QR decomposition.
*
* @param B A matrix that is n by m. Not modified.
* @param X An n by m matrix where the solution is writen to. Modified.
*/
//@Override
public override void solve(FMatrixRMaj B, FMatrixRMaj X)
{
if (X.numRows != numCols)
{
throw new ArgumentException("Unexpected dimensions for X");
}
else if (B.numRows != numRows || B.numCols != X.numCols)
{
throw new ArgumentException("Unexpected dimensions for B");
}
int BnumCols = B.numCols;
// solve each column one by one
for (int colB = 0; colB < BnumCols; colB++)
{
// make a copy of this column in the vector
for (int i = 0; i < numRows; i++)
{
a[i] = B.data[i * BnumCols + colB];
}
// Solve Qa=b
// a = Q'b
// a = Q_{n-1}...Q_2*Q_1*b
//
// Q_n*b = (I-gamma*u*u^T)*b = b - u*(gamma*U^T*b)
for (int n = 0; n < numCols; n++)
{
u[n] = 1;
float ub = a[n];
// U^T*b
for (int i = n + 1; i < numRows; i++)
{
ub += (u[i] = QR.unsafe_get(i, n)) * a[i];
}
// gamma*U^T*b
ub *= gammas[n];
for (int i = n; i < numRows; i++)
{
a[i] -= u[i] * ub;
}
}
// solve for Rx = b using the standard upper triangular solver
TriangularSolver_FDRM.solveU(QR.data, a, numCols);
// save the results
for (int i = 0; i < numCols; i++)
{
X.data[i * X.numCols + colB] = a[i];
}
}
}
public override void solve(FMatrixRMaj B, FMatrixRMaj X)
{
if (X.numRows != numCols)
{
throw new ArgumentException("Unexpected dimensions for X");
}
else if (B.numRows != numRows || B.numCols != X.numCols)
{
throw new ArgumentException("Unexpected dimensions for B");
}
int BnumCols = B.numCols;
// get the pivots and transpose them
int[] pivots = decomposition.getColPivots();
// solve each column one by one
for (int colB = 0; colB < BnumCols; colB++)
{
x_basic.reshape(numRows, 1);
Y.reshape(numRows, 1);
// make a copy of this column in the vector
for (int i = 0; i < numRows; i++)
{
Y.data[i] = B.get(i, colB);
}
// Solve Q*a=b => a = Q'*b
CommonOps_FDRM.multTransA(Q, Y, x_basic);
// solve for Rx = b using the standard upper triangular solver
TriangularSolver_FDRM.solveU(R11.data, x_basic.data, rank);
// finish the basic solution by filling in zeros
x_basic.reshape(numCols, 1, true);
for (int i = rank; i < numCols; i++)
{
x_basic.data[i] = 0;
}
if (norm2Solution && rank < numCols)
{
upgradeSolution(x_basic);
}
// save the results
for (int i = 0; i < numCols; i++)
{
X.set(pivots[i], colB, x_basic.data[i]);
}
}
}
/**
* Used internally to find the solution to a single column vector.
*/
private void solveInternal()
{
// solve L*s=b storing y in x
TriangularSolver_FDRM.solveL(el, vv, n);
// solve D*y=s
for (int i = 0; i < n; i++)
{
vv[i] /= d[i];
}
// solve L^T*x=y
TriangularSolver_FDRM.solveTranL(el, vv, n);
}
public override /**/ double quality()
{
return(SpecializedOps_FDRM.qualityTriangular(R));
}
/**
* Solves for X using the QR decomposition.
*
* @param B A matrix that is n by m. Not modified.
* @param X An n by m matrix where the solution is written to. Modified.
*/
public override void solve(FMatrixRMaj B, FMatrixRMaj X)
{
if (X.numRows != numCols)
{
throw new ArgumentException("Unexpected dimensions for X: X rows = " + X.numRows + " expected = " +
numCols);
}
else if (B.numRows != numRows || B.numCols != X.numCols)
{
throw new ArgumentException("Unexpected dimensions for B");
}
int BnumCols = B.numCols;
// solve each column one by one
for (int colB = 0; colB < BnumCols; colB++)
{
// make a copy of this column in the vector
for (int i = 0; i < numRows; i++)
{
a.data[i] = B.data[i * BnumCols + colB];
}
// Solve Qa=b
// a = Q'b
// a = Q_{n-1}...Q_2*Q_1*b
//
// Q_n*b = (I-gamma*u*u^T)*b = b - u*(gamma*U^T*b)
for (int n = 0; n < numCols; n++)
{
float[] u = QR[n];
float vv = u[n];
u[n] = 1;
QrHelperFunctions_FDRM.rank1UpdateMultR(a, u, gammas[n], 0, n, numRows, temp.data);
u[n] = vv;
}
// solve for Rx = b using the standard upper triangular solver
TriangularSolver_FDRM.solveU(R.data, a.data, numCols);
// save the results
for (int i = 0; i < numCols; i++)
{
X.data[i * X.numCols + colB] = a.data[i];
}
}
}
public override bool setA(FMatrixRMaj A)
{
_setA(A);
if (!decomposition.decompose(A))
{
return(false);
}
rank = decomposition.getRank();
R.reshape(numRows, numCols);
decomposition.getR(R, false);
// extract the r11 triangle sub matrix
R11.reshape(rank, rank);
CommonOps_FDRM.extract(R, 0, rank, 0, rank, R11, 0, 0);
if (norm2Solution && rank < numCols)
{
// extract the R12 sub-matrix
W.reshape(rank, numCols - rank);
CommonOps_FDRM.extract(R, 0, rank, rank, numCols, W, 0, 0);
// W=inv(R11)*R12
TriangularSolver_FDRM.solveU(R11.data, 0, R11.numCols, R11.numCols, W.data, 0, W.numCols, W.numCols);
// set the identity matrix in the upper portion
W.reshape(numCols, W.numCols, true);
for (int i = 0; i < numCols - rank; i++)
{
for (int j = 0; j < numCols - rank; j++)
{
if (i == j)
{
W.set(i + rank, j, -1);
}
else
{
W.set(i + rank, j, 0);
}
}
}
}
return(true);
}
private void solveUsingTriangle(float real, int index, FMatrixRMaj r)
{
for (int i = 0; i < index; i++)
{
_implicit.A.add(i, i, -real);
}
SpecializedOps_FDRM.subvector(_implicit.A, 0, index, index, false, 0, r);
CommonOps_FDRM.changeSign(r);
TriangularSolver_FDRM.solveU(_implicit.A.data, r.data, _implicit.A.numRows, 0, index);
for (int i = 0; i < index; i++)
{
_implicit.A.add(i, i, real);
}
}
public override /**/ double quality()
{
return(SpecializedOps_FDRM.qualityTriangular(R));
}
/**
* Solves for X using the QR decomposition.
*
* @param B A matrix that is n by m. Not modified.
* @param X An n by m matrix where the solution is written to. Modified.
*/
public override void solve(FMatrixRMaj B, FMatrixRMaj X)
{
if (X.numRows != numCols)
{
throw new ArgumentException("Unexpected dimensions for X");
}
else if (B.numRows != numRows || B.numCols != X.numCols)
{
throw new ArgumentException("Unexpected dimensions for B");
}
int BnumCols = B.numCols;
Y.reshape(numRows, 1, false);
Z.reshape(numRows, 1, false);
// solve each column one by one
for (int colB = 0; colB < BnumCols; colB++)
{
// make a copy of this column in the vector
for (int i = 0; i < numRows; i++)
{
Y.data[i] = B.get(i, colB);
}
// Solve Qa=b
// a = Q'b
CommonOps_FDRM.multTransA(Q, Y, Z);
// solve for Rx = b using the standard upper triangular solver
TriangularSolver_FDRM.solveU(R.data, Z.data, numCols);
// save the results
for (int i = 0; i < numCols; i++)
{
X.set(i, colB, Z.data[i]);
}
}
}
public override void solve(FMatrixRMaj B, FMatrixRMaj X)
{
if (X.numRows != numCols)
{
throw new ArgumentException("Unexpected dimensions for X");
}
else if (B.numRows != numRows || B.numCols != X.numCols)
{
throw new ArgumentException("Unexpected dimensions for B");
}
int BnumCols = B.numCols;
// get the pivots and transpose them
int[] pivots = decomposition.getColPivots();
float[][] qr = decomposition.getQR();
float[] gammas = decomposition.getGammas();
// solve each column one by one
for (int colB = 0; colB < BnumCols; colB++)
{
x_basic.reshape(numRows, 1);
Y.reshape(numRows, 1);
// make a copy of this column in the vector
for (int i = 0; i < numRows; i++)
{
x_basic.data[i] = B.get(i, colB);
}
// Solve Q*x=b => x = Q'*b
// Q_n*b = (I-gamma*u*u^T)*b = b - u*(gamma*U^T*b)
for (int i = 0; i < rank; i++)
{
float[] u = qr[i];
float vv = u[i];
u[i] = 1;
QrHelperFunctions_FDRM.rank1UpdateMultR(x_basic, u, gammas[i], 0, i, numRows, Y.data);
u[i] = vv;
}
// solve for Rx = b using the standard upper triangular solver
TriangularSolver_FDRM.solveU(R11.data, x_basic.data, rank);
// finish the basic solution by filling in zeros
x_basic.reshape(numCols, 1, true);
for (int i = rank; i < numCols; i++)
{
x_basic.data[i] = 0;
}
if (norm2Solution && rank < numCols)
{
upgradeSolution(x_basic);
}
// save the results
for (int i = 0; i < numCols; i++)
{
X.set(pivots[i], colB, x_basic.data[i]);
}
}
}
public override /**/ double quality()
{
// even those it is transposed the diagonal elements are at the same
// elements
return(SpecializedOps_FDRM.qualityTriangular(QR));
}
/**
* Solves for X using the QR decomposition.
*
* @param B A matrix that is n by m. Not modified.
* @param X An n by m matrix where the solution is written to. Modified.
*/
//@Override
public override void solve(FMatrixRMaj B, FMatrixRMaj X)
{
if (X.numRows != numCols)
{
throw new ArgumentException("Unexpected dimensions for X: X rows = " + X.numRows + " expected = " +
numCols);
}
else if (B.numRows != numRows || B.numCols != X.numCols)
{
throw new ArgumentException("Unexpected dimensions for B");
}
U = decomposer.getR(U, true);
float[] gammas = decomposer.getGammas();
float[] dataQR = QR.data;
int BnumCols = B.numCols;
// solve each column one by one
for (int colB = 0; colB < BnumCols; colB++)
{
// make a copy of this column in the vector
for (int i = 0; i < numRows; i++)
{
a[i] = B.data[i * BnumCols + colB];
}
// Solve Qa=b
// a = Q'b
// a = Q_{n-1}...Q_2*Q_1*b
//
// Q_n*b = (I-gamma*u*u^T)*b = b - u*(gamma*U^T*b)
for (int n = 0; n < numCols; n++)
{
int indexU = n * numRows + n + 1;
float ub = a[n];
// U^T*b
for (int i = n + 1; i < numRows; i++, indexU++)
{
ub += dataQR[indexU] * a[i];
}
// gamma*U^T*b
ub *= gammas[n];
a[n] -= ub;
indexU = n * numRows + n + 1;
for (int i = n + 1; i < numRows; i++, indexU++)
{
a[i] -= dataQR[indexU] * ub;
}
}
// solve for Rx = b using the standard upper triangular solver
TriangularSolver_FDRM.solveU(U.data, a, numCols);
// save the results
for (int i = 0; i < numCols; i++)
{
X.data[i * X.numCols + colB] = a[i];
}
}
}
