From 2c0d8ab64991bc2889658aa6eb0a440821a01403 Mon Sep 17 00:00:00 2001 From: Christopher Rackauckas Date: Sat, 1 Feb 2025 12:36:42 -0500 Subject: [PATCH 01/27] Make RecursiveFactorization.jl optional RecrusiveFactorization.jl brings in the LoopVectorization.jl stack, and so it's not a small dependency. It is a good thing to default to often, but we can make it a bit more optional in order to greatly decrease load times. --- Project.toml | 3 +- ext/LinearSolveRecursiveFactorization.jl | 55 +++++++++++++++++++ src/LinearSolve.jl | 1 - src/default.jl | 5 +- src/extension_algs.jl | 26 +++++++++ src/factorization.jl | 69 ------------------------ 6 files changed, 86 insertions(+), 73 deletions(-) create mode 100644 ext/LinearSolveRecursiveFactorization.jl diff --git a/Project.toml b/Project.toml index 5bcc0f4cb..6c585dc2b 100644 --- a/Project.toml +++ b/Project.toml @@ -21,7 +21,6 @@ MKL_jll = "856f044c-d86e-5d09-b602-aeab76dc8ba7" Markdown = "d6f4376e-aef5-505a-96c1-9c027394607a" PrecompileTools = "aea7be01-6a6a-4083-8856-8a6e6704d82a" Preferences = "21216c6a-2e73-6563-6e65-726566657250" -RecursiveFactorization = "f2c3362d-daeb-58d1-803e-2bc74f2840b4" Reexport = "189a3867-3050-52da-a836-e630ba90ab69" SciMLBase = "0bca4576-84f4-4d90-8ffe-ffa030f20462" SciMLOperators = "c0aeaf25-5076-4817-a8d5-81caf7dfa961" @@ -45,6 +44,7 @@ KrylovKit = "0b1a1467-8014-51b9-945f-bf0ae24f4b77" Metal = "dde4c033-4e86-420c-a63e-0dd931031962" Pardiso = "46dd5b70-b6fb-5a00-ae2d-e8fea33afaf2" RecursiveArrayTools = "731186ca-8d62-57ce-b412-fbd966d074cd" +RecursiveFactorization = "f2c3362d-daeb-58d1-803e-2bc74f2840b4" [extensions] LinearSolveBandedMatricesExt = "BandedMatrices" @@ -60,6 +60,7 @@ LinearSolveKrylovKitExt = "KrylovKit" LinearSolveMetalExt = "Metal" LinearSolvePardisoExt = "Pardiso" LinearSolveRecursiveArrayToolsExt = "RecursiveArrayTools" +LinearSolveRecursiveFactorizationExt = "RecursiveFactorization" [compat] AllocCheck = "0.2" diff --git a/ext/LinearSolveRecursiveFactorization.jl b/ext/LinearSolveRecursiveFactorization.jl new file mode 100644 index 000000000..9dbda4402 --- /dev/null +++ b/ext/LinearSolveRecursiveFactorization.jl @@ -0,0 +1,55 @@ +module LinearSolveRecursiveFactorization + +using LinearSolve, RecursiveArrayTools, LinearAlgebra, RecursiveFactorization + +function LinearSolve.init_cacheval(alg::RFLUFactorization, A, b, u, Pl, Pr, maxiters::Int, + abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) + ipiv = Vector{LinearAlgebra.BlasInt}(undef, min(size(A)...)) + ArrayInterface.lu_instance(convert(AbstractMatrix, A)), ipiv +end + +function LinearSolve.init_cacheval(alg::RFLUFactorization, A::Matrix{Float64}, b, u, Pl, Pr, + maxiters::Int, + abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) + ipiv = Vector{LinearAlgebra.BlasInt}(undef, 0) + PREALLOCATED_LU, ipiv +end + +function LinearSolve.init_cacheval(alg::RFLUFactorization, + A::Union{AbstractSparseArray, AbstractSciMLOperator}, b, u, Pl, Pr, + maxiters::Int, + abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) + nothing, nothing +end + +function LinearSolve.init_cacheval(alg::RFLUFactorization, + A::Union{Diagonal, SymTridiagonal, Tridiagonal}, b, u, Pl, Pr, + maxiters::Int, + abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) + nothing, nothing +end + +function SciMLBase.solve!(cache::LinearCache, alg::RFLUFactorization{P, T}; + kwargs...) where {P, T} + A = cache.A + A = convert(AbstractMatrix, A) + fact, ipiv = LinearSolve.@get_cacheval(cache, :RFLUFactorization) + if cache.isfresh + if length(ipiv) != min(size(A)...) + ipiv = Vector{LinearAlgebra.BlasInt}(undef, min(size(A)...)) + end + fact = RecursiveFactorization.lu!(A, ipiv, Val(P), Val(T), check = false) + cache.cacheval = (fact, ipiv) + + if !LinearAlgebra.issuccess(fact) + return SciMLBase.build_linear_solution( + alg, cache.u, nothing, cache; retcode = ReturnCode.Failure) + end + + cache.isfresh = false + end + y = ldiv!(cache.u, @get_cacheval(cache, :RFLUFactorization)[1], cache.b) + SciMLBase.build_linear_solution(alg, y, nothing, cache) +end + +end \ No newline at end of file diff --git a/src/LinearSolve.jl b/src/LinearSolve.jl index 5c83b46aa..254c89c0b 100644 --- a/src/LinearSolve.jl +++ b/src/LinearSolve.jl @@ -6,7 +6,6 @@ end import PrecompileTools using ArrayInterface -using RecursiveFactorization using Base: cache_dependencies, Bool using LinearAlgebra using SparseArrays diff --git a/src/default.jl b/src/default.jl index a0ebb705f..e39aa5625 100644 --- a/src/default.jl +++ b/src/default.jl @@ -178,14 +178,15 @@ function defaultalg(A, b, assump::OperatorAssumptions{Bool}) (__conditioning(assump) === OperatorCondition.IllConditioned || __conditioning(assump) === OperatorCondition.WellConditioned) if length(b) <= 10 - DefaultAlgorithmChoice.RFLUFactorization + DefaultAlgorithmChoice.GenericLUFactorization elseif appleaccelerate_isavailable() && b isa Array && eltype(b) <: Union{Float32, Float64, ComplexF32, ComplexF64} DefaultAlgorithmChoice.AppleAccelerateLUFactorization elseif (length(b) <= 100 || (isopenblas() && length(b) <= 500) || (usemkl && length(b) <= 200)) && (A === nothing ? eltype(b) <: Union{Float32, Float64} : - eltype(A) <: Union{Float32, Float64}) + eltype(A) <: Union{Float32, Float64}) && + Base.get_extension(@__MODULE__, :LinearSolveRecursiveFactorizationExt) DefaultAlgorithmChoice.RFLUFactorization #elseif A === nothing || A isa Matrix # alg = FastLUFactorization() diff --git a/src/extension_algs.jl b/src/extension_algs.jl index da444912b..8e21ac9b6 100644 --- a/src/extension_algs.jl +++ b/src/extension_algs.jl @@ -82,6 +82,32 @@ struct CudaOffloadFactorization <: LinearSolve.AbstractFactorization end end +## RFLUFactorization + +""" +`RFLUFactorization()` + +A fast pure Julia LU-factorization implementation +using RecursiveFactorization.jl. This is by far the fastest LU-factorization +implementation, usually outperforming OpenBLAS and MKL for smaller matrices +(<500x500), but currently optimized only for Base `Array` with `Float32` or `Float64`. +Additional optimization for complex matrices is in the works. +""" +struct RFLUFactorization{P, T} <: AbstractDenseFactorization + function RFLUFactorization(::Val{P}, ::Val{T}) where {P, T} + ext = Base.get_extension(@__MODULE__, :LinearSolveRecursiveFactorizationExt) + if ext === nothing + error("RFLUFactorization requires that RecursiveFactorization.jl is loaded, i.e. `using RecursiveFactorization`") + else + return new{P, T}() + end + end +end + +function RFLUFactorization(; pivot = Val(true), thread = Val(true)) + RFLUFactorization(pivot, thread) +end + """ ```julia MKLPardisoFactorize(; nprocs::Union{Int, Nothing} = nothing, diff --git a/src/factorization.jl b/src/factorization.jl index 74631d158..c172e65c1 100644 --- a/src/factorization.jl +++ b/src/factorization.jl @@ -989,75 +989,6 @@ function SciMLBase.solve!(cache::LinearCache, alg::CHOLMODFactorization; kwargs. SciMLBase.build_linear_solution(alg, cache.u, nothing, cache) end -## RFLUFactorization - -""" -`RFLUFactorization()` - -A fast pure Julia LU-factorization implementation -using RecursiveFactorization.jl. This is by far the fastest LU-factorization -implementation, usually outperforming OpenBLAS and MKL for smaller matrices -(<500x500), but currently optimized only for Base `Array` with `Float32` or `Float64`. -Additional optimization for complex matrices is in the works. -""" -struct RFLUFactorization{P, T} <: AbstractDenseFactorization - RFLUFactorization(::Val{P}, ::Val{T}) where {P, T} = new{P, T}() -end - -function RFLUFactorization(; pivot = Val(true), thread = Val(true)) - RFLUFactorization(pivot, thread) -end - -function init_cacheval(alg::RFLUFactorization, A, b, u, Pl, Pr, maxiters::Int, - abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) - ipiv = Vector{LinearAlgebra.BlasInt}(undef, min(size(A)...)) - ArrayInterface.lu_instance(convert(AbstractMatrix, A)), ipiv -end - -function init_cacheval(alg::RFLUFactorization, A::Matrix{Float64}, b, u, Pl, Pr, - maxiters::Int, - abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) - ipiv = Vector{LinearAlgebra.BlasInt}(undef, 0) - PREALLOCATED_LU, ipiv -end - -function init_cacheval(alg::RFLUFactorization, - A::Union{AbstractSparseArray, AbstractSciMLOperator}, b, u, Pl, Pr, - maxiters::Int, - abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) - nothing, nothing -end - -function init_cacheval(alg::RFLUFactorization, - A::Union{Diagonal, SymTridiagonal, Tridiagonal}, b, u, Pl, Pr, - maxiters::Int, - abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) - nothing, nothing -end - -function SciMLBase.solve!(cache::LinearCache, alg::RFLUFactorization{P, T}; - kwargs...) where {P, T} - A = cache.A - A = convert(AbstractMatrix, A) - fact, ipiv = @get_cacheval(cache, :RFLUFactorization) - if cache.isfresh - if length(ipiv) != min(size(A)...) - ipiv = Vector{LinearAlgebra.BlasInt}(undef, min(size(A)...)) - end - fact = RecursiveFactorization.lu!(A, ipiv, Val(P), Val(T), check = false) - cache.cacheval = (fact, ipiv) - - if !LinearAlgebra.issuccess(fact) - return SciMLBase.build_linear_solution( - alg, cache.u, nothing, cache; retcode = ReturnCode.Failure) - end - - cache.isfresh = false - end - y = ldiv!(cache.u, @get_cacheval(cache, :RFLUFactorization)[1], cache.b) - SciMLBase.build_linear_solution(alg, y, nothing, cache) -end - ## NormalCholeskyFactorization """ From 75d28138c3598f547463451b33a591d33fec19cf Mon Sep 17 00:00:00 2001 From: Christopher Rackauckas Date: Sat, 1 Feb 2025 12:59:53 -0500 Subject: [PATCH 02/27] get it working --- ext/LinearSolveRecursiveFactorization.jl | 27 ---------------------- src/LinearSolve.jl | 3 +-- src/default.jl | 2 +- src/extension_algs.jl | 11 ++++----- src/factorization.jl | 29 ++++++++++++++++++++++++ 5 files changed, 36 insertions(+), 36 deletions(-) diff --git a/ext/LinearSolveRecursiveFactorization.jl b/ext/LinearSolveRecursiveFactorization.jl index 9dbda4402..b023017d7 100644 --- a/ext/LinearSolveRecursiveFactorization.jl +++ b/ext/LinearSolveRecursiveFactorization.jl @@ -2,33 +2,6 @@ module LinearSolveRecursiveFactorization using LinearSolve, RecursiveArrayTools, LinearAlgebra, RecursiveFactorization -function LinearSolve.init_cacheval(alg::RFLUFactorization, A, b, u, Pl, Pr, maxiters::Int, - abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) - ipiv = Vector{LinearAlgebra.BlasInt}(undef, min(size(A)...)) - ArrayInterface.lu_instance(convert(AbstractMatrix, A)), ipiv -end - -function LinearSolve.init_cacheval(alg::RFLUFactorization, A::Matrix{Float64}, b, u, Pl, Pr, - maxiters::Int, - abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) - ipiv = Vector{LinearAlgebra.BlasInt}(undef, 0) - PREALLOCATED_LU, ipiv -end - -function LinearSolve.init_cacheval(alg::RFLUFactorization, - A::Union{AbstractSparseArray, AbstractSciMLOperator}, b, u, Pl, Pr, - maxiters::Int, - abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) - nothing, nothing -end - -function LinearSolve.init_cacheval(alg::RFLUFactorization, - A::Union{Diagonal, SymTridiagonal, Tridiagonal}, b, u, Pl, Pr, - maxiters::Int, - abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) - nothing, nothing -end - function SciMLBase.solve!(cache::LinearCache, alg::RFLUFactorization{P, T}; kwargs...) where {P, T} A = cache.A diff --git a/src/LinearSolve.jl b/src/LinearSolve.jl index 254c89c0b..485f3c5af 100644 --- a/src/LinearSolve.jl +++ b/src/LinearSolve.jl @@ -126,6 +126,7 @@ end const BLASELTYPES = Union{Float32, Float64, ComplexF32, ComplexF64} include("common.jl") +include("extension_algs.jl") include("factorization.jl") include("appleaccelerate.jl") include("mkl.jl") @@ -136,7 +137,6 @@ include("preconditioners.jl") include("solve_function.jl") include("default.jl") include("init.jl") -include("extension_algs.jl") include("adjoint.jl") include("deprecated.jl") @@ -211,7 +211,6 @@ PrecompileTools.@compile_workload begin prob = LinearProblem(A, b) sol = solve(prob) sol = solve(prob, LUFactorization()) - sol = solve(prob, RFLUFactorization()) sol = solve(prob, KrylovJL_GMRES()) end diff --git a/src/default.jl b/src/default.jl index e39aa5625..0820a2a39 100644 --- a/src/default.jl +++ b/src/default.jl @@ -266,7 +266,7 @@ function algchoice_to_alg(alg::Symbol) elseif alg === :GenericLUFactorization GenericLUFactorization() elseif alg === :RFLUFactorization - RFLUFactorization() + RFLUFactorization(throwerror=false) elseif alg === :BunchKaufmanFactorization BunchKaufmanFactorization() elseif alg === :CHOLMODFactorization diff --git a/src/extension_algs.jl b/src/extension_algs.jl index 8e21ac9b6..775acb1e4 100644 --- a/src/extension_algs.jl +++ b/src/extension_algs.jl @@ -94,18 +94,17 @@ implementation, usually outperforming OpenBLAS and MKL for smaller matrices Additional optimization for complex matrices is in the works. """ struct RFLUFactorization{P, T} <: AbstractDenseFactorization - function RFLUFactorization(::Val{P}, ::Val{T}) where {P, T} + function RFLUFactorization(::Val{P}, ::Val{T}; throwerror=true) where {P, T} ext = Base.get_extension(@__MODULE__, :LinearSolveRecursiveFactorizationExt) if ext === nothing - error("RFLUFactorization requires that RecursiveFactorization.jl is loaded, i.e. `using RecursiveFactorization`") - else - return new{P, T}() + throwerror && error("RFLUFactorization requires that RecursiveFactorization.jl is loaded, i.e. `using RecursiveFactorization`") end + return new{P, T}() end end -function RFLUFactorization(; pivot = Val(true), thread = Val(true)) - RFLUFactorization(pivot, thread) +function RFLUFactorization(; pivot = Val(true), thread = Val(true), throwerror=true) + RFLUFactorization(pivot, thread; throwerror) end """ diff --git a/src/factorization.jl b/src/factorization.jl index c172e65c1..81aeef84e 100644 --- a/src/factorization.jl +++ b/src/factorization.jl @@ -29,6 +29,35 @@ function init_cacheval(alg::AbstractFactorization, A, b, u, Pl, Pr, maxiters::In do_factorization(alg, convert(AbstractMatrix, A), b, u) end +## RFLU Factorization + +function LinearSolve.init_cacheval(alg::RFLUFactorization, A, b, u, Pl, Pr, maxiters::Int, + abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) + ipiv = Vector{LinearAlgebra.BlasInt}(undef, min(size(A)...)) + ArrayInterface.lu_instance(convert(AbstractMatrix, A)), ipiv +end + +function LinearSolve.init_cacheval(alg::RFLUFactorization, A::Matrix{Float64}, b, u, Pl, Pr, + maxiters::Int, + abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) + ipiv = Vector{LinearAlgebra.BlasInt}(undef, 0) + PREALLOCATED_LU, ipiv +end + +function LinearSolve.init_cacheval(alg::RFLUFactorization, + A::Union{AbstractSparseArray, AbstractSciMLOperator}, b, u, Pl, Pr, + maxiters::Int, + abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) + nothing, nothing +end + +function LinearSolve.init_cacheval(alg::RFLUFactorization, + A::Union{Diagonal, SymTridiagonal, Tridiagonal}, b, u, Pl, Pr, + maxiters::Int, + abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) + nothing, nothing +end + ## LU Factorizations """ From b62f27738b9b333a96b34c347599d2c004030c25 Mon Sep 17 00:00:00 2001 From: Christopher Rackauckas Date: Sat, 1 Feb 2025 12:43:12 -0500 Subject: [PATCH 03/27] Update ext/LinearSolveRecursiveFactorization.jl Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> --- ext/LinearSolveRecursiveFactorization.jl | 28 ++++++++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/ext/LinearSolveRecursiveFactorization.jl b/ext/LinearSolveRecursiveFactorization.jl index b023017d7..24b912c55 100644 --- a/ext/LinearSolveRecursiveFactorization.jl +++ b/ext/LinearSolveRecursiveFactorization.jl @@ -2,6 +2,34 @@ module LinearSolveRecursiveFactorization using LinearSolve, RecursiveArrayTools, LinearAlgebra, RecursiveFactorization +function LinearSolve.init_cacheval(alg::RFLUFactorization, A, b, u, Pl, Pr, maxiters::Int, + abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) + ipiv = Vector{LinearAlgebra.BlasInt}(undef, min(size(A)...)) + ArrayInterface.lu_instance(convert(AbstractMatrix, A)), ipiv +end + +function LinearSolve.init_cacheval( + alg::RFLUFactorization, A::Matrix{Float64}, b, u, Pl, Pr, + maxiters::Int, + abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) + ipiv = Vector{LinearAlgebra.BlasInt}(undef, 0) + PREALLOCATED_LU, ipiv +end + +function LinearSolve.init_cacheval(alg::RFLUFactorization, + A::Union{AbstractSparseArray, AbstractSciMLOperator}, b, u, Pl, Pr, + maxiters::Int, + abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) + nothing, nothing +end + +function LinearSolve.init_cacheval(alg::RFLUFactorization, + A::Union{Diagonal, SymTridiagonal, Tridiagonal}, b, u, Pl, Pr, + maxiters::Int, + abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) + nothing, nothing +end + function SciMLBase.solve!(cache::LinearCache, alg::RFLUFactorization{P, T}; kwargs...) where {P, T} A = cache.A From d81e8a20ba2df69cd6f8355631539eb44303fc14 Mon Sep 17 00:00:00 2001 From: Christopher Rackauckas Date: Sat, 1 Feb 2025 12:43:18 -0500 Subject: [PATCH 04/27] Update src/default.jl Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> --- src/default.jl | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/default.jl b/src/default.jl index 0820a2a39..55e6a01d7 100644 --- a/src/default.jl +++ b/src/default.jl @@ -186,7 +186,8 @@ function defaultalg(A, b, assump::OperatorAssumptions{Bool}) (usemkl && length(b) <= 200)) && (A === nothing ? eltype(b) <: Union{Float32, Float64} : eltype(A) <: Union{Float32, Float64}) && - Base.get_extension(@__MODULE__, :LinearSolveRecursiveFactorizationExt) + Base.get_extension( + @__MODULE__, :LinearSolveRecursiveFactorizationExt) DefaultAlgorithmChoice.RFLUFactorization #elseif A === nothing || A isa Matrix # alg = FastLUFactorization() From aa865bae59df3226f52753d7662f37c9c4669ddd Mon Sep 17 00:00:00 2001 From: Christopher Rackauckas Date: Sat, 1 Feb 2025 13:21:50 -0500 Subject: [PATCH 05/27] Update src/factorization.jl Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> --- src/factorization.jl | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/factorization.jl b/src/factorization.jl index 81aeef84e..f50a1838e 100644 --- a/src/factorization.jl +++ b/src/factorization.jl @@ -37,7 +37,8 @@ function LinearSolve.init_cacheval(alg::RFLUFactorization, A, b, u, Pl, Pr, maxi ArrayInterface.lu_instance(convert(AbstractMatrix, A)), ipiv end -function LinearSolve.init_cacheval(alg::RFLUFactorization, A::Matrix{Float64}, b, u, Pl, Pr, +function LinearSolve.init_cacheval( + alg::RFLUFactorization, A::Matrix{Float64}, b, u, Pl, Pr, maxiters::Int, abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) ipiv = Vector{LinearAlgebra.BlasInt}(undef, 0) From b8cd21b41239a6459a23099e9f0a81b5bbce72cf Mon Sep 17 00:00:00 2001 From: Christopher Rackauckas Date: Sat, 1 Feb 2025 13:22:01 -0500 Subject: [PATCH 06/27] Update src/extension_algs.jl Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> --- src/extension_algs.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/extension_algs.jl b/src/extension_algs.jl index 775acb1e4..3d54e2061 100644 --- a/src/extension_algs.jl +++ b/src/extension_algs.jl @@ -103,7 +103,7 @@ struct RFLUFactorization{P, T} <: AbstractDenseFactorization end end -function RFLUFactorization(; pivot = Val(true), thread = Val(true), throwerror=true) +function RFLUFactorization(; pivot = Val(true), thread = Val(true), throwerror = true) RFLUFactorization(pivot, thread; throwerror) end From 1c2eae401d8cde3767d217b1b5906e9f2097be11 Mon Sep 17 00:00:00 2001 From: Christopher Rackauckas Date: Sat, 1 Feb 2025 13:22:09 -0500 Subject: [PATCH 07/27] Update src/extension_algs.jl Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> --- src/extension_algs.jl | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/extension_algs.jl b/src/extension_algs.jl index 3d54e2061..b98c0888a 100644 --- a/src/extension_algs.jl +++ b/src/extension_algs.jl @@ -97,7 +97,8 @@ struct RFLUFactorization{P, T} <: AbstractDenseFactorization function RFLUFactorization(::Val{P}, ::Val{T}; throwerror=true) where {P, T} ext = Base.get_extension(@__MODULE__, :LinearSolveRecursiveFactorizationExt) if ext === nothing - throwerror && error("RFLUFactorization requires that RecursiveFactorization.jl is loaded, i.e. `using RecursiveFactorization`") + throwerror && + error("RFLUFactorization requires that RecursiveFactorization.jl is loaded, i.e. `using RecursiveFactorization`") end return new{P, T}() end From 6606dd4c624e787514896bf826978fbdf68df85b Mon Sep 17 00:00:00 2001 From: Christopher Rackauckas Date: Sat, 1 Feb 2025 13:22:15 -0500 Subject: [PATCH 08/27] Update src/extension_algs.jl Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> --- src/extension_algs.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/extension_algs.jl b/src/extension_algs.jl index b98c0888a..b5ca6e3ce 100644 --- a/src/extension_algs.jl +++ b/src/extension_algs.jl @@ -94,7 +94,7 @@ implementation, usually outperforming OpenBLAS and MKL for smaller matrices Additional optimization for complex matrices is in the works. """ struct RFLUFactorization{P, T} <: AbstractDenseFactorization - function RFLUFactorization(::Val{P}, ::Val{T}; throwerror=true) where {P, T} + function RFLUFactorization(::Val{P}, ::Val{T}; throwerror = true) where {P, T} ext = Base.get_extension(@__MODULE__, :LinearSolveRecursiveFactorizationExt) if ext === nothing throwerror && From 45d94fd3ef1444f62852dc8afe1e09ffb8aa0b97 Mon Sep 17 00:00:00 2001 From: Christopher Rackauckas Date: Sat, 1 Feb 2025 13:22:28 -0500 Subject: [PATCH 09/27] Update src/default.jl Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> --- src/default.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/default.jl b/src/default.jl index 55e6a01d7..cd37b8d8d 100644 --- a/src/default.jl +++ b/src/default.jl @@ -267,7 +267,7 @@ function algchoice_to_alg(alg::Symbol) elseif alg === :GenericLUFactorization GenericLUFactorization() elseif alg === :RFLUFactorization - RFLUFactorization(throwerror=false) + RFLUFactorization(throwerror = false) elseif alg === :BunchKaufmanFactorization BunchKaufmanFactorization() elseif alg === :CHOLMODFactorization From cd3a29edbdb5ba40fd588f0e7686e9a407a2b552 Mon Sep 17 00:00:00 2001 From: Christopher Rackauckas Date: Sat, 1 Feb 2025 14:19:20 -0500 Subject: [PATCH 10/27] add RecursiveFactorization in tests --- Project.toml | 3 ++- test/adjoint.jl | 2 +- test/basictests.jl | 2 +- test/default_algs.jl | 2 +- test/enzyme.jl | 2 +- test/retcodes.jl | 2 +- 6 files changed, 7 insertions(+), 6 deletions(-) diff --git a/Project.toml b/Project.toml index 6c585dc2b..343588085 100644 --- a/Project.toml +++ b/Project.toml @@ -141,6 +141,7 @@ MultiFloats = "bdf0d083-296b-4888-a5b6-7498122e68a5" Pkg = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f" Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c" RecursiveArrayTools = "731186ca-8d62-57ce-b412-fbd966d074cd" +RecursiveFactorization = "f2c3362d-daeb-58d1-803e-2bc74f2840b4" SafeTestsets = "1bc83da4-3b8d-516f-aca4-4fe02f6d838f" StableRNGs = "860ef19b-820b-49d6-a774-d7a799459cd3" StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" @@ -148,4 +149,4 @@ Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40" Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f" [targets] -test = ["Aqua", "Test", "IterativeSolvers", "InteractiveUtils", "JET", "KrylovKit", "KrylovPreconditioners", "Pkg", "Random", "SafeTestsets", "MultiFloats", "ForwardDiff", "HYPRE", "MPI", "BlockDiagonals", "Enzyme", "FiniteDiff", "BandedMatrices", "FastAlmostBandedMatrices", "StaticArrays", "AllocCheck", "StableRNGs", "Zygote"] +test = ["Aqua", "Test", "IterativeSolvers", "InteractiveUtils", "JET", "KrylovKit", "KrylovPreconditioners", "Pkg", "Random", "SafeTestsets", "MultiFloats", "ForwardDiff", "HYPRE", "MPI", "BlockDiagonals", "Enzyme", "FiniteDiff", "BandedMatrices", "FastAlmostBandedMatrices", "StaticArrays", "AllocCheck", "StableRNGs", "Zygote", "RecursiveFactorization"] diff --git a/test/adjoint.jl b/test/adjoint.jl index 809feba8a..e1c18ec0b 100644 --- a/test/adjoint.jl +++ b/test/adjoint.jl @@ -1,6 +1,6 @@ using Zygote, ForwardDiff using LinearSolve, LinearAlgebra, Test -using FiniteDiff +using FiniteDiff, RecursiveFactorization using LazyArrays: BroadcastArray n = 4 diff --git a/test/basictests.jl b/test/basictests.jl index 64ea0c3d5..497af5463 100644 --- a/test/basictests.jl +++ b/test/basictests.jl @@ -1,5 +1,5 @@ using LinearSolve, LinearAlgebra, SparseArrays, MultiFloats, ForwardDiff -using SciMLOperators +using SciMLOperators, RecursiveFactorization using IterativeSolvers, KrylovKit, MKL_jll, KrylovPreconditioners using Test import Random diff --git a/test/default_algs.jl b/test/default_algs.jl index e6d69fe52..81cfb5e51 100644 --- a/test/default_algs.jl +++ b/test/default_algs.jl @@ -1,4 +1,4 @@ -using LinearSolve, LinearAlgebra, SparseArrays, Test, JET +using LinearSolve, RecursiveFactorization, LinearAlgebra, SparseArrays, Test, JET @test LinearSolve.defaultalg(nothing, zeros(3)).alg === LinearSolve.DefaultAlgorithmChoice.RFLUFactorization prob = LinearProblem(rand(3, 3), rand(3)) diff --git a/test/enzyme.jl b/test/enzyme.jl index 1650c453b..d523036e5 100644 --- a/test/enzyme.jl +++ b/test/enzyme.jl @@ -1,6 +1,6 @@ using Enzyme, ForwardDiff using LinearSolve, LinearAlgebra, Test -using FiniteDiff +using FiniteDiff, RecursiveFactorization n = 4 A = rand(n, n); diff --git a/test/retcodes.jl b/test/retcodes.jl index c75442d34..1e33e8adb 100644 --- a/test/retcodes.jl +++ b/test/retcodes.jl @@ -1,4 +1,4 @@ -using LinearSolve +using LinearSolve, RecursiveFactorization alglist = ( LUFactorization, From 80e66148e2e97ff9c164a5f238625422a9a88c5c Mon Sep 17 00:00:00 2001 From: Christopher Rackauckas Date: Wed, 5 Feb 2025 00:02:11 -0800 Subject: [PATCH 11/27] Update and rename LinearSolveRecursiveFactorization.jl to LinearSolveRecursiveFactorizationExt.jl --- ...ctorization.jl => LinearSolveRecursiveFactorizationExt.jl} | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) rename ext/{LinearSolveRecursiveFactorization.jl => LinearSolveRecursiveFactorizationExt.jl} (97%) diff --git a/ext/LinearSolveRecursiveFactorization.jl b/ext/LinearSolveRecursiveFactorizationExt.jl similarity index 97% rename from ext/LinearSolveRecursiveFactorization.jl rename to ext/LinearSolveRecursiveFactorizationExt.jl index 24b912c55..7f032faa5 100644 --- a/ext/LinearSolveRecursiveFactorization.jl +++ b/ext/LinearSolveRecursiveFactorizationExt.jl @@ -1,4 +1,4 @@ -module LinearSolveRecursiveFactorization +module LinearSolveRecursiveFactorizationExt using LinearSolve, RecursiveArrayTools, LinearAlgebra, RecursiveFactorization @@ -53,4 +53,4 @@ function SciMLBase.solve!(cache::LinearCache, alg::RFLUFactorization{P, T}; SciMLBase.build_linear_solution(alg, y, nothing, cache) end -end \ No newline at end of file +end From c280c46fbb910c87eb6185f33b8b5f9f773239ad Mon Sep 17 00:00:00 2001 From: Christopher Rackauckas Date: Wed, 5 Feb 2025 00:25:28 -0800 Subject: [PATCH 12/27] Update LinearSolveRecursiveFactorizationExt.jl --- ext/LinearSolveRecursiveFactorizationExt.jl | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/ext/LinearSolveRecursiveFactorizationExt.jl b/ext/LinearSolveRecursiveFactorizationExt.jl index 7f032faa5..9371f8bb5 100644 --- a/ext/LinearSolveRecursiveFactorizationExt.jl +++ b/ext/LinearSolveRecursiveFactorizationExt.jl @@ -1,6 +1,7 @@ module LinearSolveRecursiveFactorizationExt -using LinearSolve, RecursiveArrayTools, LinearAlgebra, RecursiveFactorization +using LinearSolve +using LinearSolve.RecursiveArrayTools, LinearSolve.LinearAlgebra, LinearSolve.RecursiveFactorization function LinearSolve.init_cacheval(alg::RFLUFactorization, A, b, u, Pl, Pr, maxiters::Int, abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) From 50e8cbed06698aa217dc7bfa84bf4a5c7aa13473 Mon Sep 17 00:00:00 2001 From: Christopher Rackauckas Date: Wed, 5 Feb 2025 00:25:39 -0800 Subject: [PATCH 13/27] Update LinearSolveRecursiveFactorizationExt.jl --- ext/LinearSolveRecursiveFactorizationExt.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ext/LinearSolveRecursiveFactorizationExt.jl b/ext/LinearSolveRecursiveFactorizationExt.jl index 9371f8bb5..34efd84c3 100644 --- a/ext/LinearSolveRecursiveFactorizationExt.jl +++ b/ext/LinearSolveRecursiveFactorizationExt.jl @@ -1,7 +1,7 @@ module LinearSolveRecursiveFactorizationExt using LinearSolve -using LinearSolve.RecursiveArrayTools, LinearSolve.LinearAlgebra, LinearSolve.RecursiveFactorization +using LinearSolve.RecursiveArrayTools, LinearSolve.LinearAlgebra, RecursiveFactorization function LinearSolve.init_cacheval(alg::RFLUFactorization, A, b, u, Pl, Pr, maxiters::Int, abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) From 4e358f6cf4a24ab50e3a282333f1780f48c6ab71 Mon Sep 17 00:00:00 2001 From: Christopher Rackauckas Date: Wed, 5 Feb 2025 00:29:04 -0800 Subject: [PATCH 14/27] Update LinearSolveRecursiveFactorizationExt.jl --- ext/LinearSolveRecursiveFactorizationExt.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ext/LinearSolveRecursiveFactorizationExt.jl b/ext/LinearSolveRecursiveFactorizationExt.jl index 34efd84c3..9a51f11c1 100644 --- a/ext/LinearSolveRecursiveFactorizationExt.jl +++ b/ext/LinearSolveRecursiveFactorizationExt.jl @@ -1,7 +1,7 @@ module LinearSolveRecursiveFactorizationExt using LinearSolve -using LinearSolve.RecursiveArrayTools, LinearSolve.LinearAlgebra, RecursiveFactorization +using LinearSolve.LinearAlgebra, RecursiveFactorization function LinearSolve.init_cacheval(alg::RFLUFactorization, A, b, u, Pl, Pr, maxiters::Int, abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) From 0278ecd6baee14a2a3f769cbafa70cb7bd9e9845 Mon Sep 17 00:00:00 2001 From: Christopher Rackauckas Date: Wed, 5 Feb 2025 00:47:19 -0800 Subject: [PATCH 15/27] Update LinearSolveRecursiveFactorizationExt.jl --- ext/LinearSolveRecursiveFactorizationExt.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ext/LinearSolveRecursiveFactorizationExt.jl b/ext/LinearSolveRecursiveFactorizationExt.jl index 9a51f11c1..bdc348071 100644 --- a/ext/LinearSolveRecursiveFactorizationExt.jl +++ b/ext/LinearSolveRecursiveFactorizationExt.jl @@ -1,7 +1,7 @@ module LinearSolveRecursiveFactorizationExt using LinearSolve -using LinearSolve.LinearAlgebra, RecursiveFactorization +using LinearSolve.LinearAlgebra, LinearSolve.ArrayInterface, RecursiveFactorization function LinearSolve.init_cacheval(alg::RFLUFactorization, A, b, u, Pl, Pr, maxiters::Int, abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) From e18d864f445acebdc55aedb6eac1873c9e1681ad Mon Sep 17 00:00:00 2001 From: Christopher Rackauckas Date: Wed, 5 Feb 2025 01:04:37 -0800 Subject: [PATCH 16/27] namespace PreallocatedLU --- ext/LinearSolveRecursiveFactorizationExt.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ext/LinearSolveRecursiveFactorizationExt.jl b/ext/LinearSolveRecursiveFactorizationExt.jl index bdc348071..87d402c7f 100644 --- a/ext/LinearSolveRecursiveFactorizationExt.jl +++ b/ext/LinearSolveRecursiveFactorizationExt.jl @@ -14,7 +14,7 @@ function LinearSolve.init_cacheval( maxiters::Int, abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) ipiv = Vector{LinearAlgebra.BlasInt}(undef, 0) - PREALLOCATED_LU, ipiv + LinearSolve.PREALLOCATED_LU, ipiv end function LinearSolve.init_cacheval(alg::RFLUFactorization, From a689fd6fa714d22fe8f4836a0228c1ec4e0da337 Mon Sep 17 00:00:00 2001 From: Christopher Rackauckas Date: Wed, 5 Feb 2025 01:16:45 -0800 Subject: [PATCH 17/27] one more --- ext/LinearSolveRecursiveFactorizationExt.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ext/LinearSolveRecursiveFactorizationExt.jl b/ext/LinearSolveRecursiveFactorizationExt.jl index 87d402c7f..2a3601b88 100644 --- a/ext/LinearSolveRecursiveFactorizationExt.jl +++ b/ext/LinearSolveRecursiveFactorizationExt.jl @@ -18,7 +18,7 @@ function LinearSolve.init_cacheval( end function LinearSolve.init_cacheval(alg::RFLUFactorization, - A::Union{AbstractSparseArray, AbstractSciMLOperator}, b, u, Pl, Pr, + A::Union{LinearSolve.SparseArrays.AbstractSparseArray, AbstractSciMLOperator}, b, u, Pl, Pr, maxiters::Int, abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) nothing, nothing From 8faa4e623d51aa17b1898bb8205d74fdf3a1d253 Mon Sep 17 00:00:00 2001 From: Christopher Rackauckas Date: Wed, 5 Feb 2025 01:25:05 -0800 Subject: [PATCH 18/27] one more --- ext/LinearSolveRecursiveFactorizationExt.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ext/LinearSolveRecursiveFactorizationExt.jl b/ext/LinearSolveRecursiveFactorizationExt.jl index 2a3601b88..cb5998582 100644 --- a/ext/LinearSolveRecursiveFactorizationExt.jl +++ b/ext/LinearSolveRecursiveFactorizationExt.jl @@ -18,7 +18,7 @@ function LinearSolve.init_cacheval( end function LinearSolve.init_cacheval(alg::RFLUFactorization, - A::Union{LinearSolve.SparseArrays.AbstractSparseArray, AbstractSciMLOperator}, b, u, Pl, Pr, + A::Union{LinearSolve.SparseArrays.AbstractSparseArray, LinearSolve.SciMLOperators.AbstractSciMLOperator}, b, u, Pl, Pr, maxiters::Int, abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) nothing, nothing From 7d1f54a457977ee2207d1300d53ffe4053174896 Mon Sep 17 00:00:00 2001 From: Christopher Rackauckas Date: Wed, 5 Feb 2025 01:33:02 -0800 Subject: [PATCH 19/27] namespace --- ext/LinearSolveRecursiveFactorizationExt.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ext/LinearSolveRecursiveFactorizationExt.jl b/ext/LinearSolveRecursiveFactorizationExt.jl index cb5998582..8617fd9b8 100644 --- a/ext/LinearSolveRecursiveFactorizationExt.jl +++ b/ext/LinearSolveRecursiveFactorizationExt.jl @@ -50,7 +50,7 @@ function SciMLBase.solve!(cache::LinearCache, alg::RFLUFactorization{P, T}; cache.isfresh = false end - y = ldiv!(cache.u, @get_cacheval(cache, :RFLUFactorization)[1], cache.b) + y = ldiv!(cache.u, LinearSolve.@get_cacheval(cache, :RFLUFactorization)[1], cache.b) SciMLBase.build_linear_solution(alg, y, nothing, cache) end From c93a6b2c2e3920e632dd2378439322c79681f36b Mon Sep 17 00:00:00 2001 From: Christopher Rackauckas Date: Wed, 5 Feb 2025 01:42:40 -0800 Subject: [PATCH 20/27] namespace --- ext/LinearSolveRecursiveFactorizationExt.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ext/LinearSolveRecursiveFactorizationExt.jl b/ext/LinearSolveRecursiveFactorizationExt.jl index 8617fd9b8..1c4fe0155 100644 --- a/ext/LinearSolveRecursiveFactorizationExt.jl +++ b/ext/LinearSolveRecursiveFactorizationExt.jl @@ -31,7 +31,7 @@ function LinearSolve.init_cacheval(alg::RFLUFactorization, nothing, nothing end -function SciMLBase.solve!(cache::LinearCache, alg::RFLUFactorization{P, T}; +function SciMLBase.solve!(cache::LinearSolve.LinearCache, alg::RFLUFactorization{P, T}; kwargs...) where {P, T} A = cache.A A = convert(AbstractMatrix, A) From 41a786bce0fec4dcdb968994b20dfd4b1edbc168 Mon Sep 17 00:00:00 2001 From: Christopher Rackauckas Date: Wed, 5 Feb 2025 01:55:34 -0800 Subject: [PATCH 21/27] fix default --- src/default.jl | 2 +- test/default_algs.jl | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/default.jl b/src/default.jl index cd37b8d8d..f6884539c 100644 --- a/src/default.jl +++ b/src/default.jl @@ -187,7 +187,7 @@ function defaultalg(A, b, assump::OperatorAssumptions{Bool}) (A === nothing ? eltype(b) <: Union{Float32, Float64} : eltype(A) <: Union{Float32, Float64}) && Base.get_extension( - @__MODULE__, :LinearSolveRecursiveFactorizationExt) + @__MODULE__, :LinearSolveRecursiveFactorizationExt) !== nothing DefaultAlgorithmChoice.RFLUFactorization #elseif A === nothing || A isa Matrix # alg = FastLUFactorization() diff --git a/test/default_algs.jl b/test/default_algs.jl index 81cfb5e51..4b795bffb 100644 --- a/test/default_algs.jl +++ b/test/default_algs.jl @@ -1,6 +1,6 @@ using LinearSolve, RecursiveFactorization, LinearAlgebra, SparseArrays, Test, JET @test LinearSolve.defaultalg(nothing, zeros(3)).alg === - LinearSolve.DefaultAlgorithmChoice.RFLUFactorization + LinearSolve.DefaultAlgorithmChoice.GenericLUFactorization prob = LinearProblem(rand(3, 3), rand(3)) solve(prob) From 75694409842aa4a61d6510d7829bdf87f5d2b3fd Mon Sep 17 00:00:00 2001 From: Christopher Rackauckas Date: Wed, 5 Feb 2025 03:51:02 -0800 Subject: [PATCH 22/27] fix inference on recfact load --- ext/LinearSolveRecursiveFactorizationExt.jl | 2 ++ src/default.jl | 6 +++--- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/ext/LinearSolveRecursiveFactorizationExt.jl b/ext/LinearSolveRecursiveFactorizationExt.jl index 1c4fe0155..f911e36d0 100644 --- a/ext/LinearSolveRecursiveFactorizationExt.jl +++ b/ext/LinearSolveRecursiveFactorizationExt.jl @@ -3,6 +3,8 @@ module LinearSolveRecursiveFactorizationExt using LinearSolve using LinearSolve.LinearAlgebra, LinearSolve.ArrayInterface, RecursiveFactorization +LinearSolve.userecursivefactorization(A::Union{Nothing,AbstractMatrix}) = true + function LinearSolve.init_cacheval(alg::RFLUFactorization, A, b, u, Pl, Pr, maxiters::Int, abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) ipiv = Vector{LinearAlgebra.BlasInt}(undef, min(size(A)...)) diff --git a/src/default.jl b/src/default.jl index f6884539c..27e710125 100644 --- a/src/default.jl +++ b/src/default.jl @@ -165,6 +165,8 @@ function defaultalg(A::SciMLBase.AbstractSciMLOperator, b, end end +userecursivefactorization(A) = false + # Allows A === nothing as a stand-in for dense matrix function defaultalg(A, b, assump::OperatorAssumptions{Bool}) alg = if assump.issq @@ -185,9 +187,7 @@ function defaultalg(A, b, assump::OperatorAssumptions{Bool}) elseif (length(b) <= 100 || (isopenblas() && length(b) <= 500) || (usemkl && length(b) <= 200)) && (A === nothing ? eltype(b) <: Union{Float32, Float64} : - eltype(A) <: Union{Float32, Float64}) && - Base.get_extension( - @__MODULE__, :LinearSolveRecursiveFactorizationExt) !== nothing + eltype(A) <: Union{Float32, Float64}) && userecursivefactorization(A) DefaultAlgorithmChoice.RFLUFactorization #elseif A === nothing || A isa Matrix # alg = FastLUFactorization() From 8704062b6dd0184758c62f6a63d84546e7b741da Mon Sep 17 00:00:00 2001 From: Christopher Rackauckas Date: Wed, 5 Feb 2025 04:09:10 -0800 Subject: [PATCH 23/27] don't double --- ext/LinearSolveRecursiveFactorizationExt.jl | 28 --------------------- 1 file changed, 28 deletions(-) diff --git a/ext/LinearSolveRecursiveFactorizationExt.jl b/ext/LinearSolveRecursiveFactorizationExt.jl index f911e36d0..b058086e3 100644 --- a/ext/LinearSolveRecursiveFactorizationExt.jl +++ b/ext/LinearSolveRecursiveFactorizationExt.jl @@ -5,34 +5,6 @@ using LinearSolve.LinearAlgebra, LinearSolve.ArrayInterface, RecursiveFactorizat LinearSolve.userecursivefactorization(A::Union{Nothing,AbstractMatrix}) = true -function LinearSolve.init_cacheval(alg::RFLUFactorization, A, b, u, Pl, Pr, maxiters::Int, - abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) - ipiv = Vector{LinearAlgebra.BlasInt}(undef, min(size(A)...)) - ArrayInterface.lu_instance(convert(AbstractMatrix, A)), ipiv -end - -function LinearSolve.init_cacheval( - alg::RFLUFactorization, A::Matrix{Float64}, b, u, Pl, Pr, - maxiters::Int, - abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) - ipiv = Vector{LinearAlgebra.BlasInt}(undef, 0) - LinearSolve.PREALLOCATED_LU, ipiv -end - -function LinearSolve.init_cacheval(alg::RFLUFactorization, - A::Union{LinearSolve.SparseArrays.AbstractSparseArray, LinearSolve.SciMLOperators.AbstractSciMLOperator}, b, u, Pl, Pr, - maxiters::Int, - abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) - nothing, nothing -end - -function LinearSolve.init_cacheval(alg::RFLUFactorization, - A::Union{Diagonal, SymTridiagonal, Tridiagonal}, b, u, Pl, Pr, - maxiters::Int, - abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) - nothing, nothing -end - function SciMLBase.solve!(cache::LinearSolve.LinearCache, alg::RFLUFactorization{P, T}; kwargs...) where {P, T} A = cache.A From 3ad68c7d52fe93f155b70abac90b203df7dce1e0 Mon Sep 17 00:00:00 2001 From: Christopher Rackauckas Date: Wed, 5 Feb 2025 04:21:27 -0800 Subject: [PATCH 24/27] Update src/extension_algs.jl --- src/extension_algs.jl | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/extension_algs.jl b/src/extension_algs.jl index b5ca6e3ce..f45d93d81 100644 --- a/src/extension_algs.jl +++ b/src/extension_algs.jl @@ -95,8 +95,7 @@ Additional optimization for complex matrices is in the works. """ struct RFLUFactorization{P, T} <: AbstractDenseFactorization function RFLUFactorization(::Val{P}, ::Val{T}; throwerror = true) where {P, T} - ext = Base.get_extension(@__MODULE__, :LinearSolveRecursiveFactorizationExt) - if ext === nothing + if userecursivefactorization(nothing) throwerror && error("RFLUFactorization requires that RecursiveFactorization.jl is loaded, i.e. `using RecursiveFactorization`") end From 4d3a346d5e9ee1fa89933c152cb14fd48d8d5a47 Mon Sep 17 00:00:00 2001 From: Christopher Rackauckas Date: Wed, 5 Feb 2025 07:37:52 -0800 Subject: [PATCH 25/27] Update src/extension_algs.jl --- src/extension_algs.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/extension_algs.jl b/src/extension_algs.jl index f45d93d81..fbd52c6cd 100644 --- a/src/extension_algs.jl +++ b/src/extension_algs.jl @@ -95,7 +95,7 @@ Additional optimization for complex matrices is in the works. """ struct RFLUFactorization{P, T} <: AbstractDenseFactorization function RFLUFactorization(::Val{P}, ::Val{T}; throwerror = true) where {P, T} - if userecursivefactorization(nothing) + if !userecursivefactorization(nothing) throwerror && error("RFLUFactorization requires that RecursiveFactorization.jl is loaded, i.e. `using RecursiveFactorization`") end From 486d924d41eedad2fd502546e65166590a1658c7 Mon Sep 17 00:00:00 2001 From: Christopher Rackauckas Date: Wed, 5 Feb 2025 07:40:11 -0800 Subject: [PATCH 26/27] Update src/default.jl Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> --- src/default.jl | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/default.jl b/src/default.jl index 27e710125..0cb66d06e 100644 --- a/src/default.jl +++ b/src/default.jl @@ -187,7 +187,8 @@ function defaultalg(A, b, assump::OperatorAssumptions{Bool}) elseif (length(b) <= 100 || (isopenblas() && length(b) <= 500) || (usemkl && length(b) <= 200)) && (A === nothing ? eltype(b) <: Union{Float32, Float64} : - eltype(A) <: Union{Float32, Float64}) && userecursivefactorization(A) + eltype(A) <: Union{Float32, Float64}) && + userecursivefactorization(A) DefaultAlgorithmChoice.RFLUFactorization #elseif A === nothing || A isa Matrix # alg = FastLUFactorization() From 1fad9450a686fde717dc4771dc5b676a47a3ef82 Mon Sep 17 00:00:00 2001 From: Christopher Rackauckas Date: Wed, 5 Feb 2025 07:40:18 -0800 Subject: [PATCH 27/27] Update ext/LinearSolveRecursiveFactorizationExt.jl Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> --- ext/LinearSolveRecursiveFactorizationExt.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ext/LinearSolveRecursiveFactorizationExt.jl b/ext/LinearSolveRecursiveFactorizationExt.jl index b058086e3..c4794c44a 100644 --- a/ext/LinearSolveRecursiveFactorizationExt.jl +++ b/ext/LinearSolveRecursiveFactorizationExt.jl @@ -3,7 +3,7 @@ module LinearSolveRecursiveFactorizationExt using LinearSolve using LinearSolve.LinearAlgebra, LinearSolve.ArrayInterface, RecursiveFactorization -LinearSolve.userecursivefactorization(A::Union{Nothing,AbstractMatrix}) = true +LinearSolve.userecursivefactorization(A::Union{Nothing, AbstractMatrix}) = true function SciMLBase.solve!(cache::LinearSolve.LinearCache, alg::RFLUFactorization{P, T}; kwargs...) where {P, T}