/** Checks to see if all the real eigenvectors are linearly independent of each other. */ public void testVectorsLinearlyIndependent(SymmetricQRAlgorithmDecomposition alg) { int N = alg.getNumberOfEigenvalues(); // create a matrix out of the eigenvectors Matrix A = Matrix.create(N, N); int off = 0; for (int i = 0; i < N; i++) { AVector v = alg.getEigenVector(i); // it can only handle real eigenvectors if (v == null) off++; else { for (int j = 0; j < N; j++) { A.set(i - off, j, v.get(j)); } } } // see if there are any real eigenvectors if (N == off) return; // A.reshape(N-off,N, false); A = A.reshape(N - off, N); AltLU lu = new AltLU(); lu._decompose(A); assertFalse(lu.isSingular()); // assertTrue(MatrixFeatures.isRowsLinearIndependent(A)); }
/** Sees if the pair of eigenvalue and eigenvector was found in the decomposition. */ public void testForEigenpair( SymmetricQRAlgorithmDecomposition alg, double valueReal, double valueImg, double... vector) { int N = alg.getNumberOfEigenvalues(); int numMatched = 0; for (int i = 0; i < N; i++) { Vector2 c = alg.getEigenvalue(i); if (Math.abs(c.x - valueReal) < 1e-4 && Math.abs(c.y - valueImg) < 1e-4) { // if( c.isReal() ) { if (Math.abs(c.y - 0) < 1e-8) if (vector.length > 0) { AVector v = alg.getEigenVector(i); AMatrix e = Matrix.createFromRows(vector); e = e.getTranspose(); Matrix t = Matrix.create(v.length(), 1); t.setColumn(0, v); double error = diffNormF(e, t); // CommonOps.changeSign(e); e.multiply(-1); double error2 = diffNormF(e, t); if (error < 1e-3 || error2 < 1e-3) numMatched++; } else { numMatched++; } else if (Math.abs(c.y - 0) > 1e-8) { numMatched++; } } } assertEquals(1, numMatched); }
/** * Checks to see if an eigenvalue is complex then the eigenvector is null. If it is real it then * checks to see if the equation A*v = lambda*v holds true. */ public void testPairsConsistent(SymmetricQRAlgorithmDecomposition alg, Matrix A) { // // System.out.println("-------------------------------------------------------------------------"); int N = alg.getNumberOfEigenvalues(); for (int i = 0; i < N; i++) { Vector2 c = alg.getEigenvalue(i); AVector v = alg.getEigenVector(i); if (Double.isInfinite(c.x) || Double.isNaN(c.x) || Double.isInfinite(c.y) || Double.isNaN(c.y)) fail("Uncountable eigenvalue"); if (Math.abs(c.y) > 1e-20) { assertTrue(v == null); } else { assertTrue(v != null); // if( MatrixFeatures.hasUncountable(v)) { // throw new RuntimeException("Egads"); // } assertFalse(v.hasUncountable()); // CommonOps.mult(A,v,tempA); Matrix ta = Matrix.create(A.rowCount(), 1); ta.setColumn(0, (v)); AMatrix tempA = Multiplications.multiply(A, ta); // CommonOps.scale(c.real,v,tempB); Matrix tb = Matrix.create(v.length(), 1); tb.setColumn(0, v); AMatrix tempB = tb.multiplyCopy(c.x); // double max = NormOps.normPInf(A); double max = normPInf(A); if (max == 0) max = 1; double error = diffNormF(tempA, tempB) / max; if (error > 1e-12) { // System.out.println("Original matrix:"); // System.out.println(A); // A.print(); // System.out.println("Eigenvalue = "+c.x); // Eigenpair p = EigenOps.computeEigenVector(A,c.real); // p.vector.print(); // v.print(); // // // CommonOps.mult(A,p.vector,tempA); // CommonOps.scale(c.real,p.vector,tempB); // // max = NormOps.normPInf(A); // // System.out.println("error before = "+error); // error = SpecializedOps.diffNormF(tempA,tempB)/max; // System.out.println("error after = "+error); // A.print("%f"); // System.out.println(); fail("Error was too large"); } assertTrue(error <= 1e-12); } } }