Refactor algorithm selection logic

src/algorithms.jl

@@ -56,17 +56,54 @@
 @doc """
     select_algorithm(f, A; kwargs...)
 
-Given some keyword arguments and an input `A`, decide on an algrithm to use for
+Given some keyword arguments and an input `A`, decide on an algorithm to use for
 implementing the function `f` on inputs of type `A`.
+
+In general, if an algorithm is specified explicitly through the `alg` keyword argument
+(either as an algorithm type, an algorithm name as a Symbol, or as an algorithm object),
+that algorithm will be used instead of selecting it automatically. However, that
+behavior may be modified for factorization functions and/or matrix types.
+
+In general, if the algorithm is not specified, a default algorithm specified by
+[`default_algorithm`](@ref) will be used.
 """
 function select_algorithm end
 
-function _select_algorithm(f, A::AbstractMatrix, alg::AbstractAlgorithm)
+function select_algorithm(f, A; alg=nothing, kwargs...)
+    return _select_algorithm(f, A, alg; kwargs...)
+end
+
+function _select_algorithm(f, A, alg::Nothing; kwargs...)
+    return default_algorithm(f, A; kwargs...)
+end
+function _select_algorithm(f, A, alg::AbstractAlgorithm; kwargs...)
+    isempty(kwargs) ||
+        throw(ArgumentError("Additional keyword arguments are not allowed when an algorithm is specified."))
     return alg
 end
-function _select_algorithm(f, A::AbstractMatrix, alg::NamedTuple)
+function _select_algorithm(f, A, alg::Symbol; kwargs...)
+    return _select_algorithm(f, A, Algorithm{alg}; kwargs...)
+end
+function _select_algorithm(f, A, alg::Type; kwargs...)
+    return _select_algorithm(f, A, alg(; kwargs...))
+end
+function _select_algorithm(f, A::AbstractMatrix, alg::NamedTuple; kwargs...)
+    isempty(kwargs) ||
+        throw(ArgumentError("Additional keyword arguments are not allowed when algorithm parameters are specified."))
     return select_algorithm(f, A; alg...)
 end
+function _select_algorithm(f, A, alg; kwargs...)
+    return throw(ArgumentError("Unknown alg $alg"))
+end
+
+@doc """
+    default_algorithm(f, A; kwargs...)
+
+Select the default algorithm for a given factorization function `f` and input `A`.
+In general, this is called by [`select_algorithm`](@ref) if no algorithm is specified
+explicitly.
+"""
+function default_algorithm end
 
 @doc """
     copy_input(f, A)

src/implementations/truncation.jl

@@ -32,6 +32,19 @@
 """
 struct NoTruncation <: TruncationStrategy end
 
+function to_truncationstrategy(trunc::TruncationStrategy)
+    return trunc
+end
+function to_truncationstrategy(trunc::NamedTuple)
+    return TruncationStrategy(; trunc...)
+end
+function to_truncationstrategy(trunc::Nothing)
+    return NoTruncation()
+end
+function to_truncationstrategy(trunc)
+    return throw(ArgumentError("Unknown truncation strategy: $trunc"))
+end
+
 # TODO: how do we deal with sorting/filters that treat zeros differently
 # since these are implicitly discarded by selecting compact/full
 
@@ -98,8 +111,9 @@
        TruncationStrategy
     components::T
 end
-TruncationIntersection(trunc::TruncationStrategy, truncs::TruncationStrategy...) = 
-    TruncationIntersection((trunc, truncs...))
+function TruncationIntersection(trunc::TruncationStrategy, truncs::TruncationStrategy...)
+    return TruncationIntersection((trunc, truncs...))
+end
 
 function Base.:&(trunc1::TruncationStrategy, trunc2::TruncationStrategy)
     return TruncationIntersection((trunc1, trunc2))

src/interface/eig.jl

@@ -90,32 +90,21 @@
 for f in (:eig_full, :eig_vals)
     f! = Symbol(f, :!)
     @eval begin
-        function select_algorithm(::typeof($f), A; kwargs...)
-            return select_algorithm($f!, A; kwargs...)
+        function default_algorithm(::typeof($f), A; kwargs...)
+            return default_algorithm($f!, A; kwargs...)
         end
-        function select_algorithm(::typeof($f!), A; alg=nothing, kwargs...)
-            if alg isa AbstractAlgorithm
-                return alg
-            elseif alg isa Symbol
-                return Algorithm{alg}(; kwargs...)
-            else
-                isnothing(alg) || throw(ArgumentError("Unknown alg $alg"))
-                return default_eig_algorithm(A; kwargs...)
-            end
+        function default_algorithm(::typeof($f!), A; kwargs...)
+            return default_eig_algorithm(A; kwargs...)
         end
     end
 end
 
 function select_algorithm(::typeof(eig_trunc), A; kwargs...)
     return select_algorithm(eig_trunc!, A; kwargs...)
 end
