various renaming and cleanup

Author: lkdvos

ext/MatrixAlgebraKitAMDGPUExt/MatrixAlgebraKitAMDGPUExt.jl

@@ -30,7 +30,6 @@ end
 
 MatrixAlgebraKit.supports_svd(::ROCSOLVER, f::Symbol) = f in (:qr_iteration, :jacobi)
 MatrixAlgebraKit.supports_svd_full(::ROCSOLVER, f::Symbol) = f in (:qr_iteration, :jacobi)
-MatrixAlgebraKit.supports_eigh(::ROCSOLVER, f::Symbol) = f in (:jacobi, :divide_and_conquer, :qr_iteration, :bisection)
 
 function gesvd!(::ROCSOLVER, A::StridedROCMatrix, S::StridedROCVector, U::StridedROCMatrix, Vᴴ::StridedROCMatrix; kwargs...)
     m, n = size(A)

ext/MatrixAlgebraKitCUDAExt/MatrixAlgebraKitCUDAExt.jl

@@ -22,7 +22,7 @@ function MatrixAlgebraKit.default_svd_algorithm(::Type{T}; kwargs...) where {T <
     return QRIteration(; kwargs...)
 end
 function MatrixAlgebraKit.default_eig_algorithm(::Type{T}; kwargs...) where {T <: StridedCuVecOrMat{<:BlasFloat}}
-    return Simple(; kwargs...)
+    return QRIteration(; balanced = false, kwargs...)
 end
 function MatrixAlgebraKit.default_eigh_algorithm(::Type{T}; kwargs...) where {T <: StridedCuVecOrMat{<:BlasFloat}}
     return DivideAndConquer(; kwargs...)
@@ -33,8 +33,6 @@ for f in (:geqrf!, :ungqr!, :unmqr!)
     @eval $f(::CUSOLVER, args...) = YACUSOLVER.$f(args...)
 end
 
-MatrixAlgebraKit.supports_eig(::CUSOLVER, f::Symbol) = f === :simple
-MatrixAlgebraKit.supports_eigh(::CUSOLVER, f::Symbol) = f in (:jacobi, :divide_and_conquer)
 MatrixAlgebraKit.supports_svd(::CUSOLVER, f::Symbol) = f in (:qr_iteration, :jacobi, :svd_polar)
 MatrixAlgebraKit.supports_svd_full(::CUSOLVER, f::Symbol) = f in (:qr_iteration, :jacobi, :svd_polar)
 

ext/MatrixAlgebraKitGenericLinearAlgebraExt.jl

@@ -2,7 +2,7 @@ module MatrixAlgebraKitGenericLinearAlgebraExt
 
 using MatrixAlgebraKit
 using MatrixAlgebraKit: sign_safe, check_input, diagview, gaugefix!, one!, zero!, default_fixgauge
-using MatrixAlgebraKit: GLA
+using MatrixAlgebraKit: GLA, Driver
 import MatrixAlgebraKit: gesvd!, heev!
 using GenericLinearAlgebra: svd!, svdvals!, eigen!, eigvals!, Hermitian, qr!
 using LinearAlgebra: I, Diagonal, lmul!
@@ -11,12 +11,14 @@ const GlaFloat = Union{BigFloat, Complex{BigFloat}}
 const GlaStridedVecOrMatrix{T <: GlaFloat} = Union{StridedVector{T}, StridedMatrix{T}}
 MatrixAlgebraKit.default_driver(::Type{<:QRIteration}, ::Type{TA}) where {TA <: GlaStridedVecOrMatrix} = GLA()
 
-MatrixAlgebraKit.supports_eigh(::GLA, f::Symbol) = f === :qr_iteration
 MatrixAlgebraKit.supports_svd(::GLA, f::Symbol) = f === :qr_iteration
 MatrixAlgebraKit.supports_svd_full(::GLA, f::Symbol) = f === :qr_iteration
 
-function MatrixAlgebraKit.default_svd_algorithm(::Type{T}; kwargs...) where {T <: GlaStridedVecOrMatrix}
-    return QRIteration(; kwargs...)
+function MatrixAlgebraKit.default_svd_algorithm(
+        ::Type{T};
+        driver::Driver = GLA(), kwargs...
+    ) where {T <: GlaStridedVecOrMatrix}
+    return QRIteration(; driver, kwargs...)
 end
 
 function gesvd!(::GLA, A::AbstractMatrix, S::AbstractVector, U::AbstractMatrix, Vᴴ::AbstractMatrix; kwargs...)
@@ -36,8 +38,8 @@ function gesvd!(::GLA, A::AbstractMatrix, S::AbstractVector, U::AbstractMatrix,
     return S, U, Vᴴ
 end
 
-function MatrixAlgebraKit.default_eigh_algorithm(::Type{T}; kwargs...) where {T <: GlaStridedVecOrMatrix}
-    return QRIteration(; kwargs...)
+function MatrixAlgebraKit.default_eigh_algorithm(::Type{T}; driver::Driver = GLA(), kwargs...) where {T <: GlaStridedVecOrMatrix}
+    return QRIteration(; driver, kwargs...)
 end
 
 function heev!(::GLA, A::AbstractMatrix, Dd::AbstractVector, V::AbstractMatrix; kwargs...)

ext/MatrixAlgebraKitGenericSchurExt.jl

@@ -1,57 +1,51 @@
 module MatrixAlgebraKitGenericSchurExt
 
 using MatrixAlgebraKit
-using MatrixAlgebraKit: check_input, GS
-import MatrixAlgebraKit: geev!, gees!, eig_full!, eig_vals!, schur_full!, schur_vals!
+using MatrixAlgebraKit: check_input, GS, Driver
+import MatrixAlgebraKit: geev!, geevx!, gees!, eig_full!, eig_vals!, schur_full!, schur_vals!
 using LinearAlgebra: Diagonal, sorteig!
 using GenericSchur
 
 const GSFloat = Union{Float16, ComplexF16, BigFloat, Complex{BigFloat}}
 
-function MatrixAlgebraKit.default_eig_algorithm(::Type{T}; kwargs...) where {T <: StridedMatrix{<:GSFloat}}
-    return Simple(; kwargs...)
+function MatrixAlgebraKit.default_eig_algorithm(
+        ::Type{T};
+        balanced::Bool = false, driver::Driver = GS(), kwargs...
+    ) where {T <: StridedMatrix{<:GSFloat}}
+    return QRIteration(; driver, balanced, kwargs...)
 end
 
-MatrixAlgebraKit.default_driver(::Type{<:Simple}, ::Type{TA}) where {TA <: StridedMatrix{<:GSFloat}} = GS()
-
-MatrixAlgebraKit.supports_schur(::GS, f::Symbol) = f === :simple
-MatrixAlgebraKit.supports_eig(::GS, f::Symbol) = f === :simple
-
 function geev!(::GS, A::AbstractMatrix, Dd::AbstractVector, V::AbstractMatrix; kwargs...)
     D, Vmat = GenericSchur.eigen!(A)
     copyto!(Dd, D)
     length(V) > 0 && copyto!(V, Vmat)
     return Dd, V
 end
 
-function gees!(::GS, A::AbstractMatrix, Z::AbstractMatrix, vals::AbstractVector)
+function gees!(driver::GS, A::AbstractMatrix, Z::AbstractMatrix, vals::AbstractVector)
     S = GenericSchur.gschur(A)
     copyto!(A, S.T)
-    if length(Z) > 0
-        copyto!(Z, S.Z)
-        copyto!(vals, S.values)
-    else
-        copyto!(vals, sorteig!(S.values))
-    end
+    length(Z) > 0 && copyto!(Z, S.Z)
+    copyto!(vals, sorteig!(S.values))
     return A, Z, vals
 end
 
 Base.@deprecate(
     eig_full!(A, DV, alg::GS_QRIteration),
-    eig_full!(A, DV, Simple(; driver = GS(), alg.kwargs...))
+    eig_full!(A, DV, QRIteration(; driver = GS(), alg.kwargs...))
 )
 Base.@deprecate(
     eig_vals!(A, D, alg::GS_QRIteration),
-    eig_vals!(A, D, Simple(; driver = GS(), alg.kwargs...))
+    eig_vals!(A, D, QRIteration(; driver = GS(), alg.kwargs...))
 )
 
 Base.@deprecate(
     schur_full!(A, TZv, alg::GS_QRIteration),
-    schur_full!(A, TZv, Simple(; driver = GS(), alg.kwargs...))
+    schur_full!(A, TZv, QRIteration(; driver = GS(), alg.kwargs...))
 )
 Base.@deprecate(
     schur_vals!(A, vals, alg::GS_QRIteration),
-    schur_vals!(A, vals, Simple(; driver = GS(), alg.kwargs...))
+    schur_vals!(A, vals, QRIteration(; driver = GS(), alg.kwargs...))
 )
 
 end

src/MatrixAlgebraKit.jl

@@ -33,7 +33,7 @@ export left_orth!, right_orth!, left_null!, right_null!
 
 export Householder, Native_HouseholderQR, Native_HouseholderLQ
 export DivideAndConquer, SafeDivideAndConquer, QRIteration, Bisection, Jacobi, SVDViaPolar
-export MultipleRelativelyRobustRepresentations, Simple, Expert
+export RobustRepresentations
 export LAPACK_HouseholderQR, LAPACK_HouseholderLQ, LAPACK_Simple, LAPACK_Expert,
     LAPACK_QRIteration, LAPACK_Bisection, LAPACK_MultipleRelativelyRobustRepresentations,
     LAPACK_DivideAndConquer, LAPACK_Jacobi, LAPACK_SafeDivideAndConquer

src/implementations/eig.jl

@@ -90,84 +90,60 @@ end
 # ==========================
 #      IMPLEMENTATIONS
 # ==========================
-for f! in (:geev!, :geevx!)
-    @eval $f!(driver::Driver, args...) = throw(ArgumentError("$driver does not provide $f!"))
+
+geev!(driver::Driver, args...; kwargs...) = throw(ArgumentError("$driver does not provide $f!"))
+function geevx!(driver::Driver, A, Dd, V; kwargs...)
+    @warn "$driver does not provide `geevx!`, falling back to `geev!`" maxlog = 1
+    return geev!(driver, A, Dd, V; kwargs...)
 end
+_has_geevx!(::Driver) = false
 
 # LAPACK implementations
 for f! in (:geev!, :geevx!)
     @eval $f!(::LAPACK, args...; kwargs...) = YALAPACK.$f!(args...; kwargs...)
 end
+_has_geevx!(::LAPACK) = true
 
-supports_eig(::Driver, ::Symbol) = false
-supports_eig(::LAPACK, f::Symbol) = f in (:simple, :expert)
-
-for (f, f_lapack!, Alg) in (
-        (:simple, :geev!, :Simple),
-        (:expert, :geevx!, :Expert),
-    )
-    f_eig_full! = Symbol(f, :_eig_full!)
-    f_eig_vals! = Symbol(f, :_eig_vals!)
+# driver dispatch
+@inline qr_iteration_eig_full!(A, Dd, V; driver::Driver = DefaultDriver(), kwargs...) =
+    qr_iteration_eig_full!(driver, A, Dd, V; kwargs...)
+@inline qr_iteration_eig_vals!(A, D, V; driver::Driver = DefaultDriver(), kwargs...) =
+    qr_iteration_eig_vals!(driver, A, D, V; kwargs...)
 
-    # MatrixAlgebraKit wrappers
-    @eval begin
-        function eig_full!(A::AbstractMatrix, DV, alg::$Alg)
-            check_input(eig_full!, A, DV, alg)
-            D, V = DV
-            Dd, V = $f_eig_full!(A, diagview(D), V; alg.kwargs...)
-            return D, V
-        end
-        function eig_vals!(A::AbstractMatrix, D, alg::$Alg)
-            check_input(eig_vals!, A, D, alg)
-            V = similar(A, complex(eltype(A)), (size(A, 1), 0))
-            $f_eig_vals!(A, D, V; alg.kwargs...)
-            return D
-        end
-    end
+@inline qr_iteration_eig_full!(::DefaultDriver, A, Dd, V; kwargs...) =
+    qr_iteration_eig_full!(default_driver(QRIteration, A), A, Dd, V; kwargs...)
+@inline qr_iteration_eig_vals!(::DefaultDriver, A, D, V; kwargs...) =
+    qr_iteration_eig_vals!(default_driver(QRIteration, A), A, D, V; kwargs...)
 
-    # driver dispatch
-    @eval begin
-        @inline $f_eig_full!(A, Dd, V; driver::Driver = DefaultDriver(), kwargs...) =
-            $f_eig_full!(driver, A, Dd, V; kwargs...)
-        @inline $f_eig_vals!(A, D, V; driver::Driver = DefaultDriver(), kwargs...) =
-            $f_eig_vals!(driver, A, D, V; kwargs...)
-
-        @inline $f_eig_full!(::DefaultDriver, A, Dd, V; kwargs...) =
-            $f_eig_full!(default_driver($Alg, A), A, Dd, V; kwargs...)
-        @inline $f_eig_vals!(::DefaultDriver, A, D, V; kwargs...) =
-            $f_eig_vals!(default_driver($Alg, A), A, D, V; kwargs...)
-    end
+# Implementation
+function qr_iteration_eig_full!(
+        driver::Driver, A, Dd, V;
+        fixgauge::Bool = default_fixgauge(), balanced::Bool = _has_geevx!(driver), kwargs...
+    )
+    (balanced ? geevx! : geev!)(driver, A, Dd, V; kwargs...)
+    fixgauge && gaugefix!(eig_full!, V)
+    return Dd, V
+end
+function qr_iteration_eig_vals!(
+        driver::Driver, A, D, V;
+        fixgauge::Bool = default_fixgauge(), balanced::Bool = _has_geevx!(driver), kwargs...
+    )
+    (balanced ? geevx! : geev!)(driver, A, D, V; kwargs...)
+    return D
+end
 
-    # Implementation
-    @eval begin
-        function $f_eig_full!(driver::Driver, A, Dd, V; fixgauge::Bool = default_fixgauge(), kwargs...)
-            supports_eig(driver, $(QuoteNode(f))) ||
-                throw(ArgumentError(LazyString("driver ", driver, " does not provide `$($(QuoteNode(f_lapack!)))`")))
-            $(
-                if f == :simple
-                    :(isempty(kwargs) || throw(ArgumentError(LazyString("invalid keyword arguments for ", driver, " simple eig"))))
-                else
-                    :nothing
-                end
-            )
-            $f_lapack!(driver, A, Dd, V; kwargs...)
-            fixgauge && gaugefix!(eig_full!, V)
-            return Dd, V
-        end
-        function $f_eig_vals!(driver::Driver, A, D, V; fixgauge::Bool = default_fixgauge(), kwargs...)
-            supports_eig(driver, $(QuoteNode(f))) ||
-                throw(ArgumentError(LazyString("driver ", driver, " does not provide `$($(QuoteNode(f_lapack!)))`")))
-            $(
-                if f == :simple
-                    :(isempty(kwargs) || throw(ArgumentError(LazyString("invalid keyword arguments for ", driver, " simple eig"))))
-                else
-                    :nothing
-                end
-            )
-            $f_lapack!(driver, A, D, V; kwargs...)
-            return D
-        end
-    end
+# Top-level QRIteration dispatch
+function eig_full!(A::AbstractMatrix, DV, alg::QRIteration)
+    check_input(eig_full!, A, DV, alg)
+    D, V = DV
+    qr_iteration_eig_full!(A, diagview(D), V; alg.kwargs...)
+    return D, V
+end
+function eig_vals!(A::AbstractMatrix, D, alg::QRIteration)
+    check_input(eig_vals!, A, D, alg)
+    V = similar(A, complex(eltype(A)), (size(A, 1), 0))
+    qr_iteration_eig_vals!(A, D, V; alg.kwargs...)
+    return D
 end
 
 function eig_trunc!(A, DV, alg::TruncatedAlgorithm)
@@ -212,24 +188,23 @@ end
 
 # Deprecations
 # ------------
-for algtype in (:Simple, :Expert)
-    lapack_algtype = Symbol(:LAPACK_, algtype)
+for (lapack_algtype, balanced_val) in ((:LAPACK_Simple, false), (:LAPACK_Expert, true))
     @eval begin
         Base.@deprecate(
             eig_full!(A, DV, alg::$lapack_algtype),
-            eig_full!(A, DV, $algtype(; driver = LAPACK(), alg.kwargs...))
+            eig_full!(A, DV, QRIteration(; balanced = $balanced_val, alg.kwargs...))
         )
         Base.@deprecate(
             eig_vals!(A, D, alg::$lapack_algtype),
-            eig_vals!(A, D, $algtype(; driver = LAPACK(), alg.kwargs...))
+            eig_vals!(A, D, QRIteration(; balanced = $balanced_val, alg.kwargs...))
         )
     end
 end
 Base.@deprecate(
     eig_full!(A, DV, alg::CUSOLVER_Simple),
-    eig_full!(A, DV, Simple(; driver = CUSOLVER(), alg.kwargs...))
+    eig_full!(A, DV, QRIteration(; driver = CUSOLVER(), alg.kwargs...))
 )
 Base.@deprecate(
     eig_vals!(A, D, alg::CUSOLVER_Simple),
-    eig_vals!(A, D, Simple(; driver = CUSOLVER(), alg.kwargs...))
+    eig_vals!(A, D, QRIteration(; driver = CUSOLVER(), alg.kwargs...))
 )

src/implementations/eigh.jl

@@ -108,11 +108,8 @@ for f! in (:heevr!, :heevd!, :heev!, :heevx!)
     @eval $f!(::LAPACK, args...; kwargs...) = YALAPACK.$f!(args...; kwargs...)
 end
 
-supports_eigh(::Driver, ::Symbol) = false
-supports_eigh(::LAPACK, f::Symbol) = f in (:mrrr, :divide_and_conquer, :qr_iteration, :bisection)
-
 for (f, f_lapack!, Alg) in (
-        (:mrrr, :heevr!, :MultipleRelativelyRobustRepresentations),
+        (:mrrr, :heevr!, :RobustRepresentations),
         (:divide_and_conquer, :heevd!, :DivideAndConquer),
         (:qr_iteration, :heev!, :QRIteration),
         (:bisection, :heevx!, :Bisection),
@@ -153,15 +150,11 @@ for (f, f_lapack!, Alg) in (
     # Implementation
     @eval begin
         function $f_eigh_full!(driver::Driver, A, Dd, V; fixgauge::Bool = default_fixgauge(), kwargs...)
-            supports_eigh(driver, $(QuoteNode(f))) ||
-                throw(ArgumentError(LazyString("driver ", driver, " does not provide `$($(QuoteNode(f_lapack!)))`")))
             $f_lapack!(driver, A, Dd, V; kwargs...)
             fixgauge && gaugefix!(eigh_full!, V)
             return Dd, V
         end
         function $f_eigh_vals!(driver::Driver, A, D, V; fixgauge::Bool = default_fixgauge(), kwargs...)
-            supports_eigh(driver, $(QuoteNode(f))) ||
-                throw(ArgumentError(LazyString("driver ", driver, " does not provide `$($(QuoteNode(f_lapack!)))`")))
             $f_lapack!(driver, A, D, V; kwargs...)
             return D
         end
@@ -213,7 +206,15 @@ end
 
 # Deprecations
 # ------------
-for algtype in (:MultipleRelativelyRobustRepresentations, :DivideAndConquer, :QRIteration, :Bisection)
+Base.@deprecate(
+    eigh_full!(A, DV, alg::LAPACK_MultipleRelativelyRobustRepresentations),
+    eigh_full!(A, DV, RobustRepresentations(; driver = LAPACK(), alg.kwargs...))
+)
+Base.@deprecate(
+    eigh_vals!(A, D, alg::LAPACK_MultipleRelativelyRobustRepresentations),
+    eigh_vals!(A, D, RobustRepresentations(; driver = LAPACK(), alg.kwargs...))
+)
+for algtype in (:DivideAndConquer, :QRIteration, :Bisection)
     lapack_algtype = Symbol(:LAPACK_, algtype)
     @eval begin
         Base.@deprecate(