/**
* Performs a matrix inversion operations that takes advantage of the special
* properties of a covariance matrix.
*
* @param cov A covariance matrix. Not modified.
* @param cov_inv The inverse of cov. Modified.
* @return true if it could invert the matrix false if it could not.
*/
public static bool invert(FMatrixRMaj cov, FMatrixRMaj cov_inv)
{
if (cov.numCols <= 4)
{
if (cov.numCols != cov.numRows)
{
throw new ArgumentException("Must be a square matrix.");
}
if (cov.numCols >= 2)
{
UnrolledInverseFromMinor_FDRM.inv(cov, cov_inv);
}
else
{
cov_inv.data[0] = 1.0f / cov_inv.data[0];
}
}
else
{
LinearSolverDense <FMatrixRMaj> solver = LinearSolverFactory_FDRM.symmPosDef(cov.numRows);
// wrap it to make sure the covariance is not modified.
solver = new LinearSolverSafe <FMatrixRMaj>(solver);
if (!solver.setA(cov))
{
return(false);
}
solver.invert(cov_inv);
}
return(true);
}
/**
* 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);
}
public bool process(WatchedDoubleStepQREigen_FDRM imp, FMatrixRMaj A, FMatrixRMaj Q_h)
{
this._implicit = imp;
if (N != A.numRows)
{
N = A.numRows;
Q = new FMatrixRMaj(N, N);
splits = new int[N];
origEigenvalues = new Complex_F32[N];
eigenvectors = new FMatrixRMaj[N];
eigenvectorTemp = new FMatrixRMaj(N, 1);
solver = LinearSolverFactory_FDRM.linear(0);
}
else
{
// UtilEjml.setnull(eigenvectors);
eigenvectors = new FMatrixRMaj[N];
}
Array.Copy(_implicit.eigenvalues, 0, origEigenvalues, 0, N);
_implicit.setup(A);
_implicit.setQ(Q);
numSplits = 0;
onscript = true;
// Console.WriteLine("Orig A");
// A.print("%12.10ff");
if (!findQandR())
{
return(false);
}
return(extractVectors(Q_h));
}
/**
* <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);
}
