Reduce computation time in unit tests

Author: Lucas-Haubert

tests/test_complex_eigen_solver.py

@@ -5,17 +5,9 @@
 rng = np.random.default_rng()
 A = rng.random((dim, dim))
 
-ces = nanoeigenpy.ComplexEigenSolver()
-es = nanoeigenpy.ComplexEigenSolver(dim)
 es = nanoeigenpy.ComplexEigenSolver(A)
 assert es.info() == nanoeigenpy.ComputationInfo.Success
 
-es_with_vectors = nanoeigenpy.ComplexEigenSolver(A, True)
-assert es_with_vectors.info() == nanoeigenpy.ComputationInfo.Success
-
-es_without_vectors = nanoeigenpy.ComplexEigenSolver(A, False)
-assert es_without_vectors.info() == nanoeigenpy.ComputationInfo.Success
-
 V = es.eigenvectors()
 D = es.eigenvalues()
 assert V.shape == (dim, dim)
@@ -26,68 +18,15 @@
 assert nanoeigenpy.is_approx(AV.real, VD.real)
 assert nanoeigenpy.is_approx(AV.imag, VD.imag)
 
-es_compute = nanoeigenpy.ComplexEigenSolver()
-result = es_compute.compute(A, False)
-assert result.info() == nanoeigenpy.ComputationInfo.Success
-D_only = es_compute.eigenvalues()
-assert D_only.shape == (dim,)
-
-result_with_vectors = es_compute.compute(A, True)
-assert result_with_vectors.info() == nanoeigenpy.ComputationInfo.Success
-V_computed = es_compute.eigenvectors()
-D_computed = es_compute.eigenvalues()
-assert V_computed.shape == (dim, dim)
-assert D_computed.shape == (dim,)
-
 trace_A = np.trace(A)
 trace_D = np.sum(D)
 assert abs(trace_A - trace_D.real) < 1e-10
 assert abs(trace_D.imag) < 1e-10
 
-es_default = nanoeigenpy.ComplexEigenSolver()
-result_default = es_default.compute(A)
-assert result_default.info() == nanoeigenpy.ComputationInfo.Success
-V_default = es_default.eigenvectors()
-D_default = es_default.eigenvalues()
-
-es_iter = nanoeigenpy.ComplexEigenSolver(A)
-default_iter = es_iter.getMaxIterations()
-es_iter.setMaxIterations(100)
-assert es_iter.getMaxIterations() == 100
-es_iter.setMaxIterations(200)
-assert es_iter.getMaxIterations() == 200
-
-assert es.info() == nanoeigenpy.ComputationInfo.Success
-
-ces1 = nanoeigenpy.ComplexEigenSolver()
-ces2 = nanoeigenpy.ComplexEigenSolver()
-id1 = ces1.id()
-id2 = ces2.id()
-assert id1 != id2
-assert id1 == ces1.id()
-assert id2 == ces2.id()
-
-dim_constructor = 3
-ces3 = nanoeigenpy.ComplexEigenSolver(dim_constructor)
-ces4 = nanoeigenpy.ComplexEigenSolver(dim_constructor)
-id3 = ces3.id()
-id4 = ces4.id()
-assert id3 != id4
-assert id3 == ces3.id()
-assert id4 == ces4.id()
-
 ces5 = nanoeigenpy.ComplexEigenSolver(A)
 ces6 = nanoeigenpy.ComplexEigenSolver(A)
 id5 = ces5.id()
 id6 = ces6.id()
 assert id5 != id6
 assert id5 == ces5.id()
 assert id6 == ces6.id()
-
-ces7 = nanoeigenpy.ComplexEigenSolver(A, True)
-ces8 = nanoeigenpy.ComplexEigenSolver(A, False)
-id7 = ces7.id()
-id8 = ces8.id()
-assert id7 != id8
-assert id7 == ces7.id()
-assert id8 == ces8.id()

tests/test_complex_schur.py

@@ -19,50 +19,6 @@
     for col in range(row):
         assert abs(T[row, col]) < 1e-12
 