-function select_algorithm(::typeof(eig_trunc!), A; alg=nothing, trunc=nothing, kwargs...)
-    alg_eig = select_algorithm(eig_full!, A; alg, kwargs...)
-    alg_trunc = trunc isa TruncationStrategy ? trunc :
-                trunc isa NamedTuple ? TruncationStrategy(; trunc...) :
-                isnothing(trunc) ? NoTruncation() :
-                throw(ArgumentError("Unknown truncation strategy: $trunc"))
-    return TruncatedAlgorithm(alg_eig, alg_trunc)
+function select_algorithm(::typeof(eig_trunc!), A; trunc=nothing, kwargs...)
+    alg_eig = select_algorithm(eig_full!, A; kwargs...)
+    return TruncatedAlgorithm(alg_eig, to_truncationstrategy(trunc))
 end
 
 # Default to LAPACK 

src/interface/eigh.jl

@@ -89,32 +89,21 @@
 for f in (:eigh_full, :eigh_vals)
     f! = Symbol(f, :!)
     @eval begin
-        function select_algorithm(::typeof($f), A; kwargs...)
-            return select_algorithm($f!, A; kwargs...)
+        function default_algorithm(::typeof($f), A; kwargs...)
+            return default_algorithm($f!, A; kwargs...)
         end
-        function select_algorithm(::typeof($f!), A; alg=nothing, kwargs...)
-            if alg isa AbstractAlgorithm
-                return alg
-            elseif alg isa Symbol
-                return Algorithm{alg}(; kwargs...)
-            else
-                isnothing(alg) || throw(ArgumentError("Unknown alg $alg"))
-                return default_eigh_algorithm(A; kwargs...)
-            end
+        function default_algorithm(::typeof($f!), A; kwargs...)
+            return default_eigh_algorithm(A; kwargs...)
         end
     end
 end
 
 function select_algorithm(::typeof(eigh_trunc), A; kwargs...)
     return select_algorithm(eigh_trunc!, A; kwargs...)
 end
-function select_algorithm(::typeof(eigh_trunc!), A; alg=nothing, trunc=nothing, kwargs...)
-    alg_eigh = select_algorithm(eigh_full!, A; alg, kwargs...)
-    alg_trunc = trunc isa TruncationStrategy ? trunc :
-                trunc isa NamedTuple ? TruncationStrategy(; trunc...) :
-                isnothing(trunc) ? NoTruncation() :
-                throw(ArgumentError("Unknown truncation strategy: $trunc"))
-    return TruncatedAlgorithm(alg_eigh, alg_trunc)
+function select_algorithm(::typeof(eigh_trunc!), A; trunc=nothing, kwargs...)
+    alg_eigh = select_algorithm(eigh_full!, A; kwargs...)
+    return TruncatedAlgorithm(alg_eigh, to_truncationstrategy(trunc))
 end
 
 # Default to LAPACK 

src/interface/lq.jl

@@ -71,18 +71,11 @@
 for f in (:lq_full, :lq_compact, :lq_null)
     f! = Symbol(f, :!)
     @eval begin
-        function select_algorithm(::typeof($f), A; kwargs...)
-            return select_algorithm($f!, A; kwargs...)
+        function default_algorithm(::typeof($f), A; kwargs...)
+            return default_algorithm($f!, A; kwargs...)
         end
-        function select_algorithm(::typeof($f!), A; alg=nothing, kwargs...)
-            if alg isa AbstractAlgorithm
-                return alg
-            elseif alg isa Symbol
-                return Algorithm{alg}(; kwargs...)
-            else
-                isnothing(alg) || throw(ArgumentError("Unknown alg $alg"))
-                return default_lq_algorithm(A; kwargs...)
-            end
+        function default_algorithm(::typeof($f!), A; kwargs...)
+            return default_lq_algorithm(A; kwargs...)
         end
     end
 end

src/interface/polar.jl

@@ -63,18 +63,11 @@
 for f in (:left_polar, :right_polar)
     f! = Symbol(f, :!)
     @eval begin
-        function select_algorithm(::typeof($f), A; kwargs...)
-            return select_algorithm($f!, A; kwargs...)
+        function default_algorithm(::typeof($f), A; kwargs...)
+            return default_algorithm($f!, A; kwargs...)
         end
