Merge pull request #178 from haampie/improve-coverage

Remove unused iterable constructors and add missing tests for initial guess for x

Author: haampie

src/bicgstabl.jl

@@ -24,8 +24,6 @@ mutable struct BiCGStabIterable{precT, matT, solT, vecT <: AbstractVector, small
     M::smallMatT
 end
 
-bicgstabl_iterator(A, b, l; kwargs...) = bicgstabl_iterator!(zerox(A, b), A, b, l; initial_zero = true, kwargs...)
-
 function bicgstabl_iterator!(x, A, b, l::Int = 2;
     Pl = Identity(),
     max_mv_products = size(A, 2),

src/cg.jl

@@ -1,6 +1,6 @@
 import Base: start, next, done
 
-export cg, cg!, CGIterable, PCGIterable, cg_iterator, cg_iterator!
+export cg, cg!, CGIterable, PCGIterable, cg_iterator!
 
 mutable struct CGIterable{matT, solT, vecT, numT <: Real}
     A::matT
@@ -92,8 +92,6 @@ end
 
 # Utility functions
 
-@inline cg_iterator(A, b, Pl = Identity(); kwargs...) = cg_iterator!(zerox(A, b), A, b, Pl; initially_zero = true, kwargs...)
-
 function cg_iterator!(x, A, b, Pl = Identity();
     tol = sqrt(eps(real(eltype(b)))),
     maxiter::Int = size(A, 2),

src/chebyshev.jl

@@ -54,9 +54,6 @@ function next(cheb::ChebyshevIterable, iteration::Int)
     cheb.resnorm, iteration + 1
 end
 
-chebyshev_iterable(A, b, λmin::Real, λmax::Real; kwargs...) =
-    chebyshev_iterable!(zerox(A, b), A, b, λmin, λmax; kwargs...)
-
 function chebyshev_iterable!(x, A, b, λmin::Real, λmax::Real;
     tol = sqrt(eps(real(eltype(b)))), maxiter = size(A, 2), Pl = Identity(), initially_zero = false)
 

src/gmres.jl

@@ -98,8 +98,6 @@ function next(g::GMRESIterable, iteration::Int)
     g.residual.current, iteration + 1
 end
 
-gmres_iterable(A, b; kwargs...) = gmres_iterable!(zerox(A, b), A, b; initially_zero = true, kwargs...)
-
 function gmres_iterable!(x, A, b;
     Pl = Identity(),
     Pr = Identity(),

src/minres.jl

@@ -36,8 +36,6 @@ mutable struct MINRESIterable{matT, solT, vecT <: DenseVector, smallVecT <: Dens
     resnorm::realT
 end
 
-minres_iterable(A, b; kwargs...) = minres_iterable!(zerox(A, b), A, b; initially_zero = true, kwargs...)
-
 function minres_iterable!(x, A, b; 
     initially_zero::Bool = false, 
     skew_hermitian::Bool = false, 

src/simple.jl

@@ -54,12 +54,6 @@ function powm_iterable!(A, x; tol = eps(real(eltype(A))) * size(A, 2) ^ 3, maxit
     PowerMethodIterable(A, x, tol, maxiter, zero(T), similar(x), similar(x), realmax(real(T)))
 end
 
-function powm_iterable(A; kwargs...)
-    x0 = rand(Complex{real(eltype(A))}, size(A, 1))
-    scale!(x0, one(eltype(A)) / norm(x0))
-    powm_iterable!(A, x0; kwargs...)
-end
-
 """
     powm(B; kwargs...) -> λ, x, [history]
 

test/bicgstabl.jl

@@ -18,11 +18,18 @@ n = 20
         x1, his1 = bicgstabl(A, b, l, max_mv_products = 100, log = true, tol = tol)
         @test isa(his1, ConvergenceHistory)
         @test norm(A * x1 - b) / norm(b) ≤ tol
+        
+        # With an initial guess
+        x_guess = rand(T, n)
+        x2, his2 = bicgstabl!(x_guess, A, b, l, max_mv_products = 100, log = true, tol = tol)
+        @test isa(his2, ConvergenceHistory)
+        @test x2 == x_guess
+        @test norm(A * x2 - b) / norm(b) ≤ tol
 
         # Do an exact LU decomp of a nearby matrix
         F = lufact(A + rand(T, n, n))
-        x2, his2 = bicgstabl(A, b, Pl = F, l, max_mv_products = 100, log = true, tol = tol)
-        @test norm(A * x2 - b) / norm(b) ≤ tol
+        x3, his3 = bicgstabl(A, b, Pl = F, l, max_mv_products = 100, log = true, tol = tol)
+        @test norm(A * x3 - b) / norm(b) ≤ tol
     end
 end
 end

test/chebyshev.jl

@@ -22,20 +22,37 @@ srand(1234321)
 @testset "Matrix{$T}" for T in (Float32, Float64, Complex64, Complex128)
     A = randSPD(T, n)
     b = rand(T, n)
-    λ_min, λ_max = approx_eigenvalue_bounds(A)
     tol = √(eps(real(T)))
 
-    x, history = chebyshev(A, b, λ_min, λ_max, tol=tol, maxiter=10n, log=true)
-    @test isa(history, ConvergenceHistory)
-    @test history.isconverged
-    @test norm(A * x - b) / norm(b) ≤ tol
+    # Without a preconditioner
+    begin
+        λ_min, λ_max = approx_eigenvalue_bounds(A)
+        x0 = rand(n)
+        x, history = chebyshev(A, b, λ_min, λ_max, tol=tol, maxiter=10n, log=true)
+        @test isa(history, ConvergenceHistory)
+        @test history.isconverged
+        @test norm(A * x - b) / norm(b) ≤ tol
+    end
 
-    # Preconditioned solve
-    B = randSPD(T, n)
-    B_fact = cholfact!(B)
-    λ_min, λ_max = approx_eigenvalue_bounds(B_fact \ A)
-    x, history = chebyshev(A, b, λ_min, λ_max, Pl = B_fact, tol=tol, maxiter=10n, log=true)
-    @test history.isconverged
-    @test norm(A * x - b) / norm(b) ≤ tol
+    # With an initial guess
+    begin
+        λ_min, λ_max = approx_eigenvalue_bounds(A)
+        x0 = rand(T, n)
+        x, history = chebyshev!(x0, A, b, λ_min, λ_max, tol=tol, maxiter=10n, log=true)
+        @test isa(history, ConvergenceHistory)
+        @test history.isconverged
+        @test x == x0
+        @test norm(A * x - b) / norm(b) ≤ tol
+    end
+
+    # With a preconditioner
+    begin
+        B = randSPD(T, n)
+        B_fact = cholfact!(B)
+        λ_min, λ_max = approx_eigenvalue_bounds(B_fact \ A)
+        x, history = chebyshev(A, b, λ_min, λ_max, Pl = B_fact, tol=tol, maxiter=10n, log=true)
+        @test history.isconverged
+        @test norm(A * x - b) / norm(b) ≤ tol
+    end
 end
 end

test/minres.jl

@@ -27,12 +27,16 @@ n = 15
 @testset "Hermitian Matrix{$T}" for T in (Float32, Float64, Complex64, Complex128)
     A, x, b = hermitian_problem(T, n)
     tol = sqrt(eps(real(T)))
+    x0 = rand(T, n)
 
-    x_approx, hist = minres(A, b, maxiter = 10n, tol = tol, log = true)
+    x1, hist1 = minres(A, b, maxiter = 10n, tol = tol, log = true)
+    x2, hist2 = minres!(x0, A, b, maxiter = 10n, tol = tol, log = true)
 
-    @test isa(hist, ConvergenceHistory)
-    @test norm(b - A * x_approx) / norm(b) ≤ tol
-    @test hist.isconverged
+    @test isa(hist1, ConvergenceHistory)
+    @test norm(b - A * x1) / norm(b) ≤ tol
+    @test hist1.isconverged
+    @test norm(b - A * x2) / norm(b) ≤ tol
+    @test x2 == x0
 end
 
 @testset "Skew-Hermitian Matrix{$T}" for T in (Float32, Float64, Complex64, Complex128)