-A_test = rng.random((dim, dim))
-cs1 = nanoeigenpy.ComplexSchur(dim)
-cs1.compute(A_test)
-cs2 = nanoeigenpy.ComplexSchur(A_test)
-
-assert cs1.info() == nanoeigenpy.ComputationInfo.Success
-assert cs2.info() == nanoeigenpy.ComputationInfo.Success
-
-T1 = cs1.matrixT()
-U1 = cs1.matrixU()
-T2 = cs2.matrixT()
-U2 = cs2.matrixU()
-
-assert nanoeigenpy.is_approx(T1, T2)
-assert nanoeigenpy.is_approx(U1, U2)
-
-cs_no_u = nanoeigenpy.ComplexSchur(A, False)
-assert cs_no_u.info() == nanoeigenpy.ComputationInfo.Success
-T_no_u = cs_no_u.matrixT()
-
-assert nanoeigenpy.is_approx(T, T_no_u)
-
-cs_compute_no_u = nanoeigenpy.ComplexSchur(dim)
-result_no_u = cs_compute_no_u.compute(A, False)
-assert result_no_u.info() == nanoeigenpy.ComputationInfo.Success
-T_compute_no_u = cs_compute_no_u.matrixT()
-assert nanoeigenpy.is_approx(T, T_compute_no_u)
-
-cs_iter = nanoeigenpy.ComplexSchur(dim)
-cs_iter.setMaxIterations(30 * dim)  # m_maxIterationsPerRow * size
-result_iter = cs_iter.compute(A)
-assert result_iter.info() == nanoeigenpy.ComputationInfo.Success
-assert cs_iter.getMaxIterations() == 30 * dim
-
-T_iter = cs_iter.matrixT()
-U_iter = cs_iter.matrixU()
-assert nanoeigenpy.is_approx(T, T_iter)
-assert nanoeigenpy.is_approx(U, U_iter)
-
-cs_few_iter = nanoeigenpy.ComplexSchur(dim)
-cs_few_iter.setMaxIterations(1)
-result_few = cs_few_iter.compute(A)
-assert cs_few_iter.getMaxIterations() == 1
-
 A_triangular = np.triu(A)
 cs_triangular = nanoeigenpy.ComplexSchur(dim)
 cs_triangular.setMaxIterations(1)
@@ -91,27 +47,3 @@
 assert nanoeigenpy.is_approx(
     A_complex, U_from_hess @ T_from_hess @ U_from_hess.conj().T
 )
-
-cs1_id = nanoeigenpy.ComplexSchur(dim)
-cs2_id = nanoeigenpy.ComplexSchur(dim)
-id1 = cs1_id.id()
-id2 = cs2_id.id()
-assert id1 != id2
-assert id1 == cs1_id.id()
-assert id2 == cs2_id.id()
-
-cs3_id = nanoeigenpy.ComplexSchur(A)
-cs4_id = nanoeigenpy.ComplexSchur(A)
-id3 = cs3_id.id()
-id4 = cs4_id.id()
-assert id3 != id4
-assert id3 == cs3_id.id()
-assert id4 == cs4_id.id()
-
-cs5_id = nanoeigenpy.ComplexSchur(A, True)
-cs6_id = nanoeigenpy.ComplexSchur(A, False)
-id5 = cs5_id.id()
-id6 = cs6_id.id()
-assert id5 != id6
-assert id5 == cs5_id.id()
-assert id6 == cs6_id.id()

tests/test_generalized_eigen_solver.py

@@ -7,27 +7,14 @@
 B = rng.random((dim, dim))
 B = (B + B.T) * 0.5 + np.diag(10.0 + rng.random(dim))
 
-ges = nanoeigenpy.GeneralizedEigenSolver()
-ges_size = nanoeigenpy.GeneralizedEigenSolver(dim)
 ges_matrices = nanoeigenpy.GeneralizedEigenSolver(A, B)
 assert ges_matrices.info() == nanoeigenpy.ComputationInfo.Success
 
-ges_with_vectors = nanoeigenpy.GeneralizedEigenSolver(A, B, True)
-assert ges_with_vectors.info() == nanoeigenpy.ComputationInfo.Success
-
-ges_without_vectors = nanoeigenpy.GeneralizedEigenSolver(A, B, False)
-assert ges_without_vectors.info() == nanoeigenpy.ComputationInfo.Success
-
 alphas = ges_matrices.alphas()
 betas = ges_matrices.betas()
 eigenvectors = ges_matrices.eigenvectors()
 eigenvalues = ges_matrices.eigenvalues()
 
