public static void invert(LinearSolverDense <ZMatrixRMaj> solver, ZMatrixRMaj A, ZMatrixRMaj A_inv)
{
A_inv.reshape(A.numRows, A.numCols);
CommonOps_ZDRM.setIdentity(A_inv);
solver.solve(A_inv, A_inv);
}
public virtual /**/ double quality()
{
return(alg.quality());
}
/**
* Converts B and X into block matrices and calls the block matrix solve routine.
*
* @param B A matrix ℜ <sup>m × p</sup>. Not modified.
* @param X A matrix ℜ <sup>n × p</sup>, where the solution is written to. Modified.
*/
public virtual void solve(FMatrixRMaj B, FMatrixRMaj X)
{
blockB.reshape(B.numRows, B.numCols, false);
blockX.reshape(X.numRows, X.numCols, false);
MatrixOps_FDRB.convert(B, blockB);
alg.solve(blockB, blockX);
MatrixOps_FDRB.convert(blockX, X);
}
virtual public void solve(DMatrixRMaj B, DMatrixRMaj X)
{
X.reshape(blockA.numCols, B.numCols);
blockB.reshape(B.numRows, B.numCols, false);
blockX.reshape(X.numRows, X.numCols, false);
MatrixOps_DDRB.convert(B, blockB);
alg.solve(blockB, blockX);
MatrixOps_DDRB.convert(blockX, X);
}
public static void invert(LinearSolverDense <FMatrixRMaj> solver, FMatrix1Row A, FMatrixRMaj A_inv)
{
if (A.numRows != A_inv.numRows || A.numCols != A_inv.numCols)
{
throw new ArgumentException("A and A_inv must have the same dimensions");
}
CommonOps_FDRM.setIdentity(A_inv);
solver.solve(A_inv, A_inv);
}
public void solve(T B, T X)
{
if (alg.modifiesB())
{
this.B = UtilEjml.reshapeOrDeclare(this.B, B);
this.B.To = B;
B = this.B;
}
alg.solve(B, X);
}
public static void invert(LinearSolverDense <CMatrixRMaj> solver, CMatrixRMaj A, CMatrixRMaj A_inv,
CMatrixRMaj storage)
{
if (A.numRows != A_inv.numRows || A.numCols != A_inv.numCols)
{
throw new ArgumentException("A and A_inv must have the same dimensions");
}
CommonOps_CDRM.setIdentity(storage);
solver.solve(storage, A_inv);
}
public override /**/ double quality()
{
return(SpecializedOps_FDRM.qualityTriangular(R));
}
/**
* <p>
* Upgrades the basic solution to the optimal 2-norm solution.
* </p>
*
* <pre>
* First solves for 'z'
*
* || x_b - P*[ R_11^-1 * R_12 ] * z ||2
* min z || [ - I_{n-r} ] ||
*
* </pre>
*
* @param X basic solution, also output solution
*/
protected void upgradeSolution(FMatrixRMaj X)
{
FMatrixRMaj z = Y; // recycle Y
// compute the z which will minimize the 2-norm of X
// because of the identity matrix tacked onto the end 'A' should never be singular
if (!internalSolver.setA(W))
{
throw new InvalidOperationException("This should never happen. Is input NaN?");
}
z.reshape(numCols - rank, 1);
internalSolver.solve(X, z);
// compute X by tweaking the original
CommonOps_FDRM.multAdd(-1, W, z, X);
}
public virtual void solve(T B, T X)
{
if (alg.modifiesB())
{
if (this.B == null)
{
this.B = (T)B.copy();
}
else
{
if (this.B.getNumRows() != B.getNumRows() || this.B.getNumCols() != B.getNumCols())
{
this.B.reshape(A.getNumRows(), B.getNumCols());
}
this.B.set(B);
}
B = this.B;
}
alg.solve(B, X);
}
/**
* Computes the most dominant eigen vector of A using an inverted shifted matrix.
* The inverted shifted matrix is defined as <b>B = (A - αI)<sup>-1</sup></b> and
* can converge faster if α is chosen wisely.
*
* @param A An invertible square matrix matrix.
* @param alpha Shifting factor.
* @return If it converged or not.
*/
public bool computeShiftInvert(FMatrixRMaj A, float alpha)
{
initPower(A);
LinearSolverDense <FMatrixRMaj> solver = LinearSolverFactory_FDRM.linear(A.numCols);
SpecializedOps_FDRM.addIdentity(A, B, -alpha);
solver.setA(B);
bool converged = false;
for (int i = 0; i < maxIterations && !converged; i++)
{
solver.solve(q0, q1);
float s = NormOps_FDRM.normPInf(q1);
CommonOps_FDRM.divide(q1, s, q2);
converged = checkConverged(A);
}
return(converged);
}
private void solveWithLU(float real, int index, FMatrixRMaj r)
{
FMatrixRMaj A = new FMatrixRMaj(index, index);
CommonOps_FDRM.extract(_implicit.A, 0, index, 0, index, A, 0, 0);
for (int i = 0; i < index; i++)
{
A.add(i, i, -real);
}
r.reshape(index, 1, false);
SpecializedOps_FDRM.subvector(_implicit.A, 0, index, index, false, 0, r);
CommonOps_FDRM.changeSign(r);
// TODO this must be very inefficient
if (!solver.setA(A))
{
throw new InvalidOperationException("Solve failed");
}
solver.solve(r, r);
}
/**
* <p>
* Given an eigenvalue it computes an eigenvector using inverse iteration:
* <br>
* for i=1:MAX {<br>
* (A - μI)z<sup>(i)</sup> = q<sup>(i-1)</sup><br>
* q<sup>(i)</sup> = z<sup>(i)</sup> / ||z<sup>(i)</sup>||<br>
* λ<sup>(i)</sup> = q<sup>(i)</sup><sup>T</sup> A q<sup>(i)</sup><br>
* }<br>
* </p>
* <p>
* NOTE: If there is another eigenvalue that is very similar to the provided one then there
* is a chance of it converging towards that one instead. The larger a matrix is the more
* likely this is to happen.
* </p>
* @param A Matrix whose eigenvector is being computed. Not modified.
* @param eigenvalue The eigenvalue in the eigen pair.
* @return The eigenvector or null if none could be found.
*/
public static FEigenpair computeEigenVector(FMatrixRMaj A, float eigenvalue)
{
if (A.numRows != A.numCols)
{
throw new ArgumentException("Must be a square matrix.");
}
FMatrixRMaj M = new FMatrixRMaj(A.numRows, A.numCols);
FMatrixRMaj x = new FMatrixRMaj(A.numRows, 1);
FMatrixRMaj b = new FMatrixRMaj(A.numRows, 1);
CommonOps_FDRM.fill(b, 1);
// perturb the eigenvalue slightly so that its not an exact solution the first time
// eigenvalue -= eigenvalue*UtilEjml.F_EPS*10;
float origEigenvalue = eigenvalue;
SpecializedOps_FDRM.addIdentity(A, M, -eigenvalue);
float threshold = NormOps_FDRM.normPInf(A) * UtilEjml.F_EPS;
float prevError = float.MaxValue;
bool hasWorked = false;
LinearSolverDense <FMatrixRMaj> solver = LinearSolverFactory_FDRM.linear(M.numRows);
float perp = 0.0001f;
for (int i = 0; i < 200; i++)
{
bool failed = false;
// if the matrix is singular then the eigenvalue is within machine precision
// of the true value, meaning that x must also be.
if (!solver.setA(M))
{
failed = true;
}
else
{
solver.solve(b, x);
}
// see if solve silently failed
if (MatrixFeatures_FDRM.hasUncountable(x))
{
failed = true;
}
if (failed)
{
if (!hasWorked)
{
// if it failed on the first trial try perturbing it some more
float val = i % 2 == 0 ? 1.0f - perp : 1.0f + perp;
// maybe this should be turn into a parameter allowing the user
// to configure the wise of each step
eigenvalue = origEigenvalue * (float)Math.Pow(val, i / 2 + 1);
SpecializedOps_FDRM.addIdentity(A, M, -eigenvalue);
}
else
{
// otherwise assume that it was so accurate that the matrix was singular
// and return that result
return(new FEigenpair(eigenvalue, b));
}
}
else
{
hasWorked = true;
b.set(x);
NormOps_FDRM.normalizeF(b);
// compute the residual
CommonOps_FDRM.mult(M, b, x);
float error = NormOps_FDRM.normPInf(x);
if (error - prevError > UtilEjml.F_EPS * 10)
{
// if the error increased it is probably converging towards a different
// eigenvalue
// CommonOps.set(b,1);
prevError = float.MaxValue;
hasWorked = false;
float val = i % 2 == 0 ? 1.0f - perp : 1.0f + perp;
eigenvalue = origEigenvalue * (float)Math.Pow(val, 1);
}
else
{
// see if it has converged
if (error <= threshold || Math.Abs(prevError - error) <= UtilEjml.F_EPS)
{
return(new FEigenpair(eigenvalue, b));
}
// update everything
prevError = error;
eigenvalue = VectorVectorMult_FDRM.innerProdA(b, A, b);
}
SpecializedOps_FDRM.addIdentity(A, M, -eigenvalue);
}
}
return(null);
}