-        function select_algorithm(::typeof($f!), A; alg=nothing, kwargs...)
-            if alg isa AbstractAlgorithm
-                return alg
-            elseif alg isa Symbol
-                return Algorithm{alg}(; kwargs...)
-            else
-                isnothing(alg) || throw(ArgumentError("Unknown alg $alg"))
-                return default_polar_algorithm(A; kwargs...)
-            end
+        function default_algorithm(::typeof($f!), A; kwargs...)
+            return default_polar_algorithm(A; kwargs...)
         end
     end
 end

src/interface/qr.jl

@@ -71,18 +71,11 @@
 for f in (:qr_full, :qr_compact, :qr_null)
     f! = Symbol(f, :!)
     @eval begin
-        function select_algorithm(::typeof($f), A; kwargs...)
-            return select_algorithm($f!, A; kwargs...)
+        function default_algorithm(::typeof($f), A; kwargs...)
+            return default_algorithm($f!, A; kwargs...)
         end
-        function select_algorithm(::typeof($f!), A; alg=nothing, kwargs...)
-            if alg isa AbstractAlgorithm
-                return alg
-            elseif alg isa Symbol
-                return Algorithm{alg}(; kwargs...)
-            else
-                isnothing(alg) || throw(ArgumentError("Unknown alg $alg"))
-                return default_qr_algorithm(A; kwargs...)
-            end
+        function default_algorithm(::typeof($f!), A; kwargs...)
+            return default_qr_algorithm(A; kwargs...)
         end
     end
 end

src/interface/schur.jl

@@ -54,18 +54,11 @@
 for f in (:schur_full, :schur_vals)
     f! = Symbol(f, :!)
     @eval begin
-        function select_algorithm(::typeof($f), A; kwargs...)
-            return select_algorithm($f!, A; kwargs...)
+        function default_algorithm(::typeof($f), A; kwargs...)
+            return default_algorithm($f!, A; kwargs...)
         end
-        function select_algorithm(::typeof($f!), A; alg=nothing, kwargs...)
-            if alg isa AbstractAlgorithm
-                return alg
-            elseif alg isa Symbol
-                return Algorithm{alg}(; kwargs...)
-            else
-                isnothing(alg) || throw(ArgumentError("Unknown alg $alg"))
-                return default_eig_algorithm(A; kwargs...)
-            end
+        function default_algorithm(::typeof($f!), A; kwargs...)
+            return default_eig_algorithm(A; kwargs...)
         end
     end
 end

src/interface/svd.jl

@@ -93,32 +93,21 @@
 for f in (:svd_full, :svd_compact, :svd_vals)
     f! = Symbol(f, :!)
     @eval begin
-        function select_algorithm(::typeof($f), A; kwargs...)
-            return select_algorithm($f!, A; kwargs...)
+        function default_algorithm(::typeof($f), A; kwargs...)
+            return default_algorithm($f!, A; kwargs...)
         end
-        function select_algorithm(::typeof($f!), A; alg=nothing, kwargs...)
-            if alg isa AbstractAlgorithm
-                return alg
-            elseif alg isa Symbol
-                return Algorithm{alg}(; kwargs...)
-            else
-                isnothing(alg) || throw(ArgumentError("Unknown alg $alg"))
-                return default_svd_algorithm(A; kwargs...)
-            end
+        function default_algorithm(::typeof($f!), A; kwargs...)
+            return default_svd_algorithm(A; kwargs...)
         end
     end
 end
 
 function select_algorithm(::typeof(svd_trunc), A; kwargs...)
     return select_algorithm(svd_trunc!, A; kwargs...)
 end
-function select_algorithm(::typeof(svd_trunc!), A; alg=nothing, trunc=nothing, kwargs...)
-    alg_svd = select_algorithm(svd_compact!, A; alg, kwargs...)
-    alg_trunc = trunc isa TruncationStrategy ? trunc :
-                trunc isa NamedTuple ? TruncationStrategy(; trunc...) :
-                isnothing(trunc) ? NoTruncation() :
-                throw(ArgumentError("Unknown truncation strategy: $trunc"))
-    return TruncatedAlgorithm(alg_svd, alg_trunc)
+function select_algorithm(::typeof(svd_trunc!), A; trunc=nothing, kwargs...)
+    alg_svd = select_algorithm(svd_compact!, A; kwargs...)
+    return TruncatedAlgorithm(alg_svd, to_truncationstrategy(trunc))
 end
 
 # Default to LAPACK SDD for `StridedMatrix{<:BlasFloat}`