-assert alphas.shape == (dim,)
-assert betas.shape == (dim,)
-assert eigenvectors.shape == (dim, dim)
-assert eigenvalues.shape == (dim,)
-
 for k in range(dim):
     v = eigenvectors[:, k]
     lambda_k = eigenvalues[k]
@@ -51,66 +38,3 @@
     if abs(betas[k]) > 1e-12:
         expected_eigenvalue = alphas[k] / betas[k]
         assert abs(eigenvalues[k] - expected_eigenvalue) < 1e-12
-
-ges_compute = nanoeigenpy.GeneralizedEigenSolver()
-result = ges_compute.compute(A, B, False)
-assert result.info() == nanoeigenpy.ComputationInfo.Success
-alphas_only = ges_compute.alphas()
-betas_only = ges_compute.betas()
-eigenvalues_only = ges_compute.eigenvalues()
-
-result_with_vectors = ges_compute.compute(A, B, True)
-assert result_with_vectors.info() == nanoeigenpy.ComputationInfo.Success
-eigenvectors_computed = ges_compute.eigenvectors()
-
-ges_default = nanoeigenpy.GeneralizedEigenSolver()
-result_default = ges_default.compute(A, B)
-assert result_default.info() == nanoeigenpy.ComputationInfo.Success
-
-ges_iter = nanoeigenpy.GeneralizedEigenSolver(A, B)
-ges_iter.setMaxIterations(100)
-ges_iter.setMaxIterations(200)
-
-A1 = rng.random((dim, dim))
-B1 = rng.random((dim, dim))
-spdA = A.T @ A + A1.T @ A1
-spdB = B.T @ B + B1.T @ B1
-
-ges_spd = nanoeigenpy.GeneralizedEigenSolver(spdA, spdB)
-assert ges_spd.info() == nanoeigenpy.ComputationInfo.Success
-
-spd_eigenvalues = ges_spd.eigenvalues()
-max_imag = np.max(np.abs(spd_eigenvalues.imag))
-assert max_imag < 1e-10
-
-ges1 = nanoeigenpy.GeneralizedEigenSolver()
-ges2 = nanoeigenpy.GeneralizedEigenSolver()
-id1 = ges1.id()
-id2 = ges2.id()
-assert id1 != id2
-assert id1 == ges1.id()
-assert id2 == ges2.id()
-
-ges3 = nanoeigenpy.GeneralizedEigenSolver(dim)
-ges4 = nanoeigenpy.GeneralizedEigenSolver(dim)
-id3 = ges3.id()
-id4 = ges4.id()
-assert id3 != id4
-assert id3 == ges3.id()
-assert id4 == ges4.id()
-
-ges5 = nanoeigenpy.GeneralizedEigenSolver(A, B)
-ges6 = nanoeigenpy.GeneralizedEigenSolver(A, B)
-id5 = ges5.id()
-id6 = ges6.id()
-assert id5 != id6
-assert id5 == ges5.id()
-assert id6 == ges6.id()
-
-ges7 = nanoeigenpy.GeneralizedEigenSolver(A, B, True)
-ges8 = nanoeigenpy.GeneralizedEigenSolver(A, B, False)
-id7 = ges7.id()
-id8 = ges8.id()
-assert id7 != id8
-assert id7 == ges7.id()
-assert id8 == ges8.id()

tests/test_generalized_self_adjoint_eigen_solver.py

@@ -78,44 +78,6 @@ def test_generalized_selfadjoint_eigensolver(options):
     rank = len([d for d in D if abs(d) > 1e-12])
     assert rank <= dim
 
