rework type stability

Author: lkdvos

ext/MatrixAlgebraKitAMDGPUExt/MatrixAlgebraKitAMDGPUExt.jl

@@ -14,7 +14,7 @@ using LinearAlgebra: BlasFloat
 
 include("yarocsolver.jl")
 
-MatrixAlgebraKit.default_householder_driver(::StridedROCMatrix{<:BlasFloat}) = ROCSOLVER()
+MatrixAlgebraKit.default_householder_driver(::Type{A}) where {A <: StridedROCMatrix{<:BlasFloat}} = ROCSOLVER()
 function MatrixAlgebraKit.default_svd_algorithm(::Type{T}; kwargs...) where {T <: StridedROCMatrix}
     return ROCSOLVER_QRIteration(; kwargs...)
 end

ext/MatrixAlgebraKitCUDAExt/MatrixAlgebraKitCUDAExt.jl

@@ -15,7 +15,7 @@ using LinearAlgebra: BlasFloat
 
 include("yacusolver.jl")
 
-MatrixAlgebraKit.default_householder_driver(::StridedCuVecOrMat{<:BlasFloat}) = CUSOLVER()
+MatrixAlgebraKit.default_householder_driver(::Type{A}) where {A <: StridedCuVecOrMat{<:BlasFloat}} = CUSOLVER()
 function MatrixAlgebraKit.default_svd_algorithm(::Type{T}; kwargs...) where {TT <: BlasFloat, T <: StridedCuVecOrMat{TT}}
     return CUSOLVER_QRIteration(; kwargs...)
 end

src/algorithms.jl

@@ -88,7 +88,7 @@ Finally, the same behavior is obtained when the keyword arguments are
 passed as the third positional argument in the form of a `NamedTuple`. 
 """ select_algorithm
 
-Base.@assume_effects :foldable function select_algorithm(f::F, A, alg::Alg = nothing; kwargs...) where {F, Alg}
+@inline function select_algorithm(f::F, A, alg::Alg = nothing; kwargs...) where {F, Alg}
     if isnothing(alg)
         return default_algorithm(f, A; kwargs...)
     elseif alg isa Symbol

src/interface/decompositions.jl

@@ -80,13 +80,17 @@ Depending on the driver, various other keywords may be (un)available to customiz
 """
 @algdef Householder
 
-default_householder_driver(A) = Native()
+default_householder_driver(A) = default_householder_driver(typeof(A))
+default_householder_driver(::Type) = Native()
 
-default_householder_driver(::YALAPACK.MaybeBlasMat) = LAPACK()
+default_householder_driver(::Type{A}) where {A <: YALAPACK.MaybeBlasMat} = LAPACK()
 
 # note: StridedVector fallback is needed for handling reshaped parent types
-default_householder_driver(::StridedVector{<:BlasFloat}) = LAPACK()
-default_householder_driver(A::Union{SubArray, Base.ReshapedArray}) = default_householder_driver(parent(A))
+default_householder_driver(::Type{A}) where {A <: StridedVector{<:BlasFloat}} = LAPACK()
+default_householder_driver(::Type{<:SubArray{T, N, A}}) where {T, N, A} =
+    default_householder_driver(A)
+default_householder_driver(::Type{<:Base.ReshapedArray{T, N, A}}) where {T, N, A} =
+    default_householder_driver(A)
 
 
 # General Eigenvalue Decomposition

src/interface/lq.jl

@@ -70,10 +70,9 @@ See also [`qr_full(!)`](@ref lq_full) and [`qr_compact(!)`](@ref lq_compact).
 # -------------------
 default_lq_algorithm(A; kwargs...) = default_lq_algorithm(typeof(A); kwargs...)
 
-default_lq_algorithm(T::Type; kwargs...) =
-    throw(MethodError(default_lq_algorithm, (T,)))
-default_lq_algorithm(::Type{T}; kwargs...) where {T <: AbstractMatrix} =
-    Householder(; kwargs...)
+default_lq_algorithm(T::Type; kwargs...) = throw(MethodError(default_lq_algorithm, (T,)))
+default_lq_algorithm(::Type{T}; driver = default_householder_driver(T), kwargs...) where {T <: AbstractMatrix} =
+    Householder(; driver, kwargs...)
 default_lq_algorithm(::Type{T}; kwargs...) where {T <: Diagonal} =
     DiagonalAlgorithm(; kwargs...)
 default_lq_algorithm(::Type{<:Base.ReshapedArray{T, N, A}}) where {T, N, A} =

src/interface/qr.jl

@@ -70,10 +70,9 @@ See also [`lq_full(!)`](@ref lq_full) and [`lq_compact(!)`](@ref lq_compact).
 # -------------------
 default_qr_algorithm(A; kwargs...) = default_qr_algorithm(typeof(A); kwargs...)
 
-default_qr_algorithm(T::Type; kwargs...) =
-    throw(MethodError(default_qr_algorithm, (T,)))
-default_qr_algorithm(::Type{T}; kwargs...) where {T <: AbstractMatrix} =
-    Householder(; kwargs...)
+default_qr_algorithm(T::Type; kwargs...) = throw(MethodError(default_qr_algorithm, (T,)))
+default_qr_algorithm(::Type{T}; driver = default_householder_driver(T), kwargs...) where {T <: AbstractMatrix} =
+    Householder(; driver, kwargs...)
 default_qr_algorithm(::Type{T}; kwargs...) where {T <: Diagonal} =
     DiagonalAlgorithm(; kwargs...)
 default_qr_algorithm(::Type{<:Base.ReshapedArray{T, N, A}}) where {T, N, A} =

test/algorithms.jl

@@ -2,7 +2,7 @@ using MatrixAlgebraKit
 using Test
 using TestExtras
 using MatrixAlgebraKit: LAPACK_SVDAlgorithm, PolarViaSVD, TruncatedAlgorithm,
-    default_algorithm, select_algorithm, Householder
+    default_algorithm, select_algorithm, Householder, LAPACK
 
 @testset "default_algorithm" begin
     A = randn(3, 3)
@@ -17,21 +17,21 @@ using MatrixAlgebraKit: LAPACK_SVDAlgorithm, PolarViaSVD, TruncatedAlgorithm,
             LAPACK_MultipleRelativelyRobustRepresentations()
     end
     for f in (lq_full!, lq_full, lq_compact!, lq_compact, lq_null!, lq_null)
-        @test @constinferred(default_algorithm(f, A)) == Householder()
+        @test @constinferred(default_algorithm(f, A)) == Householder(; driver = LAPACK())
     end
     for f in (left_polar!, left_polar, right_polar!, right_polar)
         @test @constinferred(default_algorithm(f, A)) ==
             PolarViaSVD(LAPACK_DivideAndConquer())
     end
     for f in (qr_full!, qr_full, qr_compact!, qr_compact, qr_null!, qr_null)
-        @test @constinferred(default_algorithm(f, A)) == Householder()
+        @test @constinferred(default_algorithm(f, A)) == Householder(; driver = LAPACK())
     end
     for f in (schur_full!, schur_full, schur_vals!, schur_vals)
         @test @constinferred(default_algorithm(f, A)) === LAPACK_Expert()
     end
 
     @test @constinferred(default_algorithm(qr_compact!, A; blocksize = 2)) ==
-        Householder(; blocksize = 2)
+        Householder(; driver = LAPACK(), blocksize = 2)
 end
 
 @testset "select_algorithm" begin