/** * 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(DMatrixRMaj cov, DMatrixRMaj cov_inv) { if (cov.numCols <= 4) { if (cov.numCols != cov.numRows) { throw new ArgumentException("Must be a square matrix."); } if (cov.numCols >= 2) { UnrolledInverseFromMinor_DDRM.inv(cov, cov_inv); } else { cov_inv.data[0] = 1.0 / cov_inv.data[0]; } } else { LinearSolverDense <DMatrixRMaj> solver = LinearSolverFactory_DDRM.symmPosDef(cov.numRows); // wrap it to make sure the covariance is not modified. solver = new LinearSolverSafe <DMatrixRMaj>(solver); if (!solver.setA(cov)) { return(false); } solver.invert(cov_inv); } return(true); }
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 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); }
/** * Configures internal parameters. * * @param decomposition Used to solve the linear system. * @param norm2Solution If true then the optimal 2-norm solution will be computed for degenerate systems. */ protected BaseLinearSolverQrp_FDRM(QRPDecomposition_F32 <FMatrixRMaj> decomposition, bool norm2Solution) { this.decomposition = decomposition; this.norm2Solution = norm2Solution; if (internalSolver.modifiesA()) { internalSolver = new LinearSolverSafe <FMatrixRMaj>(internalSolver); } }
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); }
/** * <p> * Performs a matrix inversion operation on the specified matrix and stores the results * in the same matrix.<br> * <br> * a = a<sup>-1</sup> * </p> * * <p> * If the algorithm could not invert the matrix then false is returned. If it returns true * that just means the algorithm finished. The results could still be bad * because the matrix is singular or nearly singular. * </p> * * @param A The matrix that is to be inverted. Results are stored here. Modified. * @return true if it could invert the matrix false if it could not. */ public static bool invert(CMatrixRMaj A) { LinearSolverDense <CMatrixRMaj> solver = LinearSolverFactory_CDRM.lu(A.numRows); if (solver.setA(A)) { solver.invert(A); } else { return(false); } return(true); }
/** * <p> * Performs a matrix inversion operation that does not modify the original * and stores the results in another matrix. The two matrices must have the * same dimension.<br> * <br> * b = a<sup>-1</sup> * </p> * * <p> * If the algorithm could not invert the matrix then false is returned. If it returns true * that just means the algorithm finished. The results could still be bad * because the matrix is singular or nearly singular. * </p> * * <p> * For medium to large matrices there might be a slight performance boost to using * {@link LinearSolverFactory_CDRM} instead. * </p> * * @param input The matrix that is to be inverted. Not modified. * @param output Where the inverse matrix is stored. Modified. * @return true if it could invert the matrix false if it could not. */ public static bool invert(CMatrixRMaj input, CMatrixRMaj output) { LinearSolverDense <CMatrixRMaj> solver = LinearSolverFactory_CDRM.lu(input.numRows); if (solver.modifiesA()) { input = (CMatrixRMaj)input.copy(); } if (!solver.setA(input)) { return(false); } solver.invert(output); 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)); }
//@Override public void configure(DMatrixRMaj F, DMatrixRMaj Q, DMatrixRMaj H) { this.F = F; this.Q = Q; this.H = H; int dimenX = F.numCols; int dimenZ = H.numRows; a = new DMatrixRMaj(dimenX, 1); b = new DMatrixRMaj(dimenX, dimenX); y = new DMatrixRMaj(dimenZ, 1); S = new DMatrixRMaj(dimenZ, dimenZ); S_inv = new DMatrixRMaj(dimenZ, dimenZ); c = new DMatrixRMaj(dimenZ, dimenX); d = new DMatrixRMaj(dimenX, dimenZ); K = new DMatrixRMaj(dimenX, dimenZ); x = new DMatrixRMaj(dimenX, 1); P = new DMatrixRMaj(dimenX, dimenX); // covariance matrices are symmetric positive semi-definite solver = LinearSolverFactory_DDRM.symmPosDef(dimenX); }
public LinearSolverChol_DDRB(LinearSolverDense <DMatrixRBlock> alg) : base(alg) { }
/** * * @param alg The solver it is wrapped around. */ public LinearSolverSafe(LinearSolverDense <T> alg) { this.alg = alg; }
public LinearSolver_DDRB_to_DDRM(LinearSolverDense <DMatrixRBlock> alg) { this.alg = alg; }
/** * <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); }
public LinearSolverQrBlock64_DDRM(LinearSolverDense <DMatrixRBlock> alg) : base(alg) { }