-    decomp1 = nanoeigenpy.GeneralizedSelfAdjointEigenSolver()
-    decomp2 = nanoeigenpy.GeneralizedSelfAdjointEigenSolver()
-    id1 = decomp1.id()
-    id2 = decomp2.id()
-    assert id1 != id2
-    assert id1 == decomp1.id()
-    assert id2 == decomp2.id()
-
-    decomp3 = nanoeigenpy.GeneralizedSelfAdjointEigenSolver(dim)
-    decomp4 = nanoeigenpy.GeneralizedSelfAdjointEigenSolver(dim)
-    id3 = decomp3.id()
-    id4 = decomp4.id()
-    assert id3 != id4
-    assert id3 == decomp3.id()
-    assert id4 == decomp4.id()
-
-    decomp5 = nanoeigenpy.GeneralizedSelfAdjointEigenSolver(A, B, options)
-    decomp6 = nanoeigenpy.GeneralizedSelfAdjointEigenSolver(A, B, options)
-    id5 = decomp5.id()
-    id6 = decomp6.id()
-    assert id5 != id6
-    assert id5 == decomp5.id()
-    assert id6 == decomp6.id()
-
-    if compute_eigenvectors and (
-        options & nanoeigenpy.DecompositionOptions.Ax_lBx.value
-    ):
-        A_pos = A @ A.T + np.eye(dim)
-        gsaes_pos = nanoeigenpy.GeneralizedSelfAdjointEigenSolver(A_pos, B, options)
-        assert gsaes_pos.info() == nanoeigenpy.ComputationInfo.Success
-
-        D_pos = gsaes_pos.eigenvalues()
-        if all(D_pos[i] > 1e-12 for i in range(dim)):
-            sqrt_matrix = gsaes_pos.operatorSqrt()
-            inv_sqrt_matrix = gsaes_pos.operatorInverseSqrt()
-            assert sqrt_matrix.shape == (dim, dim)
-            assert inv_sqrt_matrix.shape == (dim, dim)
-
 
 if __name__ == "__main__":
     import sys

tests/test_iterative_solvers.py

@@ -12,13 +12,6 @@
     nanoeigenpy.solvers.LeastSquaresConjugateGradient,
     nanoeigenpy.solvers.IdentityLeastSquaresConjugateGradient,
     nanoeigenpy.solvers.DiagonalLeastSquaresConjugateGradient,
-    nanoeigenpy.solvers.MINRES,
-    nanoeigenpy.solvers.IdentityBiCGSTAB,
-]
-
-_classes_bis = [
-    nanoeigenpy.solvers.DiagonalMINRES,
-    nanoeigenpy.solvers.BiCGSTAB,
 ]
 
 
@@ -66,50 +59,6 @@ def test_solver_with_guess(cls):
     assert nanoeigenpy.is_approx(B, A.dot(X_est), 1e-6)
 
 
-@pytest.mark.parametrize("cls", _classes_bis)
-def test_solver_bis(cls):
-    Q = rng.standard_normal((dim, dim))
-    A = Q.T @ Q + np.eye(dim) * 0.1
-    solver = cls(A)
-    solver.setMaxIterations(MAX_ITER)
-
-    x = rng.random(dim)
-    b = A.dot(x)
-    x_est = solver.solve(b)
-
-    assert solver.info() == nanoeigenpy.ComputationInfo.Success
-    assert nanoeigenpy.is_approx(b, A.dot(x_est), 1e-6)
-
-    X = rng.random((dim, 20))
-    B = A.dot(X)
-    X_est = solver.solve(B)
-
-    assert nanoeigenpy.is_approx(B, A.dot(X_est), 1e-6)
-
-
-@pytest.mark.parametrize("cls", _classes_bis)
-def test_solver_with_guess_bis(cls):
-    Q = rng.standard_normal((dim, dim))
-    A = Q.T @ Q + np.eye(dim) * 0.1
-    solver = cls(A)
-    solver.setMaxIterations(MAX_ITER)
-
-    x = rng.random(dim)
-    b = A.dot(x)
-    x_est = solver.solveWithGuess(b, x + 0.01)
-
-    assert solver.info() == nanoeigenpy.ComputationInfo.Success
-    assert nanoeigenpy.is_approx(x, x_est, 1e-6)
-    assert nanoeigenpy.is_approx(b, A.dot(x_est), 1e-6)
-
-    X = rng.random((dim, 20))
-    B = A.dot(X)
-    X_est = solver.solveWithGuess(B, X + 0.01)
-
-    assert nanoeigenpy.is_approx(X, X_est, 1e-6)
-    assert nanoeigenpy.is_approx(B, A.dot(X_est), 1e-6)
-
-
 if __name__ == "__main__":
     import sys