Allow which symbols like in Arpack.jl and KrylovKit.jl

bench/example.jl

@@ -9,7 +9,7 @@ using Arpack
 
 function helloworld(n = 40, nev = 4)
     A = randn(n, n)
-    @time S, hist = partialschur(A, nev = nev, which = LR(), tol = 1e-6)
+    @time S, hist = partialschur(A, nev = nev, which = :LR, tol = 1e-6)
     @time eigs(A, nev = nev, which = :LR, tol = 1e-6)
     @show norm(A * S.Q - S.Q * S.R)
     println(hist)

bench/partial_schur.jl

@@ -37,7 +37,7 @@ end
 function bencharnoldi()
     A = mymatrix(6000)
     A = construct_linear_map(mymatrix(6000))
-    target = LM()
+    target = :LM
 
     @benchmark partialschur(
         B,

docs/src/usage/01_getting_started.md

@@ -43,7 +43,7 @@ julia> A = spdiagm(
             0 => fill(2.0, 100), 
             1 => fill(-1.0, 99)
        );
-julia> decomp, history = partialschur(A, nev=10, tol=1e-6, which=SR());
+julia> decomp, history = partialschur(A, nev=10, tol=1e-6, which=:SR);
 julia> decomp
 PartialSchur decomposition (Float64) of dimension 10
 eigenvalues:

docs/src/usage/02_spectral_transformations.md

@@ -27,7 +27,7 @@ function construct_linear_map(A)
 end
 
 # Target the largest eigenvalues of the inverted problem
-decomp, = partialschur(construct_linear_map(A), nev=4, tol=1e-5, restarts=100, which=LM())
+decomp, = partialschur(construct_linear_map(A), nev=4, tol=1e-5, restarts=100, which=:LM)
 λs_inv, X = partialeigen(decomp)
 
 # Eigenvalues have to be inverted to find the smallest eigenvalues of the non-inverted problem.
@@ -65,7 +65,7 @@ function construct_linear_map(A,B)
 end
 
 # Target the largest eigenvalues of the inverted problem
-decomp,  = partialschur(construct_linear_map(A, B), nev=4, tol=1e-5, restarts=100, which=LM())
+decomp,  = partialschur(construct_linear_map(A, B), nev=4, tol=1e-5, restarts=100, which=:LM)
 λs_inv, X = partialeigen(decomp)
 
 # Eigenvalues have to be inverted to find the smallest eigenvalues of the non-inverted problem.

readme.md

@@ -31,7 +31,7 @@ julia> A = spdiagm(
             1 => fill(-1.0, 99)
        );
 
-julia> decomp, history = partialschur(A, nev=10, tol=1e-6, which=SR());
+julia> decomp, history = partialschur(A, nev=10, tol=1e-6, which=:SR);
 
 julia> decomp
 PartialSchur decomposition (Float64) of dimension 10

src/run.jl

@@ -31,22 +31,22 @@ The most important keyword arguments:
 | Keyword | Type | Default | Description |
 |------:|:-----|:----|:------|
 | `nev` | `Int` | `min(6, size(A, 1))` |Number of eigenvalues |
-| `which` | `Target` | `LM()` | One of `LM()`, `LR()`, `SR()`, `LI()`, `SI()`, see below. |
+| `which` | `Symbol` or `Target` | `:LM` | One of `:LM`, `:LR`, `:SR`, `:LI`, `:SI`, see below. |
 | `tol` | `Real` | `√eps` | Tolerance for convergence: ‖Ax - xλ‖₂ < tol * ‖λ‖ |
 
-The target `which` can be any of `subtypes(ArnoldiMethod.Target)`:
+The target `which` can be any of:
 
-| Target | Description |
-|------:|:-----|
-| `LM()` | Largest magnitude: `abs(λ)` is largest |
-| `LR()` | Largest real part: `real(λ)` is largest |
-| `SR()` | Smallest real part: `real(λ)` is smallest |
-| `LI()` | Largest imaginary part: `imag(λ)` is largest|
-| `SI()` | Smallest imaginary part: `imag(λ)` is smallest|
+| Target          | Description                                    |
+|----------------:|:-----------------------------------------------|
+| `:LM` or `LM()` | Largest magnitude: `abs(λ)` is largest         |
+| `:LR` or `LR()` | Largest real part: `real(λ)` is largest        |
+| `:SR` or `SR()` | Smallest real part: `real(λ)` is smallest      |
+| `:LI` or `LI()` | Largest imaginary part: `imag(λ)` is largest   |
+| `:SI` or `SI()` | Smallest imaginary part: `imag(λ)` is smallest |
 
 !!! note
 
-    The targets `LI()` and `SI()` only make sense in complex arithmetic. In real
+    The targets `:LI` and `:SI` only make sense in complex arithmetic. In real
     arithmetic `λ` is an eigenvalue iff `conj(λ)` is an eigenvalue and this 
     conjugate pair converges simultaneously.
 
@@ -94,7 +94,7 @@ is usually about two times `mindim`.
 function partialschur(
     A;
     nev::Int = min(6, size(A, 1)),
-    which::Target = LM(),
+    which::Union{Target,Symbol} = LM(),
     tol::Real = sqrt(eps(real(vtype(A)))),
     mindim::Int = min(max(10, nev), size(A, 1)),
     maxdim::Int = min(max(20, 2nev), size(A, 1)),
@@ -107,9 +107,17 @@ function partialschur(
     nev ≤ mindim ≤ maxdim ≤ s || throw(
         ArgumentError("nev ≤ mindim ≤ maxdim does not hold, got $nev ≤ $mindim ≤ $maxdim"),
     )
-    _partialschur(A, vtype(A), mindim, maxdim, nev, tol, restarts, which)
+    _which = which isa Target ? which : _symbol_to_target(which)
+    _partialschur(A, vtype(A), mindim, maxdim, nev, tol, restarts, _which)
 end
 
+_symbol_to_target(sym::Symbol) =
+    sym == :LM ? LM() :
+    sym == :LR ? LR() :
+    sym == :SR ? SR() :
+    sym == :LI ? LI() : sym == :SI ? SI() : throw(ArgumentError("Unknown target: $sym"))
+
+
 """
     IsConverged(ritz, tol)
 

test/partial_schur.jl

@@ -52,7 +52,7 @@ end
 @testset "Target non-dominant eigenvalues" begin
     # Dominant eigenvalues 50, 51, 52, 53, but we target the smallest real part
     A = Diagonal([1:0.1:10; 50:53])
-    S, hist = partialschur(A, which = SR())
+    S, hist = partialschur(A, which = :SR)
     @test all(x -> real(x) ≤ 10, eigenvalues(S.R))
 end