From 029f47050bf31fde2ff0cbcdb9c61cdafd218210 Mon Sep 17 00:00:00 2001 From: jClugstor Date: Wed, 4 Jun 2025 13:19:30 -0400 Subject: [PATCH 01/36] add imports for SciMLMessage --- src/LinearSolve.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/LinearSolve.jl b/src/LinearSolve.jl index d21103de0..d96180add 100644 --- a/src/LinearSolve.jl +++ b/src/LinearSolve.jl @@ -16,7 +16,7 @@ using LinearAlgebra: LinearAlgebra, BlasInt, LU, Adjoint, BLAS, Bidiagonal, Bunc norm, qr, qr!, svd, svd! using LazyArrays: @~, BroadcastArray -using SciMLBase: SciMLBase, LinearAliasSpecifier, AbstractSciMLOperator, +using SciMLBase: SciMLBase, LinearAliasSpecifier, LinearVerbosity, Verbosity, @SciMLMessage, AbstractSciMLOperator, init, solve!, reinit!, solve, ReturnCode, LinearProblem using SciMLOperators: SciMLOperators, AbstractSciMLOperator, IdentityOperator, MatrixOperator, From b0f72278ab53b79e7c6135193babfe0e9d77dfbc Mon Sep 17 00:00:00 2001 From: jClugstor Date: Wed, 4 Jun 2025 13:19:49 -0400 Subject: [PATCH 02/36] make verbose be a LinearVerbosity --- src/common.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/common.jl b/src/common.jl index f447df8e7..7c93c8ee8 100644 --- a/src/common.jl +++ b/src/common.jl @@ -143,7 +143,7 @@ function SciMLBase.init(prob::LinearProblem, alg::SciMLLinearSolveAlgorithm, abstol = default_tol(real(eltype(prob.b))), reltol = default_tol(real(eltype(prob.b))), maxiters::Int = length(prob.b), - verbose::Bool = false, + verbose::LinearVerbosity = false, Pl = nothing, Pr = nothing, assumptions = OperatorAssumptions(issquare(prob.A)), From 8341ae39fdc2af5565200a8d315cad40cf594571 Mon Sep 17 00:00:00 2001 From: jClugstor Date: Wed, 4 Jun 2025 13:20:07 -0400 Subject: [PATCH 03/36] use SciMLMessage for fallback to QR factorization --- src/default.jl | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/src/default.jl b/src/default.jl index b3c494df0..4d9095bd7 100644 --- a/src/default.jl +++ b/src/default.jl @@ -365,7 +365,9 @@ end newex = quote sol = SciMLBase.solve!(cache, $(algchoice_to_alg(alg)), args...; kwargs...) if sol.retcode === ReturnCode.Failure && alg.safetyfallback - ## TODO: Add verbosity logging here about using the fallback + @SciMLMessage("LU factorization failed, falling back to QR factorization. `A` is potentially rank-deficient.", + cache.verbose, :default_lu_fallback, :error_control) + sol = SciMLBase.solve!( cache, QRFactorization(ColumnNorm()), args...; kwargs...) SciMLBase.build_linear_solution(alg, sol.u, sol.resid, sol.cache; @@ -385,7 +387,9 @@ end sol = SciMLBase.solve!(cache, $(algchoice_to_alg(alg)), args...; kwargs...) if sol.retcode === ReturnCode.Failure && alg.safetyfallback - ## TODO: Add verbosity logging here about using the fallback + @SciMLMessage("LU factorization failed, falling back to QR factorization. `A` is potentially rank-deficient.", + cache.verbose, :default_lu_fallback, :error_control) + sol = SciMLBase.solve!( cache, QRFactorization(ColumnNorm()), args...; kwargs...) SciMLBase.build_linear_solution(alg, sol.u, sol.resid, sol.cache; From 476f0da2786cfa4f43b23bf81a173e019a962bab Mon Sep 17 00:00:00 2001 From: jClugstor Date: Wed, 4 Jun 2025 15:49:34 -0400 Subject: [PATCH 04/36] use SciMLMessage --- ext/LinearSolveIterativeSolversExt.jl | 14 ++++++++------ src/iterative_wrappers.jl | 6 ++++-- 2 files changed, 12 insertions(+), 8 deletions(-) diff --git a/ext/LinearSolveIterativeSolversExt.jl b/ext/LinearSolveIterativeSolversExt.jl index 901b6bf74..04eb1620a 100644 --- a/ext/LinearSolveIterativeSolversExt.jl +++ b/ext/LinearSolveIterativeSolversExt.jl @@ -56,7 +56,8 @@ function LinearSolve.init_cacheval(alg::IterativeSolversJL, A, b, u, Pl, Pr, max iterable = if alg.generate_iterator === IterativeSolvers.cg_iterator! !LinearSolve._isidentity_struct(Pr) && - @warn "$(alg.generate_iterator) doesn't support right preconditioning" + @SciMLMessage("$(alg.generate_iterator) doesn't support right preconditioning", + verbose, :no_right_preconditioning, :performance) alg.generate_iterator(u, A, b, Pl; kwargs...) elseif alg.generate_iterator === IterativeSolvers.gmres_iterable! @@ -64,7 +65,8 @@ function LinearSolve.init_cacheval(alg::IterativeSolversJL, A, b, u, Pl, Pr, max kwargs...) elseif alg.generate_iterator === IterativeSolvers.idrs_iterable! !!LinearSolve._isidentity_struct(Pr) && - @warn "$(alg.generate_iterator) doesn't support right preconditioning" + @SciMLMessage("$(alg.generate_iterator) doesn't support right preconditioning", + verbose, :no_right_preconditioning, :performance) history = IterativeSolvers.ConvergenceHistory(partial = true) history[:abstol] = abstol history[:reltol] = reltol @@ -72,7 +74,8 @@ function LinearSolve.init_cacheval(alg::IterativeSolversJL, A, b, u, Pl, Pr, max alg.kwargs...) elseif alg.generate_iterator === IterativeSolvers.bicgstabl_iterator! !!LinearSolve._isidentity_struct(Pr) && - @warn "$(alg.generate_iterator) doesn't support right preconditioning" + @SciMLMessage("$(alg.generate_iterator) doesn't support right preconditioning", + verbose, :no_right_preconditioning, :performance) alg.generate_iterator(u, A, b, alg.args...; Pl = Pl, abstol = abstol, reltol = reltol, max_mv_products = maxiters * 2, @@ -103,14 +106,13 @@ function SciMLBase.solve!(cache::LinearCache, alg::IterativeSolversJL; kwargs... end purge_history!(cache.cacheval, cache.u, cache.b) - cache.verbose && println("Using IterativeSolvers.$(alg.generate_iterator)") + @SciMLMessage("Using IterativeSolvers.$(alg.generate_iterator)", cache.verbose, :using_IterativeSolvers, :numerical) i = 0 for iter in enumerate(cache.cacheval) i += 1 - cache.verbose && println("Iter: $(iter[1]), residual: $(iter[2])") + @SciMLMessage("Iter: $(iter[1]), residual: $(iter[2])", cache.verbose, :IterativeSolvers_iterations) # TODO inject callbacks KSP into solve! cb!(cache.cacheval) end - cache.verbose && println() resid = cache.cacheval isa IterativeSolvers.IDRSIterable ? cache.cacheval.R : cache.cacheval.residual diff --git a/src/iterative_wrappers.jl b/src/iterative_wrappers.jl index 16d28d908..630389df6 100644 --- a/src/iterative_wrappers.jl +++ b/src/iterative_wrappers.jl @@ -290,7 +290,8 @@ function SciMLBase.solve!(cache::LinearCache, alg::KrylovJL; kwargs...) if cache.cacheval isa Krylov.CgWorkspace N !== I && - @warn "$(alg.KrylovAlg) doesn't support right preconditioning." + @SciMLMessage("$(alg.KrylovAlg) doesn't support right preconditioning.", + verbose, :no_right_preconditioning, :performance) Krylov.krylov_solve!(args...; M, kwargs...) elseif cache.cacheval isa Krylov.GmresWorkspace Krylov.krylov_solve!(args...; M, N, restart = alg.gmres_restart > 0, kwargs...) @@ -298,7 +299,8 @@ function SciMLBase.solve!(cache::LinearCache, alg::KrylovJL; kwargs...) Krylov.krylov_solve!(args...; M, N, kwargs...) elseif cache.cacheval isa Krylov.MinresWorkspace N !== I && - @warn "$(alg.KrylovAlg) doesn't support right preconditioning." + @SciMLMessage("$(alg.KrylovAlg) doesn't support right preconditioning.", + verbose, :no_right_preconditioning, :performance) Krylov.krylov_solve!(args...; M, kwargs...) else Krylov.krylov_solve!(args...; kwargs...) From 29066d34975ac68d52b497bb8776bacc2cf61555 Mon Sep 17 00:00:00 2001 From: jClugstor Date: Wed, 4 Jun 2025 15:50:33 -0400 Subject: [PATCH 05/36] replace verbose::Bool with verbose::LinearVerbosity --- docs/src/advanced/developing.md | 2 +- ext/LinearSolveBandedMatricesExt.jl | 6 +- ext/LinearSolveCUDAExt.jl | 8 +- ext/LinearSolveFastAlmostBandedMatricesExt.jl | 2 +- ext/LinearSolveFastLapackInterfaceExt.jl | 10 +- ext/LinearSolveHYPREExt.jl | 4 +- ext/LinearSolveIterativeSolversExt.jl | 2 +- ext/LinearSolveMetalExt.jl | 2 +- ext/LinearSolvePardisoExt.jl | 2 +- ext/LinearSolveSparseArraysExt.jl | 40 ++-- ext/LinearSolveSparspakExt.jl | 4 +- src/appleaccelerate.jl | 4 +- src/common.jl | 2 +- src/default.jl | 4 +- src/factorization.jl | 180 +++++++++--------- src/iterative_wrappers.jl | 4 +- src/mkl.jl | 4 +- src/simplelu.jl | 2 +- 18 files changed, 141 insertions(+), 141 deletions(-) diff --git a/docs/src/advanced/developing.md b/docs/src/advanced/developing.md index 31b7a5d1f..ea70d32e1 100644 --- a/docs/src/advanced/developing.md +++ b/docs/src/advanced/developing.md @@ -19,7 +19,7 @@ struct MyLUFactorization{P} <: LinearSolve.SciMLLinearSolveAlgorithm end function LinearSolve.init_cacheval( alg::MyLUFactorization, A, b, u, Pl, Pr, maxiters::Int, abstol, reltol, - verbose::Bool, assump::LinearSolve.OperatorAssumptions) + verbose::LinearVerbosity, assump::LinearSolve.OperatorAssumptions) lu!(convert(AbstractMatrix, A)) end diff --git a/ext/LinearSolveBandedMatricesExt.jl b/ext/LinearSolveBandedMatricesExt.jl index deb85e25a..a6ff8755c 100644 --- a/ext/LinearSolveBandedMatricesExt.jl +++ b/ext/LinearSolveBandedMatricesExt.jl @@ -41,14 +41,14 @@ for alg in (:SVDFactorization, :MKLLUFactorization, :DiagonalFactorization, :AppleAccelerateLUFactorization, :CholeskyFactorization) @eval begin function init_cacheval(::$(alg), ::BandedMatrix, b, u, Pl, Pr, maxiters::Int, - abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) + abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) return nothing end end end function init_cacheval(::LUFactorization, A::BandedMatrix{T}, b, u, Pl, Pr, maxiters::Int, - abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) where {T} + abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) where {T} (T <: BigFloat) && return qr(similar(A, 0, 0)) return lu(similar(A, 0, 0)) end @@ -61,7 +61,7 @@ for alg in (:SVDFactorization, :MKLLUFactorization, :DiagonalFactorization, :AppleAccelerateLUFactorization, :QRFactorization, :LUFactorization) @eval begin function init_cacheval(::$(alg), ::Symmetric{<:Number, <:BandedMatrix}, b, u, Pl, - Pr, maxiters::Int, abstol, reltol, verbose::Bool, + Pr, maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) return nothing end diff --git a/ext/LinearSolveCUDAExt.jl b/ext/LinearSolveCUDAExt.jl index aaedcf21a..90a65f65a 100644 --- a/ext/LinearSolveCUDAExt.jl +++ b/ext/LinearSolveCUDAExt.jl @@ -48,26 +48,26 @@ function SciMLBase.solve!(cache::LinearSolve.LinearCache, alg::CudaOffloadFactor end function LinearSolve.init_cacheval(alg::CudaOffloadFactorization, A, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) qr(CUDA.CuArray(A)) end function LinearSolve.init_cacheval( ::SparspakFactorization, A::CUDA.CUSPARSE.CuSparseMatrixCSR, b, u, - Pl, Pr, maxiters::Int, abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) + Pl, Pr, maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) nothing end function LinearSolve.init_cacheval( ::KLUFactorization, A::CUDA.CUSPARSE.CuSparseMatrixCSR, b, u, - Pl, Pr, maxiters::Int, abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) + Pl, Pr, maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) nothing end function LinearSolve.init_cacheval( ::UMFPACKFactorization, A::CUDA.CUSPARSE.CuSparseMatrixCSR, b, u, - Pl, Pr, maxiters::Int, abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) + Pl, Pr, maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) nothing end diff --git a/ext/LinearSolveFastAlmostBandedMatricesExt.jl b/ext/LinearSolveFastAlmostBandedMatricesExt.jl index 1ceff10c5..99314d835 100644 --- a/ext/LinearSolveFastAlmostBandedMatricesExt.jl +++ b/ext/LinearSolveFastAlmostBandedMatricesExt.jl @@ -21,7 +21,7 @@ for alg in (:SVDFactorization, :MKLLUFactorization, :DiagonalFactorization, :AppleAccelerateLUFactorization, :CholeskyFactorization, :LUFactorization) @eval begin function init_cacheval(::$(alg), ::AlmostBandedMatrix, b, u, Pl, Pr, maxiters::Int, - abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) + abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) return nothing end end diff --git a/ext/LinearSolveFastLapackInterfaceExt.jl b/ext/LinearSolveFastLapackInterfaceExt.jl index 45b690037..945442e2c 100644 --- a/ext/LinearSolveFastLapackInterfaceExt.jl +++ b/ext/LinearSolveFastLapackInterfaceExt.jl @@ -9,7 +9,7 @@ struct WorkspaceAndFactors{W, F} end function LinearSolve.init_cacheval(::FastLUFactorization, A, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) ws = LUWs(A) return WorkspaceAndFactors( @@ -36,7 +36,7 @@ end function LinearSolve.init_cacheval( alg::FastQRFactorization{NoPivot}, A::AbstractMatrix, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) ws = QRWYWs(A; blocksize = alg.blocksize) return WorkspaceAndFactors(ws, @@ -44,7 +44,7 @@ function LinearSolve.init_cacheval( end function LinearSolve.init_cacheval( ::FastQRFactorization{ColumnNorm}, A::AbstractMatrix, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) ws = QRpWs(A) return WorkspaceAndFactors(ws, @@ -52,10 +52,10 @@ function LinearSolve.init_cacheval( end function LinearSolve.init_cacheval(alg::FastQRFactorization, A, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) return init_cacheval(alg, convert(AbstractMatrix, A), b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) end diff --git a/ext/LinearSolveHYPREExt.jl b/ext/LinearSolveHYPREExt.jl index ad7d98333..1c6774f99 100644 --- a/ext/LinearSolveHYPREExt.jl +++ b/ext/LinearSolveHYPREExt.jl @@ -22,7 +22,7 @@ end function LinearSolve.init_cacheval(alg::HYPREAlgorithm, A, b, u, Pl, Pr, maxiters::Int, abstol, reltol, - verbose::Bool, assumptions::OperatorAssumptions) + verbose::LinearVerbosity, assumptions::OperatorAssumptions) return HYPRECache(nothing, nothing, nothing, nothing, true, true, true) end @@ -64,7 +64,7 @@ function SciMLBase.init(prob::LinearProblem, alg::HYPREAlgorithm, eltype(prob.A)), # TODO: Implement length() for HYPREVector in HYPRE.jl? maxiters::Int = prob.b isa HYPREVector ? 1000 : length(prob.b), - verbose::Bool = false, + verbose::LinearVerbosity = false, Pl = LinearAlgebra.I, Pr = LinearAlgebra.I, assumptions = OperatorAssumptions(), diff --git a/ext/LinearSolveIterativeSolversExt.jl b/ext/LinearSolveIterativeSolversExt.jl index 04eb1620a..2d04f3e40 100644 --- a/ext/LinearSolveIterativeSolversExt.jl +++ b/ext/LinearSolveIterativeSolversExt.jl @@ -47,7 +47,7 @@ LinearSolve.default_alias_b(::IterativeSolversJL, ::Any, ::Any) = true function LinearSolve.init_cacheval(alg::IterativeSolversJL, A, b, u, Pl, Pr, maxiters::Int, abstol, reltol, - verbose::Bool, assumptions::OperatorAssumptions) + verbose::LinearVerbosity, assumptions::OperatorAssumptions) restart = (alg.gmres_restart == 0) ? min(20, size(A, 1)) : alg.gmres_restart s = :idrs_s in keys(alg.kwargs) ? alg.kwargs.idrs_s : 4 # shadow space diff --git a/ext/LinearSolveMetalExt.jl b/ext/LinearSolveMetalExt.jl index 036ffa9cd..507ae0142 100644 --- a/ext/LinearSolveMetalExt.jl +++ b/ext/LinearSolveMetalExt.jl @@ -9,7 +9,7 @@ default_alias_A(::MetalLUFactorization, ::Any, ::Any) = false default_alias_b(::MetalLUFactorization, ::Any, ::Any) = false function LinearSolve.init_cacheval(alg::MetalLUFactorization, A, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) ArrayInterface.lu_instance(convert(AbstractMatrix, A)) end diff --git a/ext/LinearSolvePardisoExt.jl b/ext/LinearSolvePardisoExt.jl index 5b459d8cc..670e1388e 100644 --- a/ext/LinearSolvePardisoExt.jl +++ b/ext/LinearSolvePardisoExt.jl @@ -20,7 +20,7 @@ function LinearSolve.init_cacheval(alg::PardisoJL, maxiters::Int, abstol, reltol, - verbose::Bool, + verbose::LinearVerbosity, assumptions::LinearSolve.OperatorAssumptions) @unpack nprocs, solver_type, matrix_type, cache_analysis, iparm, dparm, vendor = alg A = convert(AbstractMatrix, A) diff --git a/ext/LinearSolveSparseArraysExt.jl b/ext/LinearSolveSparseArraysExt.jl index 57e135164..8974133d2 100644 --- a/ext/LinearSolveSparseArraysExt.jl +++ b/ext/LinearSolveSparseArraysExt.jl @@ -34,7 +34,7 @@ end function LinearSolve.init_cacheval(alg::RFLUFactorization, A::Union{AbstractSparseArray, LinearSolve.SciMLOperators.AbstractSciMLOperator}, b, u, Pl, Pr, maxiters::Int, - abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) + abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) nothing, nothing end @@ -65,7 +65,7 @@ end function LinearSolve.init_cacheval(alg::GenericFactorization, A::Union{Hermitian{T, <:SparseMatrixCSC}, Symmetric{T, <:SparseMatrixCSC}}, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) where {T} newA = copy(convert(AbstractMatrix, A)) LinearSolve.do_factorization(alg, newA, b, u) @@ -78,7 +78,7 @@ function LinearSolve.init_cacheval( alg::LUFactorization, A::AbstractSparseArray{<:Number, <:Integer}, b, u, Pl, Pr, maxiters::Int, abstol, reltol, - verbose::Bool, assumptions::OperatorAssumptions) + verbose::LinearVerbosity, assumptions::OperatorAssumptions) nothing end @@ -86,7 +86,7 @@ function LinearSolve.init_cacheval( alg::GenericLUFactorization, A::AbstractSparseArray{<:Number, <:Integer}, b, u, Pl, Pr, maxiters::Int, abstol, reltol, - verbose::Bool, assumptions::OperatorAssumptions) + verbose::LinearVerbosity, assumptions::OperatorAssumptions) nothing end @@ -94,7 +94,7 @@ function LinearSolve.init_cacheval( alg::UMFPACKFactorization, A::AbstractArray, b, u, Pl, Pr, maxiters::Int, abstol, reltol, - verbose::Bool, assumptions::OperatorAssumptions) + verbose::LinearVerbosity, assumptions::OperatorAssumptions) nothing end @@ -102,7 +102,7 @@ function LinearSolve.init_cacheval( alg::LUFactorization, A::AbstractSparseArray{Float64, Int64}, b, u, Pl, Pr, maxiters::Int, abstol, reltol, - verbose::Bool, assumptions::OperatorAssumptions) + verbose::LinearVerbosity, assumptions::OperatorAssumptions) PREALLOCATED_UMFPACK end @@ -110,7 +110,7 @@ function LinearSolve.init_cacheval( alg::LUFactorization, A::AbstractSparseArray{T, Int64}, b, u, Pl, Pr, maxiters::Int, abstol, reltol, - verbose::Bool, assumptions::OperatorAssumptions) where {T <: BLASELTYPES} + verbose::LinearVerbosity, assumptions::OperatorAssumptions) where {T <: BLASELTYPES} if LinearSolve.is_cusparse(A) ArrayInterface.lu_instance(A) else @@ -123,7 +123,7 @@ function LinearSolve.init_cacheval( alg::LUFactorization, A::AbstractSparseArray{T, Int32}, b, u, Pl, Pr, maxiters::Int, abstol, reltol, - verbose::Bool, assumptions::OperatorAssumptions) where {T <: BLASELTYPES} + verbose::LinearVerbosity, assumptions::OperatorAssumptions) where {T <: BLASELTYPES} if LinearSolve.is_cusparse(A) ArrayInterface.lu_instance(A) else @@ -144,7 +144,7 @@ function LinearSolve.init_cacheval( alg::UMFPACKFactorization, A::AbstractSparseArray{Float64, Int}, b, u, Pl, Pr, maxiters::Int, abstol, reltol, - verbose::Bool, assumptions::OperatorAssumptions) + verbose::LinearVerbosity, assumptions::OperatorAssumptions) PREALLOCATED_UMFPACK end @@ -160,7 +160,7 @@ function LinearSolve.init_cacheval( alg::UMFPACKFactorization, A::AbstractSparseArray{T, Int64}, b, u, Pl, Pr, maxiters::Int, abstol, reltol, - verbose::Bool, assumptions::OperatorAssumptions) where {T <: BLASELTYPES} + verbose::LinearVerbosity, assumptions::OperatorAssumptions) where {T <: BLASELTYPES} SparseArrays.UMFPACK.UmfpackLU(SparseMatrixCSC{T, Int64}( zero(Int64), zero(Int64), [Int64(1)], Int64[], T[])) end @@ -169,7 +169,7 @@ function LinearSolve.init_cacheval( alg::UMFPACKFactorization, A::AbstractSparseArray{T, Int32}, b, u, Pl, Pr, maxiters::Int, abstol, reltol, - verbose::Bool, assumptions::OperatorAssumptions) where {T <: BLASELTYPES} + verbose::LinearVerbosity, assumptions::OperatorAssumptions) where {T <: BLASELTYPES} SparseArrays.UMFPACK.UmfpackLU(SparseMatrixCSC{T, Int32}( zero(Int32), zero(Int32), [Int32(1)], Int32[], T[])) end @@ -218,7 +218,7 @@ function LinearSolve.init_cacheval( alg::KLUFactorization, A::AbstractArray, b, u, Pl, Pr, maxiters::Int, abstol, reltol, - verbose::Bool, assumptions::OperatorAssumptions) + verbose::LinearVerbosity, assumptions::OperatorAssumptions) nothing end @@ -226,7 +226,7 @@ function LinearSolve.init_cacheval( alg::KLUFactorization, A::AbstractSparseArray{Float64, Int64}, b, u, Pl, Pr, maxiters::Int, abstol, reltol, - verbose::Bool, assumptions::OperatorAssumptions) + verbose::LinearVerbosity, assumptions::OperatorAssumptions) PREALLOCATED_KLU end @@ -242,7 +242,7 @@ function LinearSolve.init_cacheval( alg::KLUFactorization, A::AbstractSparseArray{Float64, Int32}, b, u, Pl, Pr, maxiters::Int, abstol, reltol, - verbose::Bool, assumptions::OperatorAssumptions) + verbose::LinearVerbosity, assumptions::OperatorAssumptions) KLU.KLUFactorization(SparseMatrixCSC{Float64, Int32}( 0, 0, [Int32(1)], Int32[], Float64[])) end @@ -288,7 +288,7 @@ function LinearSolve.init_cacheval(alg::CHOLMODFactorization, A::Union{SparseMatrixCSC{T, Int}, Symmetric{T, SparseMatrixCSC{T, Int}}}, b, u, Pl, Pr, maxiters::Int, abstol, reltol, - verbose::Bool, assumptions::OperatorAssumptions) where {T <: + verbose::LinearVerbosity, assumptions::OperatorAssumptions) where {T <: Float64} PREALLOCATED_CHOLMOD end @@ -297,7 +297,7 @@ function LinearSolve.init_cacheval(alg::CHOLMODFactorization, A::Union{SparseMatrixCSC{T, Int}, Symmetric{T, SparseMatrixCSC{T, Int}}}, b, u, Pl, Pr, maxiters::Int, abstol, reltol, - verbose::Bool, assumptions::OperatorAssumptions) where {T <: + verbose::LinearVerbosity, assumptions::OperatorAssumptions) where {T <: BLASELTYPES} cholesky(sparse(reshape([one(T)], 1, 1))) end @@ -306,14 +306,14 @@ function LinearSolve.init_cacheval(alg::CHOLMODFactorization, A::AbstractArray, b, u, Pl, Pr, maxiters::Int, abstol, reltol, - verbose::Bool, assumptions::OperatorAssumptions) + verbose::LinearVerbosity, assumptions::OperatorAssumptions) nothing end function LinearSolve.init_cacheval(alg::NormalCholeskyFactorization, A::Union{AbstractSparseArray{T}, LinearSolve.GPUArraysCore.AnyGPUArray, Symmetric{T, <:AbstractSparseArray{T}}}, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) where {T <: BLASELTYPES} ArrayInterface.cholesky_instance(convert(AbstractMatrix, A)) end @@ -373,7 +373,7 @@ function LinearSolve.init_cacheval( alg::QRFactorization, A::AbstractSparseArray{<:Number, <:Integer}, b, u, Pl, Pr, maxiters::Int, abstol, reltol, - verbose::Bool, assumptions::OperatorAssumptions) + verbose::LinearVerbosity, assumptions::OperatorAssumptions) nothing end @@ -386,7 +386,7 @@ end function LinearSolve.init_cacheval( alg::QRFactorization, A::Symmetric{<:Number, <:SparseMatrixCSC}, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) return nothing end diff --git a/ext/LinearSolveSparspakExt.jl b/ext/LinearSolveSparspakExt.jl index 256ff617c..affd68302 100644 --- a/ext/LinearSolveSparspakExt.jl +++ b/ext/LinearSolveSparspakExt.jl @@ -12,14 +12,14 @@ function LinearSolve.init_cacheval( ::SparspakFactorization, A::SparseMatrixCSC{Float64, Int}, b, u, Pl, Pr, maxiters::Int, abstol, reltol, - verbose::Bool, assumptions::OperatorAssumptions) + verbose::LinearVerbosity, assumptions::OperatorAssumptions) PREALLOCATED_SPARSEPAK end function LinearSolve.init_cacheval( ::SparspakFactorization, A::AbstractSparseMatrixCSC{Tv, Ti}, b, u, Pl, Pr, maxiters::Int, abstol, reltol, - verbose::Bool, assumptions::OperatorAssumptions) where {Tv, Ti} + verbose::LinearVerbosity, assumptions::OperatorAssumptions) where {Tv, Ti} if size(A, 1) == size(A, 2) A = convert(AbstractMatrix, A) if A isa SparseArrays.AbstractSparseArray diff --git a/src/appleaccelerate.jl b/src/appleaccelerate.jl index a8772f336..da2a4f7da 100644 --- a/src/appleaccelerate.jl +++ b/src/appleaccelerate.jl @@ -220,14 +220,14 @@ const PREALLOCATED_APPLE_LU = begin end function LinearSolve.init_cacheval(alg::AppleAccelerateLUFactorization, A, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) PREALLOCATED_APPLE_LU end function LinearSolve.init_cacheval(alg::AppleAccelerateLUFactorization, A::AbstractMatrix{<:Union{Float32, ComplexF32, ComplexF64}}, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) A = rand(eltype(A), 0, 0) luinst = ArrayInterface.lu_instance(A) diff --git a/src/common.jl b/src/common.jl index 7c93c8ee8..587058625 100644 --- a/src/common.jl +++ b/src/common.jl @@ -79,7 +79,7 @@ mutable struct LinearCache{TA, Tb, Tu, Tp, Talg, Tc, Tl, Tr, Ttol, issq, S} abstol::Ttol reltol::Ttol maxiters::Int - verbose::Bool + verbose::LinearVerbosity assumptions::OperatorAssumptions{issq} sensealg::S end diff --git a/src/default.jl b/src/default.jl index 4d9095bd7..866e6d171 100644 --- a/src/default.jl +++ b/src/default.jl @@ -302,7 +302,7 @@ function SciMLBase.solve!(cache::LinearCache, alg::Nothing, end function init_cacheval(alg::Nothing, A, b, u, Pl, Pr, maxiters::Int, abstol, reltol, - verbose::Bool, assump::OperatorAssumptions) + verbose::LinearVerbosity, assump::OperatorAssumptions) init_cacheval(defaultalg(A, b, assump), A, b, u, Pl, Pr, maxiters, abstol, reltol, verbose, assump) @@ -313,7 +313,7 @@ cache.cacheval = NamedTuple(LUFactorization = cache of LUFactorization, ...) """ @generated function init_cacheval(alg::DefaultLinearSolver, A, b, u, Pl, Pr, maxiters::Int, abstol, reltol, - verbose::Bool, assump::OperatorAssumptions) + verbose::LinearVerbosity, assump::OperatorAssumptions) caches = map(first.(EnumX.symbol_map(DefaultAlgorithmChoice.T))) do alg if alg === :KrylovJL_GMRES || alg === :KrylovJL_CRAIGMR || alg === :KrylovJL_LSMR quote diff --git a/src/factorization.jl b/src/factorization.jl index 4b3e946a9..6107e4df2 100644 --- a/src/factorization.jl +++ b/src/factorization.jl @@ -50,14 +50,14 @@ end # RF Bad fallback: will fail if `A` is just a stand-in # This should instead just create the factorization type. function init_cacheval(alg::AbstractFactorization, A, b, u, Pl, Pr, maxiters::Int, abstol, - reltol, verbose::Bool, assumptions::OperatorAssumptions) + reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) 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) + abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) ipiv = Vector{LinearAlgebra.BlasInt}(undef, min(size(A)...)) ArrayInterface.lu_instance(convert(AbstractMatrix, A)), ipiv end @@ -65,14 +65,14 @@ end function LinearSolve.init_cacheval( alg::RFLUFactorization, A::Matrix{Float64}, b, u, Pl, Pr, maxiters::Int, - abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) + abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) PREALLOCATED_LU, PREALLOCATED_IPIV end function LinearSolve.init_cacheval(alg::RFLUFactorization, A::Union{Diagonal, SymTridiagonal, Tridiagonal}, b, u, Pl, Pr, maxiters::Int, - abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) + abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) nothing, nothing end @@ -171,7 +171,7 @@ end function init_cacheval( alg::GenericLUFactorization, A, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) ipiv = Vector{LinearAlgebra.BlasInt}(undef, min(size(A)...)) ArrayInterface.lu_instance(convert(AbstractMatrix, A)), ipiv @@ -179,7 +179,7 @@ end function init_cacheval( alg::GenericLUFactorization, A::Matrix{Float64}, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) PREALLOCATED_LU, PREALLOCATED_IPIV end @@ -211,21 +211,21 @@ end function init_cacheval( alg::LUFactorization, A, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) ArrayInterface.lu_instance(convert(AbstractMatrix, A)) end function init_cacheval(alg::LUFactorization, A::Union{<:Adjoint, <:Transpose}, b, u, Pl, Pr, maxiters::Int, abstol, reltol, - verbose::Bool, assumptions::OperatorAssumptions) + verbose::LinearVerbosity, assumptions::OperatorAssumptions) error_no_cudss_lu(A) return lu(A; check = false) end function init_cacheval(alg::GenericLUFactorization, A::Union{<:Adjoint, <:Transpose}, b, u, Pl, Pr, maxiters::Int, abstol, reltol, - verbose::Bool, assumptions::OperatorAssumptions) + verbose::LinearVerbosity, assumptions::OperatorAssumptions) error_no_cudss_lu(A) A isa GPUArraysCore.AnyGPUArray && return nothing ipiv = Vector{LinearAlgebra.BlasInt}(undef, 0) @@ -236,21 +236,21 @@ const PREALLOCATED_LU = ArrayInterface.lu_instance(rand(1, 1)) function init_cacheval(alg::LUFactorization, A::Matrix{Float64}, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) PREALLOCATED_LU end function init_cacheval(alg::LUFactorization, A::AbstractSciMLOperator, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) nothing end function init_cacheval(alg::GenericLUFactorization, A::AbstractSciMLOperator, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) nothing end @@ -300,13 +300,13 @@ function do_factorization(alg::QRFactorization, A, b, u) end function init_cacheval(alg::QRFactorization, A, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) ArrayInterface.qr_instance(convert(AbstractMatrix, A), alg.pivot) end function init_cacheval(alg::QRFactorization, A::Symmetric{<:Number, <:Array}, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) return qr(convert(AbstractMatrix, A), alg.pivot) end @@ -314,13 +314,13 @@ end const PREALLOCATED_QR_ColumnNorm = ArrayInterface.qr_instance(rand(1, 1), ColumnNorm()) function init_cacheval(alg::QRFactorization{ColumnNorm}, A::Matrix{Float64}, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) return PREALLOCATED_QR_ColumnNorm end function init_cacheval( alg::QRFactorization, A::Union{<:Adjoint, <:Transpose}, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) A isa GPUArraysCore.AnyGPUArray && return qr(A) return qr(A, alg.pivot) end @@ -328,12 +328,12 @@ end const PREALLOCATED_QR_NoPivot = ArrayInterface.qr_instance(rand(1, 1)) function init_cacheval(alg::QRFactorization{NoPivot}, A::Matrix{Float64}, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) return PREALLOCATED_QR_NoPivot end function init_cacheval(alg::QRFactorization, A::AbstractSciMLOperator, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) nothing end @@ -379,33 +379,33 @@ function do_factorization(alg::CholeskyFactorization, A, b, u) end function init_cacheval(alg::CholeskyFactorization, A::SMatrix{S1, S2}, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) where {S1, S2} cholesky(A) end function init_cacheval(alg::CholeskyFactorization, A::GPUArraysCore.AnyGPUArray, b, u, Pl, - Pr, maxiters::Int, abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) + Pr, maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) cholesky(A; check = false) end function init_cacheval( alg::CholeskyFactorization, A::AbstractArray{<:BLASELTYPES}, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) ArrayInterface.cholesky_instance(convert(AbstractMatrix, A), alg.pivot) end const PREALLOCATED_CHOLESKY = ArrayInterface.cholesky_instance(rand(1, 1), NoPivot()) function init_cacheval(alg::CholeskyFactorization, A::Matrix{Float64}, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) PREALLOCATED_CHOLESKY end function init_cacheval(alg::CholeskyFactorization, A::Union{Diagonal, AbstractSciMLOperator, AbstractArray}, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) nothing end @@ -433,12 +433,12 @@ end function init_cacheval(alg::LDLtFactorization, A, b, u, Pl, Pr, maxiters::Int, abstol, reltol, - verbose::Bool, assumptions::OperatorAssumptions) + verbose::LinearVerbosity, assumptions::OperatorAssumptions) nothing end function init_cacheval(alg::LDLtFactorization, A::SymTridiagonal, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) ArrayInterface.ldlt_instance(convert(AbstractMatrix, A)) end @@ -472,7 +472,7 @@ function do_factorization(alg::SVDFactorization, A, b, u) end function init_cacheval(alg::SVDFactorization, A::Union{Matrix, SMatrix}, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) ArrayInterface.svd_instance(convert(AbstractMatrix, A)) end @@ -480,13 +480,13 @@ end const PREALLOCATED_SVD = ArrayInterface.svd_instance(rand(1, 1)) function init_cacheval(alg::SVDFactorization, A::Matrix{Float64}, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) PREALLOCATED_SVD end function init_cacheval(alg::SVDFactorization, A, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) nothing end @@ -515,7 +515,7 @@ end function init_cacheval(alg::BunchKaufmanFactorization, A::Symmetric{<:Number, <:Matrix}, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) ArrayInterface.bunchkaufman_instance(convert(AbstractMatrix, A)) end @@ -525,13 +525,13 @@ const PREALLOCATED_BUNCHKAUFMAN = ArrayInterface.bunchkaufman_instance(Symmetric function init_cacheval(alg::BunchKaufmanFactorization, A::Symmetric{Float64, Matrix{Float64}}, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) PREALLOCATED_BUNCHKAUFMAN end function init_cacheval(alg::BunchKaufmanFactorization, A, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) nothing end @@ -572,58 +572,58 @@ end function init_cacheval( alg::GenericFactorization{typeof(lu)}, A::AbstractMatrix, b, u, Pl, Pr, maxiters::Int, - abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) + abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) ArrayInterface.lu_instance(A) end function init_cacheval( alg::GenericFactorization{typeof(lu!)}, A::AbstractMatrix, b, u, Pl, Pr, maxiters::Int, - abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) + abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) ArrayInterface.lu_instance(A) end function init_cacheval(alg::GenericFactorization{typeof(lu)}, A::StridedMatrix{<:LinearAlgebra.BlasFloat}, b, u, Pl, Pr, maxiters::Int, - abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) + abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) ArrayInterface.lu_instance(A) end function init_cacheval(alg::GenericFactorization{typeof(lu!)}, A::StridedMatrix{<:LinearAlgebra.BlasFloat}, b, u, Pl, Pr, maxiters::Int, - abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) + abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) ArrayInterface.lu_instance(A) end function init_cacheval(alg::GenericFactorization{typeof(lu)}, A::Diagonal, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) Diagonal(inv.(A.diag)) end function init_cacheval(alg::GenericFactorization{typeof(lu)}, A::Tridiagonal, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) ArrayInterface.lu_instance(A) end function init_cacheval(alg::GenericFactorization{typeof(lu!)}, A::Diagonal, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) Diagonal(inv.(A.diag)) end function init_cacheval( alg::GenericFactorization{typeof(lu!)}, A::Tridiagonal, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) ArrayInterface.lu_instance(A) end function init_cacheval( alg::GenericFactorization{typeof(lu!)}, A::SymTridiagonal{T, V}, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) where {T, V} LinearAlgebra.LDLt{T, SymTridiagonal{T, V}}(A) end function init_cacheval( alg::GenericFactorization{typeof(lu)}, A::SymTridiagonal{T, V}, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) where {T, V} LinearAlgebra.LDLt{T, SymTridiagonal{T, V}}(A) end @@ -631,24 +631,24 @@ end function init_cacheval( alg::GenericFactorization{typeof(qr)}, A::AbstractMatrix, b, u, Pl, Pr, maxiters::Int, - abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) + abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) ArrayInterface.qr_instance(A) end function init_cacheval( alg::GenericFactorization{typeof(qr!)}, A::AbstractMatrix, b, u, Pl, Pr, maxiters::Int, - abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) + abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) ArrayInterface.qr_instance(A) end function init_cacheval( alg::GenericFactorization{typeof(qr)}, A::SymTridiagonal{T, V}, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) where {T, V} LinearAlgebra.LDLt{T, SymTridiagonal{T, V}}(A) end function init_cacheval( alg::GenericFactorization{typeof(qr!)}, A::SymTridiagonal{T, V}, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) where {T, V} LinearAlgebra.LDLt{T, SymTridiagonal{T, V}}(A) end @@ -656,33 +656,33 @@ end function init_cacheval(alg::GenericFactorization{typeof(qr)}, A::StridedMatrix{<:LinearAlgebra.BlasFloat}, b, u, Pl, Pr, maxiters::Int, - abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) + abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) ArrayInterface.qr_instance(A) end function init_cacheval(alg::GenericFactorization{typeof(qr!)}, A::StridedMatrix{<:LinearAlgebra.BlasFloat}, b, u, Pl, Pr, maxiters::Int, - abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) + abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) ArrayInterface.qr_instance(A) end function init_cacheval(alg::GenericFactorization{typeof(qr)}, A::Diagonal, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) Diagonal(inv.(A.diag)) end function init_cacheval(alg::GenericFactorization{typeof(qr)}, A::Tridiagonal, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) ArrayInterface.qr_instance(A) end function init_cacheval(alg::GenericFactorization{typeof(qr!)}, A::Diagonal, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) Diagonal(inv.(A.diag)) end function init_cacheval( alg::GenericFactorization{typeof(qr!)}, A::Tridiagonal, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) ArrayInterface.qr_instance(A) end @@ -690,87 +690,87 @@ end function init_cacheval( alg::GenericFactorization{typeof(svd)}, A::AbstractMatrix, b, u, Pl, Pr, maxiters::Int, - abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) + abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) ArrayInterface.svd_instance(A) end function init_cacheval( alg::GenericFactorization{typeof(svd!)}, A::AbstractMatrix, b, u, Pl, Pr, maxiters::Int, - abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) + abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) ArrayInterface.svd_instance(A) end function init_cacheval(alg::GenericFactorization{typeof(svd)}, A::StridedMatrix{<:LinearAlgebra.BlasFloat}, b, u, Pl, Pr, maxiters::Int, - abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) + abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) ArrayInterface.svd_instance(A) end function init_cacheval(alg::GenericFactorization{typeof(svd!)}, A::StridedMatrix{<:LinearAlgebra.BlasFloat}, b, u, Pl, Pr, maxiters::Int, - abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) + abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) ArrayInterface.svd_instance(A) end function init_cacheval(alg::GenericFactorization{typeof(svd)}, A::Diagonal, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) Diagonal(inv.(A.diag)) end function init_cacheval( alg::GenericFactorization{typeof(svd)}, A::Tridiagonal, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) ArrayInterface.svd_instance(A) end function init_cacheval(alg::GenericFactorization{typeof(svd!)}, A::Diagonal, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) Diagonal(inv.(A.diag)) end function init_cacheval(alg::GenericFactorization{typeof(svd!)}, A::Tridiagonal, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) ArrayInterface.svd_instance(A) end function init_cacheval( alg::GenericFactorization{typeof(svd!)}, A::SymTridiagonal{T, V}, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) where {T, V} LinearAlgebra.LDLt{T, SymTridiagonal{T, V}}(A) end function init_cacheval( alg::GenericFactorization{typeof(svd)}, A::SymTridiagonal{T, V}, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) where {T, V} LinearAlgebra.LDLt{T, SymTridiagonal{T, V}}(A) end function init_cacheval(alg::GenericFactorization, A::Diagonal, b, u, Pl, Pr, maxiters::Int, - abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) + abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) Diagonal(inv.(A.diag)) end function init_cacheval(alg::GenericFactorization, A::Tridiagonal, b, u, Pl, Pr, maxiters::Int, - abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) + abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) ArrayInterface.lu_instance(A) end function init_cacheval(alg::GenericFactorization, A::SymTridiagonal{T, V}, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) where {T, V} LinearAlgebra.LDLt{T, SymTridiagonal{T, V}}(A) end function init_cacheval(alg::GenericFactorization, A, b, u, Pl, Pr, maxiters::Int, - abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) + abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) init_cacheval(alg, convert(AbstractMatrix, A), b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) end function init_cacheval(alg::GenericFactorization, A::AbstractMatrix, b, u, Pl, Pr, maxiters::Int, - abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) + abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) do_factorization(alg, A, b, u) end @@ -778,7 +778,7 @@ function init_cacheval( alg::Union{GenericFactorization{typeof(bunchkaufman!)}, GenericFactorization{typeof(bunchkaufman)}}, A::Union{Hermitian, Symmetric}, b, u, Pl, Pr, maxiters::Int, abstol, - reltol, verbose::Bool, assumptions::OperatorAssumptions) + reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) BunchKaufman(A.data, Array(1:size(A, 1)), A.uplo, true, false, 0) end @@ -787,7 +787,7 @@ function init_cacheval( GenericFactorization{typeof(bunchkaufman)}}, A::StridedMatrix{<:LinearAlgebra.BlasFloat}, b, u, Pl, Pr, maxiters::Int, - abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) + abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) if eltype(A) <: Complex return bunchkaufman!(Hermitian(A)) else @@ -801,49 +801,49 @@ end # Cholesky needs the posdef matrix, for GenericFactorization assume structure is needed function init_cacheval( alg::GenericFactorization{typeof(cholesky)}, A::AbstractMatrix, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) newA = copy(convert(AbstractMatrix, A)) do_factorization(alg, newA, b, u) end function init_cacheval( alg::GenericFactorization{typeof(cholesky!)}, A::AbstractMatrix, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) newA = copy(convert(AbstractMatrix, A)) do_factorization(alg, newA, b, u) end function init_cacheval(alg::GenericFactorization{typeof(cholesky!)}, A::Diagonal, b, u, Pl, Pr, maxiters::Int, - abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) + abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) Diagonal(inv.(A.diag)) end function init_cacheval( alg::GenericFactorization{typeof(cholesky!)}, A::Tridiagonal, b, u, Pl, Pr, maxiters::Int, - abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) + abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) ArrayInterface.lu_instance(A) end function init_cacheval( alg::GenericFactorization{typeof(cholesky!)}, A::SymTridiagonal{T, V}, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) where {T, V} LinearAlgebra.LDLt{T, SymTridiagonal{T, V}}(A) end function init_cacheval(alg::GenericFactorization{typeof(cholesky)}, A::Diagonal, b, u, Pl, Pr, maxiters::Int, - abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) + abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) Diagonal(inv.(A.diag)) end function init_cacheval( alg::GenericFactorization{typeof(cholesky)}, A::Tridiagonal, b, u, Pl, Pr, maxiters::Int, - abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) + abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) ArrayInterface.lu_instance(A) end function init_cacheval( alg::GenericFactorization{typeof(cholesky)}, A::SymTridiagonal{T, V}, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) where {T, V} LinearAlgebra.LDLt{T, SymTridiagonal{T, V}}(A) end @@ -875,7 +875,7 @@ end function init_cacheval(alg::UMFPACKFactorization, A, b, u, Pl, Pr, maxiters::Int, abstol, reltol, - verbose::Bool, assumptions::OperatorAssumptions) + verbose::LinearVerbosity, assumptions::OperatorAssumptions) nothing end @@ -901,7 +901,7 @@ end function init_cacheval(alg::KLUFactorization, A, b, u, Pl, Pr, maxiters::Int, abstol, reltol, - verbose::Bool, assumptions::OperatorAssumptions) + verbose::LinearVerbosity, assumptions::OperatorAssumptions) nothing end @@ -929,7 +929,7 @@ end function init_cacheval(alg::CHOLMODFactorization, A, b, u, Pl, Pr, maxiters::Int, abstol, reltol, - verbose::Bool, assumptions::OperatorAssumptions) + verbose::LinearVerbosity, assumptions::OperatorAssumptions) nothing end @@ -986,13 +986,13 @@ default_alias_b(::NormalCholeskyFactorization, ::Any, ::Any) = true const PREALLOCATED_NORMALCHOLESKY = ArrayInterface.cholesky_instance(rand(1, 1), NoPivot()) function init_cacheval(alg::NormalCholeskyFactorization, A::SMatrix, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) return cholesky(Symmetric((A)' * A)) end function init_cacheval(alg::NormalCholeskyFactorization, A, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) A_ = convert(AbstractMatrix, A) return ArrayInterface.cholesky_instance( @@ -1003,13 +1003,13 @@ const PREALLOCATED_NORMALCHOLESKY_SYMMETRIC = ArrayInterface.cholesky_instance( Symmetric(rand(1, 1)), NoPivot()) function init_cacheval(alg::NormalCholeskyFactorization, A::Matrix{Float64}, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) return PREALLOCATED_NORMALCHOLESKY_SYMMETRIC end function init_cacheval(alg::NormalCholeskyFactorization, A::Union{Diagonal, AbstractSciMLOperator}, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) nothing end @@ -1070,7 +1070,7 @@ default_alias_A(::NormalBunchKaufmanFactorization, ::Any, ::Any) = true default_alias_b(::NormalBunchKaufmanFactorization, ::Any, ::Any) = true function init_cacheval(alg::NormalBunchKaufmanFactorization, A, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) ArrayInterface.bunchkaufman_instance(convert(AbstractMatrix, A)) end @@ -1098,7 +1098,7 @@ A special implementation only for solving `Diagonal` matrices fast. struct DiagonalFactorization <: AbstractDenseFactorization end function init_cacheval(alg::DiagonalFactorization, A, b, u, Pl, Pr, maxiters::Int, - abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) + abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) nothing end @@ -1149,22 +1149,22 @@ end function init_cacheval(alg::SparspakFactorization, A::Union{AbstractMatrix, Nothing, AbstractSciMLOperator}, b, u, Pl, Pr, maxiters::Int, abstol, reltol, - verbose::Bool, assumptions::OperatorAssumptions) + verbose::LinearVerbosity, assumptions::OperatorAssumptions) nothing end function init_cacheval(::SparspakFactorization, ::StaticArray, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions) + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) nothing end for alg in vcat(InteractiveUtils.subtypes(AbstractDenseFactorization), InteractiveUtils.subtypes(AbstractSparseFactorization)) @eval function init_cacheval(alg::$alg, A::MatrixOperator, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) init_cacheval(alg, A.A, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) end end diff --git a/src/iterative_wrappers.jl b/src/iterative_wrappers.jl index 630389df6..e565148b2 100644 --- a/src/iterative_wrappers.jl +++ b/src/iterative_wrappers.jl @@ -185,7 +185,7 @@ end # zeroinit allows for init_cacheval to start by initing with A (0,0) function init_cacheval(alg::KrylovJL, A, b, u, Pl, Pr, maxiters::Int, abstol, reltol, - verbose::Bool, assumptions::OperatorAssumptions; zeroinit = true) + verbose::LinearVerbosity, assumptions::OperatorAssumptions; zeroinit = true) KS = get_KrylovJL_solver(alg.KrylovAlg) if zeroinit @@ -240,7 +240,7 @@ end # Krylov.jl tries to init with `ArrayPartition(undef, ...)`. Avoid hitting that! function init_cacheval( alg::LinearSolve.KrylovJL, A, b::RecursiveArrayTools.ArrayPartition, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, ::LinearSolve.OperatorAssumptions) + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, ::LinearSolve.OperatorAssumptions) return nothing end diff --git a/src/mkl.jl b/src/mkl.jl index 189c1ab75..72d30df0c 100644 --- a/src/mkl.jl +++ b/src/mkl.jl @@ -197,14 +197,14 @@ const PREALLOCATED_MKL_LU = begin end function LinearSolve.init_cacheval(alg::MKLLUFactorization, A, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) PREALLOCATED_MKL_LU end function LinearSolve.init_cacheval(alg::MKLLUFactorization, A::AbstractMatrix{<:Union{Float32, ComplexF32, ComplexF64}}, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) A = rand(eltype(A), 0, 0) ArrayInterface.lu_instance(A), Ref{BlasInt}() diff --git a/src/simplelu.jl b/src/simplelu.jl index 9c1ad0bf7..910211b2c 100644 --- a/src/simplelu.jl +++ b/src/simplelu.jl @@ -143,6 +143,6 @@ function SciMLBase.solve!(cache::LinearCache, alg::SimpleLUFactorization; kwargs end function init_cacheval(alg::SimpleLUFactorization, A, b, u, Pl, Pr, maxiters::Int, abstol, - reltol, verbose::Bool, assumptions::OperatorAssumptions) + reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) LUSolver(convert(AbstractMatrix, A)) end From 525eae2971a86a1419dfd013223573656a2fd118 Mon Sep 17 00:00:00 2001 From: jClugstor Date: Tue, 10 Jun 2025 11:31:21 -0400 Subject: [PATCH 06/36] make default verbose a LInearVerbosity --- src/common.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/common.jl b/src/common.jl index 587058625..c1109ede5 100644 --- a/src/common.jl +++ b/src/common.jl @@ -143,7 +143,7 @@ function SciMLBase.init(prob::LinearProblem, alg::SciMLLinearSolveAlgorithm, abstol = default_tol(real(eltype(prob.b))), reltol = default_tol(real(eltype(prob.b))), maxiters::Int = length(prob.b), - verbose::LinearVerbosity = false, + verbose::LinearVerbosity = LinearVerbosity(), Pl = nothing, Pr = nothing, assumptions = OperatorAssumptions(issquare(prob.A)), From 39a3a63292401661e73ca6593775206c663ee400 Mon Sep 17 00:00:00 2001 From: jClugstor Date: Tue, 10 Jun 2025 11:31:32 -0400 Subject: [PATCH 07/36] make KrylovKit verbosity work --- ext/LinearSolveKrylovKitExt.jl | 10 ++++++++++ src/iterative_wrappers.jl | 2 +- 2 files changed, 11 insertions(+), 1 deletion(-) diff --git a/ext/LinearSolveKrylovKitExt.jl b/ext/LinearSolveKrylovKitExt.jl index 1aa1e5d52..ee714786d 100644 --- a/ext/LinearSolveKrylovKitExt.jl +++ b/ext/LinearSolveKrylovKitExt.jl @@ -26,6 +26,7 @@ function SciMLBase.solve!(cache::LinearCache, alg::KrylovKitJL; kwargs...) rtol = float(cache.reltol) maxiter = cache.maxiters verbosity = cache.verbose ? 1 : 0 + verbosity = verbosity_to_KrylovKit(cache.verbose.numerical.Krylovkit_verbosity) krylovdim = (alg.gmres_restart == 0) ? min(20, size(cache.A, 1)) : alg.gmres_restart kwargs = (atol = atol, rtol = rtol, maxiter = maxiter, verbosity = verbosity, @@ -41,4 +42,13 @@ function SciMLBase.solve!(cache::LinearCache, alg::KrylovKitJL; kwargs...) iters = iters) end +function verbosity_to_KrylovKit(verb::SciML.Verbosity.Type) + SciML.@match verb begin + Verbosity.None() => 0 + Verbosity.Warn() => 1 + Verbosity.Error() => 2 + Verbosity.Info() => 3 + Level(x) => x + _ => error("Not a valid verbosity level for KrylovKit.") + end end diff --git a/src/iterative_wrappers.jl b/src/iterative_wrappers.jl index e565148b2..5f49299a8 100644 --- a/src/iterative_wrappers.jl +++ b/src/iterative_wrappers.jl @@ -268,7 +268,7 @@ function SciMLBase.solve!(cache::LinearCache, alg::KrylovJL; kwargs...) atol = float(cache.abstol) rtol = float(cache.reltol) itmax = cache.maxiters - verbose = cache.verbose ? 1 : 0 + verbose = cache.verbose cacheval = if cache.alg isa DefaultLinearSolver if alg.KrylovAlg === Krylov.gmres! From bbc687ca3fc64ff626154cb4c7deecfc73736c17 Mon Sep 17 00:00:00 2001 From: jClugstor Date: Wed, 11 Jun 2025 12:31:20 -0400 Subject: [PATCH 08/36] make sure krylov verbosity works --- ext/LinearSolveKrylovKitExt.jl | 2 +- src/iterative_wrappers.jl | 10 +++++++++- 2 files changed, 10 insertions(+), 2 deletions(-) diff --git a/ext/LinearSolveKrylovKitExt.jl b/ext/LinearSolveKrylovKitExt.jl index ee714786d..dded0338b 100644 --- a/ext/LinearSolveKrylovKitExt.jl +++ b/ext/LinearSolveKrylovKitExt.jl @@ -42,7 +42,7 @@ function SciMLBase.solve!(cache::LinearCache, alg::KrylovKitJL; kwargs...) iters = iters) end -function verbosity_to_KrylovKit(verb::SciML.Verbosity.Type) +function verbosity_to_KrylovKit(verb::SciMLBase.Verbosity.Type) SciML.@match verb begin Verbosity.None() => 0 Verbosity.Warn() => 1 diff --git a/src/iterative_wrappers.jl b/src/iterative_wrappers.jl index 5f49299a8..c1436d759 100644 --- a/src/iterative_wrappers.jl +++ b/src/iterative_wrappers.jl @@ -284,8 +284,14 @@ function SciMLBase.solve!(cache::LinearCache, alg::KrylovJL; kwargs...) cache.cacheval end + krylovJL_verbose = SciMLBase.@match verbose.numerical.KrylovJL_verbosity begin + SciMLBase.Verbosity.None() => 0 + ::SciMLBase.Verbosity.Type => 1 + _ => error("Invalid verbosity.") + end + args = (cacheval, cache.A, cache.b) - kwargs = (atol = atol, rtol, itmax, verbose, + kwargs = (atol = atol, rtol, itmax, verbose = krylovJL_verbose, ldiv = true, history = true, alg.kwargs...) if cache.cacheval isa Krylov.CgWorkspace @@ -333,3 +339,5 @@ function SciMLBase.solve!(cache::LinearCache, alg::KrylovJL; kwargs...) return SciMLBase.build_linear_solution(alg, cache.u, Ref(resid), cache; iters = stats.niter, retcode, stats) end + + From fa3ae3d5d9b56320903cc3f35324bc615e7da382 Mon Sep 17 00:00:00 2001 From: jClugstor Date: Wed, 11 Jun 2025 12:31:34 -0400 Subject: [PATCH 09/36] using more stuff --- src/LinearSolve.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/LinearSolve.jl b/src/LinearSolve.jl index d96180add..87f6c2cbe 100644 --- a/src/LinearSolve.jl +++ b/src/LinearSolve.jl @@ -16,7 +16,7 @@ using LinearAlgebra: LinearAlgebra, BlasInt, LU, Adjoint, BLAS, Bidiagonal, Bunc norm, qr, qr!, svd, svd! using LazyArrays: @~, BroadcastArray -using SciMLBase: SciMLBase, LinearAliasSpecifier, LinearVerbosity, Verbosity, @SciMLMessage, AbstractSciMLOperator, +using SciMLBase: SciMLBase, LinearAliasSpecifier, LinearVerbosity, Verbosity, @SciMLMessage, LinearVerbosity, AbstractSciMLOperator, init, solve!, reinit!, solve, ReturnCode, LinearProblem using SciMLOperators: SciMLOperators, AbstractSciMLOperator, IdentityOperator, MatrixOperator, From 219d7ed1e4cb86c6d55334b24a7a69f42609bf97 Mon Sep 17 00:00:00 2001 From: jClugstor Date: Mon, 7 Jul 2025 11:46:39 -0400 Subject: [PATCH 10/36] add verbosity types --- src/verbosity.jl | 178 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 178 insertions(+) create mode 100644 src/verbosity.jl diff --git a/src/verbosity.jl b/src/verbosity.jl new file mode 100644 index 000000000..e6ee72142 --- /dev/null +++ b/src/verbosity.jl @@ -0,0 +1,178 @@ +# Linear Verbosity + +linear_defaults = Dict( + :default_lu_fallback => Verbosity.Warn(), + :no_right_preconditioning => Verbosity.Warn(), + :using_iterative_solvers => Verbosity.Warn(), + :using_IterativeSolvers => Verbosity.Warn(), + :IterativeSolvers_iterations => Verbosity.Warn(), + :KrylovKit_verbosity => Verbosity.Warn(), + :KrylovJL_verbosity => Verbosity.None() +) +mutable struct LinearErrorControlVerbosity + default_lu_fallback::Verbosity.Type + + function LinearErrorControlVerbosity(; + default_lu_fallback = linear_defaults[:default_lu_fallback]) + new(default_lu_fallback) + end + + function LinearErrorControlVerbosity(verbose::Verbosity.Type) + @match verbose begin + Verbosity.None() => new(fill( + Verbosity.None(), length(fieldnames(LinearErrorControlVerbosity)))...) + + Verbosity.Info() => new(fill( + Verbosity.Info(), length(fieldnames(LinearErrorControlVerbosity)))...) + + Verbosity.Warn() => new(fill( + Verbosity.Warn(), length(fieldnames(LinearErrorControlVerbosity)))...) + + Verbosity.Error() => new(fill( + Verbosity.Error(), length(fieldnames(LinearErrorControlVerbosity)))...) + + Verbosity.Default() => LinearErrorControlVerbosity() + + Verbosity.Edge() => LinearErrorControlVerbosity() + + _ => @error "Not a valid choice for verbosity." + end + end +end + +mutable struct LinearPerformanceVerbosity + no_right_preconditioning::Verbosity.Type + + function LinearPerformanceVerbosity(; + no_right_preconditioning = linear_defaults[:no_right_preconditioning]) + new(no_right_preconditioning) + end + + function LinearPerformanceVerbosity(verbose::Verbosity.Type) + @match verbose begin + Verbosity.None() => new(fill( + Verbosity.None(), length(fieldnames(LinearPerformanceVerbosity)))...) + + Verbosity.Info() => new(fill( + Verbosity.Info(), length(fieldnames(LinearPerformanceVerbosity)))...) + + Verbosity.Warn() => new(fill( + Verbosity.Warn(), length(fieldnames(LinearPerformanceVerbosity)))...) + + Verbosity.Error() => new(fill( + Verbosity.Error(), length(fieldnames(LinearPerformanceVerbosity)))...) + + Verbosity.Default() => LinearPerformanceVerbosity() + + Verbosity.Edge() => LinearPerformanceVerbosity() + + _ => @error "Not a valid choice for verbosity." + end + end +end + +mutable struct LinearNumericalVerbosity + using_IterativeSolvers::Verbosity.Type + IterativeSolvers_iterations::Verbosity.Type + KrylovKit_verbosity::Verbosity.Type + KrylovJL_verbosity::Verbosity.Type + + function LinearNumericalVerbosity(; + using_IterativeSolvers = linear_defaults[:using_IterativeSolvers], + IterativeSolvers_iterations = linear_defaults[:IterativeSolvers_iterations], + KrylovKit_verbosity = linear_defaults[:KrylovKit_verbosity], + KrylovJL_verbosity = linear_defaults[:KrylovJL_verbosity]) + new(using_IterativeSolvers, IterativeSolvers_iterations, + KrylovKit_verbosity, KrylovJL_verbosity) + end + + function LinearNumericalVerbosity(verbose::Verbosity.Type) + @match verbose begin + Verbosity.None() => new(fill( + Verbosity.None(), length(fieldnames(LinearNumericalVerbosity)))...) + + Verbosity.Info() => new(fill( + Verbosity.Info(), length(fieldnames(LinearNumericalVerbosity)))...) + + Verbosity.Warn() => new(fill( + Verbosity.Warn(), length(fieldnames(LinearNumericalVerbosity)))...) + + Verbosity.Error() => new(fill( + Verbosity.Error(), length(fieldnames(LinearNumericalVerbosity)))...) + + Verbosity.Default() => LinearNumericalVerbosity() + + Verbosity.Edge() => LinearNumericalVerbosity() + + _ => @error "Not a valid choice for verbosity." + end + end +end + +struct LinearVerbosity{T} <: AbstractVerbositySpecifier{T} + error_control::LinearErrorControlVerbosity + performance::LinearPerformanceVerbosity + numerical::LinearNumericalVerbosity +end + +function LinearVerbosity(verbose::Verbosity.Type) + @match verbose begin + Verbosity.Default() => LinearVerbosity{true}( + LinearErrorControlVerbosity(Verbosity.Default()), + LinearPerformanceVerbosity(Verbosity.Default()), + LinearNumericalVerbosity(Verbosity.Default()) + ) + + Verbosity.None() => LinearVerbosity{false}( + LinearErrorControlVerbosity(Verbosity.None()), + LinearPerformanceVerbosity(Verbosity.None()), + LinearNumericalVerbosity(Verbosity.None())) + + Verbosity.All() => LinearVerbosity{true}( + LinearErrorControlVerbosity(Verbosity.Info()), + LinearPerformanceVerbosity(Verbosity.Info()), + LinearNumericalVerbosity(Verbosity.Info()) + ) + + _ => @error "Not a valid choice for LinearVerbosity. Available choices are `Default`, `None`, and `All`." + end +end + +function LinearVerbosity(; + error_control = Verbosity.Default(), performance = Verbosity.Default(), + numerical = Verbosity.Default(), kwargs...) + if error_control isa Verbosity.Type + error_control_verbosity = LinearErrorControlVerbosity(error_control) + else + error_control_verbosity = error_control + end + + if performance isa Verbosity.Type + performance_verbosity = LinearPerformanceVerbosity(performance) + else + performance_verbosity = performance + end + + if numerical isa Verbosity.Type + numerical_verbosity = LinearNumericalVerbosity(numerical) + else + numerical_verbosity = numerical + end + + if !isempty(kwargs) + for (key, value) in pairs(kwargs) + if hasfield(LinearErrorControlVerbosity, key) + setproperty!(error_control_verbosity, key, value) + elseif hasfield(LinearPerformanceVerbosity, key) + setproperty!(performance_verbosity, key, value) + elseif hasfield(LinearNumericalVerbosity, key) + setproperty!(numerical_verbosity, key, value) + else + error("$key is not a recognized verbosity toggle.") + end + end + end + + LinearVerbosity{true}(error_control_verbosity, + performance_verbosity, numerical_verbosity) +end \ No newline at end of file From cef5050893a3bcb2a192bc015816664dc77b08e2 Mon Sep 17 00:00:00 2001 From: jClugstor Date: Tue, 8 Jul 2025 13:43:28 -0400 Subject: [PATCH 11/36] add SciMLVerbosity as dep --- Project.toml | 1 + 1 file changed, 1 insertion(+) diff --git a/Project.toml b/Project.toml index 08e28aa60..db6bb9402 100644 --- a/Project.toml +++ b/Project.toml @@ -23,6 +23,7 @@ RecursiveArrayTools = "731186ca-8d62-57ce-b412-fbd966d074cd" Reexport = "189a3867-3050-52da-a836-e630ba90ab69" SciMLBase = "0bca4576-84f4-4d90-8ffe-ffa030f20462" SciMLOperators = "c0aeaf25-5076-4817-a8d5-81caf7dfa961" +SciMLVerbosity = "a05b3ec9-34a1-438a-b0a1-c0adb433119f" Setfield = "efcf1570-3423-57d1-acb7-fd33fddbac46" StaticArraysCore = "1e83bf80-4336-4d27-bf5d-d5a4f845583c" UnPack = "3a884ed6-31ef-47d7-9d2a-63182c4928ed" From ed1b9386db9c15dbb324a8dc3e3ecce5b157a72d Mon Sep 17 00:00:00 2001 From: jClugstor Date: Tue, 8 Jul 2025 13:43:57 -0400 Subject: [PATCH 12/36] use SciMLVerbosity not SciMLBase --- ext/LinearSolveKrylovKitExt.jl | 2 +- src/LinearSolve.jl | 4 +++- src/iterative_wrappers.jl | 4 ++-- 3 files changed, 6 insertions(+), 4 deletions(-) diff --git a/ext/LinearSolveKrylovKitExt.jl b/ext/LinearSolveKrylovKitExt.jl index dded0338b..cd448c044 100644 --- a/ext/LinearSolveKrylovKitExt.jl +++ b/ext/LinearSolveKrylovKitExt.jl @@ -42,7 +42,7 @@ function SciMLBase.solve!(cache::LinearCache, alg::KrylovKitJL; kwargs...) iters = iters) end -function verbosity_to_KrylovKit(verb::SciMLBase.Verbosity.Type) +function verbosity_to_KrylovKit(verb::Verbosity.Type) SciML.@match verb begin Verbosity.None() => 0 Verbosity.Warn() => 1 diff --git a/src/LinearSolve.jl b/src/LinearSolve.jl index 87f6c2cbe..a210fe63e 100644 --- a/src/LinearSolve.jl +++ b/src/LinearSolve.jl @@ -16,11 +16,12 @@ using LinearAlgebra: LinearAlgebra, BlasInt, LU, Adjoint, BLAS, Bidiagonal, Bunc norm, qr, qr!, svd, svd! using LazyArrays: @~, BroadcastArray -using SciMLBase: SciMLBase, LinearAliasSpecifier, LinearVerbosity, Verbosity, @SciMLMessage, LinearVerbosity, AbstractSciMLOperator, +using SciMLBase: SciMLBase, LinearAliasSpecifier, AbstractSciMLOperator, init, solve!, reinit!, solve, ReturnCode, LinearProblem using SciMLOperators: SciMLOperators, AbstractSciMLOperator, IdentityOperator, MatrixOperator, has_ldiv!, issquare +using SciMLVerbosity: Verbosity, @SciMLMessage, @match, AbstractVerbositySpecifier using Setfield: @set, @set! using UnPack: @unpack using DocStringExtensions: DocStringExtensions @@ -152,6 +153,7 @@ const BLASELTYPES = Union{Float32, Float64, ComplexF32, ComplexF64} function defaultalg_symbol end +include("verbosity.jl") include("generic_lufact.jl") include("common.jl") include("extension_algs.jl") diff --git a/src/iterative_wrappers.jl b/src/iterative_wrappers.jl index c1436d759..3be8c37a6 100644 --- a/src/iterative_wrappers.jl +++ b/src/iterative_wrappers.jl @@ -285,8 +285,8 @@ function SciMLBase.solve!(cache::LinearCache, alg::KrylovJL; kwargs...) end krylovJL_verbose = SciMLBase.@match verbose.numerical.KrylovJL_verbosity begin - SciMLBase.Verbosity.None() => 0 - ::SciMLBase.Verbosity.Type => 1 + Verbosity.None() => 0 + ::Verbosity.Type => 1 _ => error("Invalid verbosity.") end From 1da71ffc3539b771813b93c7c852b7726e0c766f Mon Sep 17 00:00:00 2001 From: jClugstor Date: Wed, 9 Jul 2025 14:36:24 -0400 Subject: [PATCH 13/36] replace --- ext/LinearSolveSparseArraysExt.jl | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/ext/LinearSolveSparseArraysExt.jl b/ext/LinearSolveSparseArraysExt.jl index 8974133d2..0dfa530aa 100644 --- a/ext/LinearSolveSparseArraysExt.jl +++ b/ext/LinearSolveSparseArraysExt.jl @@ -136,7 +136,7 @@ function LinearSolve.init_cacheval( alg::LUFactorization, A::LinearSolve.GPUArraysCore.AnyGPUArray, b, u, Pl, Pr, maxiters::Int, abstol, reltol, - verbose::Bool, assumptions::OperatorAssumptions) + verbose::LinearVerbosity, assumptions::OperatorAssumptions) ArrayInterface.lu_instance(A) end @@ -152,7 +152,7 @@ function LinearSolve.init_cacheval( alg::UMFPACKFactorization, A::LinearSolve.GPUArraysCore.AnyGPUArray, b, u, Pl, Pr, maxiters::Int, abstol, reltol, - verbose::Bool, assumptions::OperatorAssumptions) + verbose::LinearVerbosity, assumptions::OperatorAssumptions) nothing end @@ -234,7 +234,7 @@ function LinearSolve.init_cacheval( alg::KLUFactorization, A::LinearSolve.GPUArraysCore.AnyGPUArray, b, u, Pl, Pr, maxiters::Int, abstol, reltol, - verbose::Bool, assumptions::OperatorAssumptions) + verbose::LinearVerbosity, assumptions::OperatorAssumptions) nothing end From 900b927ea8f60adfd26f6c9ffd7c272409e9c2aa Mon Sep 17 00:00:00 2001 From: jClugstor Date: Mon, 14 Jul 2025 09:27:53 -0400 Subject: [PATCH 14/36] imports --- ext/LinearSolveKrylovKitExt.jl | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/ext/LinearSolveKrylovKitExt.jl b/ext/LinearSolveKrylovKitExt.jl index cd448c044..4a50bcdeb 100644 --- a/ext/LinearSolveKrylovKitExt.jl +++ b/ext/LinearSolveKrylovKitExt.jl @@ -1,6 +1,7 @@ module LinearSolveKrylovKitExt using LinearSolve, KrylovKit, LinearAlgebra +using SciMLVerbosity: @match, Verbosity using LinearSolve: LinearCache, DEFAULT_PRECS function LinearSolve.KrylovKitJL(args...; @@ -25,8 +26,7 @@ function SciMLBase.solve!(cache::LinearCache, alg::KrylovKitJL; kwargs...) atol = float(cache.abstol) rtol = float(cache.reltol) maxiter = cache.maxiters - verbosity = cache.verbose ? 1 : 0 - verbosity = verbosity_to_KrylovKit(cache.verbose.numerical.Krylovkit_verbosity) + verbosity = verbosity_to_KrylovKit(cache.verbose.numerical.KrylovKit_verbosity) krylovdim = (alg.gmres_restart == 0) ? min(20, size(cache.A, 1)) : alg.gmres_restart kwargs = (atol = atol, rtol = rtol, maxiter = maxiter, verbosity = verbosity, @@ -43,12 +43,14 @@ function SciMLBase.solve!(cache::LinearCache, alg::KrylovKitJL; kwargs...) end function verbosity_to_KrylovKit(verb::Verbosity.Type) - SciML.@match verb begin + @match verb begin Verbosity.None() => 0 Verbosity.Warn() => 1 Verbosity.Error() => 2 Verbosity.Info() => 3 - Level(x) => x + Verbosity.Level(x) => x _ => error("Not a valid verbosity level for KrylovKit.") end end + +end From 1630865b34717a7fc400f4bbe4ef75558aa0b559 Mon Sep 17 00:00:00 2001 From: jClugstor Date: Sun, 20 Jul 2025 14:27:53 -0400 Subject: [PATCH 15/36] use LinearVerbosity for verbose --- ext/LinearSolveSparseArraysExt.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ext/LinearSolveSparseArraysExt.jl b/ext/LinearSolveSparseArraysExt.jl index 0dfa530aa..ba1f3655a 100644 --- a/ext/LinearSolveSparseArraysExt.jl +++ b/ext/LinearSolveSparseArraysExt.jl @@ -379,7 +379,7 @@ end function LinearSolve.init_cacheval( alg::QRFactorization, A::SparseMatrixCSC{Float64, <:Integer}, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) ArrayInterface.qr_instance(convert(AbstractMatrix, A), alg.pivot) end From c9746f667ef1fc180ae7a9e0478982acfc7006a5 Mon Sep 17 00:00:00 2001 From: jClugstor Date: Sun, 20 Jul 2025 15:13:20 -0400 Subject: [PATCH 16/36] allow for bool verbose for backwards compatibility --- src/common.jl | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/src/common.jl b/src/common.jl index c1109ede5..f9e7d6f26 100644 --- a/src/common.jl +++ b/src/common.jl @@ -143,7 +143,7 @@ function SciMLBase.init(prob::LinearProblem, alg::SciMLLinearSolveAlgorithm, abstol = default_tol(real(eltype(prob.b))), reltol = default_tol(real(eltype(prob.b))), maxiters::Int = length(prob.b), - verbose::LinearVerbosity = LinearVerbosity(), + verbose = LinearVerbosity(), Pl = nothing, Pr = nothing, assumptions = OperatorAssumptions(issquare(prob.A)), @@ -200,6 +200,16 @@ function SciMLBase.init(prob::LinearProblem, alg::SciMLLinearSolveAlgorithm, deepcopy(A) end + if verbose isa Bool + #@warn "Using `true` or `false` for `verbose` is being deprecated. Please use a `LinearVerbosity` type to specify verbosity settings. + # For details see the verbosity section of the common solver options documentation page." + if verbose + verbose = LinearVerbosity() + else + verbose = LinearVerbosity(Verbosity.None()) + end + end + b = if issparsematrix(b) && !(A isa Diagonal) Array(b) # the solution to a linear solve will always be dense! elseif alias_b || b isa SVector From 96b65093f6ad0f950dd4727d78890fdf1eacc349 Mon Sep 17 00:00:00 2001 From: jClugstor Date: Sun, 20 Jul 2025 16:11:36 -0400 Subject: [PATCH 17/36] add documentation --- docs/src/basics/common_solver_opts.md | 90 ++++++++++++++++++++++++++- 1 file changed, 89 insertions(+), 1 deletion(-) diff --git a/docs/src/basics/common_solver_opts.md b/docs/src/basics/common_solver_opts.md index 80c994621..bb45a537a 100644 --- a/docs/src/basics/common_solver_opts.md +++ b/docs/src/basics/common_solver_opts.md @@ -12,7 +12,6 @@ The following are the options these algorithms take, along with their defaults. `A` and `b` can be written to and changed by the solver algorithm. When fields are `nothing` the default behavior is used, which is to default to `true` when the algorithm is known not to modify the matrices, and false otherwise. - - `verbose`: Whether to print extra information. Defaults to `false`. - `assumptions`: Sets the assumptions of the operator in order to effect the default choice algorithm. See the [Operator Assumptions page for more details](@ref assumptions). @@ -26,3 +25,92 @@ solve completely. Error controls only apply to iterative solvers. - `maxiters`: The number of iterations allowed. Defaults to `length(prob.b)` - `Pl,Pr`: The left and right preconditioners, respectively. For more information, see [the Preconditioners page](@ref prec). + +## Verbosity Controls + +The verbosity system in LinearSolve.jl provides fine-grained control over the diagnostic messages, warnings, and errors that are displayed during the solution of linear systems. + +The verbosity system is organized hierarchically into three main categories: + +1. Error Control - Messages related to fallbacks and error handling +2. Performance - Messages related to performance considerations +3. Numerical - Messages related to numerical solvers and iterations + +Each category can be configured independently, and individual settings can be adjusted to suit your needs. + +### Verbosity Levels +The following verbosity levels are available: + +#### Individual Settings +These settings are meant for individual settings within a category. These can also be used to set all of the individual settings in a group to the same value. +- Verbosity.None() - Suppress all messages +- Verbosity.Info() - Show message as log message at info level +- Verbosity.Warn() - Show warnings (default for most settings) +- Verbosity.Error() - Throw errors instead of warnings +- Verbosity.Level(n) - Show messages with a log level setting of n + +#### Group Settings +These settings are meant for +- Verbosity.Default() - Use the default settings +- Verbosity.All() - Show all possible messages + +### Basic Usage + +#### Global Verbosity Control + +```julia +using LinearSolve + +# Suppress all messages +verbose = LinearVerbosity(Verbosity.None()) +prob = LinearProblem(A, b) +sol = solve(prob; verbose=verbose) + +# Show all messages +verbose = LinearVerbosity(Verbosity.All()) +sol = solve(prob; verbose=verbose) + +# Use default settings +verbose = LinearVerbosity(Verbosity.Default()) +sol = solve(prob; verbose=verbose) +``` + +#### Group Level Control + +```julia +# Customize by category +verbose = LinearVerbosity( + error_control = Verbosity.Warn(), # Show warnings for error control related issues + performance = Verbosity.None(), # Suppress performance messages + numerical = Verbosity.Info() # Show all numerical related log messages at info level +) + +sol = solve(prob; verbose=verbose) +``` + +#### Fine-grained Control +The constructor for `LinearVerbosity` allows you to set verbosity for each specific message toggle, giving you fine-grained control. +The verbosity settings for the toggles are automatically passed to the group objects. +```julia +# Set specific message types +verbose = LinearVerbosity( + default_lu_fallback = Verbosity.Info(), # Show info when LU fallback is used + KrylovJL_verbosity = Verbosity.Warn(), # Show warnings from KrylovJL + no_right_preconditioning = Verbosity.None(), # Suppress right preconditioning messages + KrylovKit_verbosity = Verbosity.Level(KrylovKit.WARN_LEVEL) # Set KrylovKit verbosity level using KrylovKit's own verbosity levels +) + +sol = solve(prob; verbose=verbose) + +``` + +#### Verbosity Levels +##### Error Control Settings +- default_lu_fallback: Controls messages when falling back to LU factorization (default: Warn) +##### Performance Settings +- no_right_preconditioning: Controls messages when right preconditioning is not used (default: Warn) +##### Numerical Settings +- using_IterativeSolvers: Controls messages when using the IterativeSolvers.jl package (default: Warn) +- IterativeSolvers_iterations: Controls messages about iteration counts from IterativeSolvers.jl (default: Warn) +- KrylovKit_verbosity: Controls messages from the KrylovKit.jl package (default: Warn) +- KrylovJL_verbosity: Controls verbosity of the KrylovJL.jl package (default: None) \ No newline at end of file From 3b631cecb27c401a667a55f3c2bf804221f5fe77 Mon Sep 17 00:00:00 2001 From: jClugstor Date: Sun, 20 Jul 2025 16:15:16 -0400 Subject: [PATCH 18/36] fix imports and exports --- src/LinearSolve.jl | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/LinearSolve.jl b/src/LinearSolve.jl index a210fe63e..bb515851d 100644 --- a/src/LinearSolve.jl +++ b/src/LinearSolve.jl @@ -237,6 +237,8 @@ error_no_cudss_lu(A) = nothing cudss_loaded(A) = false is_cusparse(A) = false +export LinearVerbosity, LinearErrorControlVerbosity, LinearPerformanceVerbosity, LinearNumericalVerbosity + export LUFactorization, SVDFactorization, QRFactorization, GenericFactorization, GenericLUFactorization, SimpleLUFactorization, RFLUFactorization, NormalCholeskyFactorization, NormalBunchKaufmanFactorization, From 6bbe2725025a482c33af734b4beee3272a4a1a9b Mon Sep 17 00:00:00 2001 From: jClugstor Date: Sun, 20 Jul 2025 16:21:24 -0400 Subject: [PATCH 19/36] add usings --- ext/LinearSolveHYPREExt.jl | 2 +- ext/LinearSolveIterativeSolversExt.jl | 3 ++- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/ext/LinearSolveHYPREExt.jl b/ext/LinearSolveHYPREExt.jl index 1c6774f99..ac6ba0b04 100644 --- a/ext/LinearSolveHYPREExt.jl +++ b/ext/LinearSolveHYPREExt.jl @@ -5,7 +5,7 @@ using HYPRE.LibHYPRE: HYPRE_Complex using HYPRE: HYPRE, HYPREMatrix, HYPRESolver, HYPREVector using LinearSolve: HYPREAlgorithm, LinearCache, LinearProblem, LinearSolve, OperatorAssumptions, default_tol, init_cacheval, __issquare, - __conditioning, LinearSolveAdjoint + __conditioning, LinearSolveAdjoint, LinearVerbosity using SciMLBase: LinearProblem, LinearAliasSpecifier, SciMLBase using UnPack: @unpack using Setfield: @set! diff --git a/ext/LinearSolveIterativeSolversExt.jl b/ext/LinearSolveIterativeSolversExt.jl index 2d04f3e40..d834c9788 100644 --- a/ext/LinearSolveIterativeSolversExt.jl +++ b/ext/LinearSolveIterativeSolversExt.jl @@ -3,6 +3,7 @@ module LinearSolveIterativeSolversExt using LinearSolve, LinearAlgebra using LinearSolve: LinearCache, DEFAULT_PRECS import LinearSolve: IterativeSolversJL +using SciMLVerbosity: @SciMLMessage, Verbosity using IterativeSolvers @@ -110,7 +111,7 @@ function SciMLBase.solve!(cache::LinearCache, alg::IterativeSolversJL; kwargs... i = 0 for iter in enumerate(cache.cacheval) i += 1 - @SciMLMessage("Iter: $(iter[1]), residual: $(iter[2])", cache.verbose, :IterativeSolvers_iterations) + @SciMLMessage("Iter: $(iter[1]), residual: $(iter[2])", cache.verbose, :IterativeSolvers_iterations, :numerical) # TODO inject callbacks KSP into solve! cb!(cache.cacheval) end From 05653ff8ff093f6e2be1ab72caa35b69003549d1 Mon Sep 17 00:00:00 2001 From: jClugstor Date: Sun, 20 Jul 2025 16:34:47 -0400 Subject: [PATCH 20/36] add compat, fix types --- Project.toml | 1 + src/simplegmres.jl | 4 ++-- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/Project.toml b/Project.toml index db6bb9402..4768ecb4c 100644 --- a/Project.toml +++ b/Project.toml @@ -110,6 +110,7 @@ Reexport = "1" SafeTestsets = "0.1" SciMLBase = "2.70" SciMLOperators = "0.3.7, 0.4, 1" +SciMLVerbosity = "1.0" Setfield = "1" SparseArrays = "1.10" Sparspak = "0.3.6" diff --git a/src/simplegmres.jl b/src/simplegmres.jl index a21826c9f..644a62b61 100644 --- a/src/simplegmres.jl +++ b/src/simplegmres.jl @@ -161,7 +161,7 @@ function init_cacheval(alg::SimpleGMRES{UDB}, args...; kwargs...) where {UDB} end function _init_cacheval(::Val{false}, alg::SimpleGMRES, A, b, u, Pl, Pr, maxiters::Int, - abstol, reltol, ::Bool, ::OperatorAssumptions; zeroinit = true, kwargs...) + abstol, reltol, ::LinearVerbosity, ::OperatorAssumptions; zeroinit = true, kwargs...) @unpack memory, restart, blocksize, warm_start = alg if zeroinit @@ -392,7 +392,7 @@ function SciMLBase.solve!(cache::SimpleGMRESCache{false}, lincache::LinearCache) end function _init_cacheval(::Val{true}, alg::SimpleGMRES, A, b, u, Pl, Pr, maxiters::Int, - abstol, reltol, ::Bool, ::OperatorAssumptions; zeroinit = true, + abstol, reltol, ::LinearVerbosity, ::OperatorAssumptions; zeroinit = true, blocksize = alg.blocksize) @unpack memory, restart, warm_start = alg From c768919b38f4f4339f083d756b00079ae0957569 Mon Sep 17 00:00:00 2001 From: jClugstor Date: Sun, 20 Jul 2025 23:14:51 -0400 Subject: [PATCH 21/36] make sure verbosity works for HYPRE --- ext/LinearSolveHYPREExt.jl | 17 +++++++++++++++-- src/verbosity.jl | 11 +++++++---- test/hypretests.jl | 3 ++- 3 files changed, 24 insertions(+), 7 deletions(-) diff --git a/ext/LinearSolveHYPREExt.jl b/ext/LinearSolveHYPREExt.jl index ac6ba0b04..4ac0bfa5b 100644 --- a/ext/LinearSolveHYPREExt.jl +++ b/ext/LinearSolveHYPREExt.jl @@ -7,6 +7,7 @@ using LinearSolve: HYPREAlgorithm, LinearCache, LinearProblem, LinearSolve, OperatorAssumptions, default_tol, init_cacheval, __issquare, __conditioning, LinearSolveAdjoint, LinearVerbosity using SciMLBase: LinearProblem, LinearAliasSpecifier, SciMLBase +using SciMLVerbosity: @match, Verbosity using UnPack: @unpack using Setfield: @set! @@ -64,7 +65,7 @@ function SciMLBase.init(prob::LinearProblem, alg::HYPREAlgorithm, eltype(prob.A)), # TODO: Implement length() for HYPREVector in HYPRE.jl? maxiters::Int = prob.b isa HYPREVector ? 1000 : length(prob.b), - verbose::LinearVerbosity = false, + verbose = LinearVerbosity(), Pl = LinearAlgebra.I, Pr = LinearAlgebra.I, assumptions = OperatorAssumptions(), @@ -159,10 +160,22 @@ function create_solver(alg::HYPREAlgorithm, cache::LinearCache) solver = create_solver(alg.solver, comm) # Construct solver options + + + # This should be a function in SciMLVerbosity + verbose = @match cache.verbose.numerical.HYPRE_verbosity begin + Verbosity.None() => 0 + Verbosity.Info() => 1 + Verbosity.Warn() => 2 + Verbosity.Error() => 3 + Verbosity.Level(i) => i + end + + solver_options = (; AbsoluteTol = cache.abstol, MaxIter = cache.maxiters, - PrintLevel = Int(cache.verbose), + PrintLevel = verbose, Tol = cache.reltol) # Preconditioner (uses Pl even though it might not be a *left* preconditioner just *a* diff --git a/src/verbosity.jl b/src/verbosity.jl index e6ee72142..88eb51e3e 100644 --- a/src/verbosity.jl +++ b/src/verbosity.jl @@ -1,13 +1,14 @@ # Linear Verbosity -linear_defaults = Dict( +const linear_defaults = Dict{Symbol, Verbosity.Type}( :default_lu_fallback => Verbosity.Warn(), :no_right_preconditioning => Verbosity.Warn(), :using_iterative_solvers => Verbosity.Warn(), :using_IterativeSolvers => Verbosity.Warn(), :IterativeSolvers_iterations => Verbosity.Warn(), :KrylovKit_verbosity => Verbosity.Warn(), - :KrylovJL_verbosity => Verbosity.None() + :KrylovJL_verbosity => Verbosity.None(), + :HYPRE_verbosity => Verbosity.Level(1) ) mutable struct LinearErrorControlVerbosity default_lu_fallback::Verbosity.Type @@ -76,14 +77,16 @@ mutable struct LinearNumericalVerbosity IterativeSolvers_iterations::Verbosity.Type KrylovKit_verbosity::Verbosity.Type KrylovJL_verbosity::Verbosity.Type + HYPRE_verbosity::Verbosity.Type function LinearNumericalVerbosity(; using_IterativeSolvers = linear_defaults[:using_IterativeSolvers], IterativeSolvers_iterations = linear_defaults[:IterativeSolvers_iterations], KrylovKit_verbosity = linear_defaults[:KrylovKit_verbosity], - KrylovJL_verbosity = linear_defaults[:KrylovJL_verbosity]) + KrylovJL_verbosity = linear_defaults[:KrylovJL_verbosity], + HYPRE_verbosity = linear_defaults[:HYPRE_verbosity]) new(using_IterativeSolvers, IterativeSolvers_iterations, - KrylovKit_verbosity, KrylovJL_verbosity) + KrylovKit_verbosity, KrylovJL_verbosity, HYPRE_verbosity) end function LinearNumericalVerbosity(verbose::Verbosity.Type) diff --git a/test/hypretests.jl b/test/hypretests.jl index 0d04ebd94..b5d02bc16 100644 --- a/test/hypretests.jl +++ b/test/hypretests.jl @@ -4,6 +4,7 @@ using HYPRE.LibHYPRE: HYPRE_BigInt, HYPRE_IJVectorGetValues, HYPRE_Int using LinearAlgebra using LinearSolve +using LinearSolve: LinearVerbosity using MPI using Random: MersenneTwister using SparseArrays @@ -78,7 +79,7 @@ function test_interface(alg; kw...) atol = 1e-6 rtol = 1e-6 - cache_kwargs = (; verbose = true, abstol = atol, reltol = rtol, maxiters = 50) + cache_kwargs = (; verbose = LinearVerbosity(), abstol = atol, reltol = rtol, maxiters = 50) cache_kwargs = merge(cache_kwargs, kw) # prob1, prob3 with initial guess, prob2, prob4 without From d77f307a5877359a497bacc2e13fdd9e1dd7ec90 Mon Sep 17 00:00:00 2001 From: jClugstor Date: Sun, 20 Jul 2025 23:27:36 -0400 Subject: [PATCH 22/36] add simple tests for verbosity --- test/runtests.jl | 1 + test/verbosity.jl | 18 ++++++++++++++++++ 2 files changed, 19 insertions(+) create mode 100644 test/verbosity.jl diff --git a/test/runtests.jl b/test/runtests.jl index 53140926b..301ef57b4 100644 --- a/test/runtests.jl +++ b/test/runtests.jl @@ -18,6 +18,7 @@ if GROUP == "All" || GROUP == "Core" @time @safetestset "ForwardDiff Overloads" include("forwarddiff_overloads.jl") @time @safetestset "Traits" include("traits.jl") @time @safetestset "BandedMatrices" include("banded.jl") + @time @safetestset "Verbosity" include("verbosity.jl") end # Don't run Enzyme tests on prerelease diff --git a/test/verbosity.jl b/test/verbosity.jl new file mode 100644 index 000000000..eb6787da6 --- /dev/null +++ b/test/verbosity.jl @@ -0,0 +1,18 @@ +using LinearSolve +using LinearSolve: LinearVerbosity +using SciMLVerbosity: Verbosity +using Logging +using Test + +A = [1.0 0 0 0 + 0 1 0 0 + 0 0 1 0 + 0 0 0 0] +b = rand(4) +prob = LinearProblem(A, b) + +@test_logs (:warn, "Falling back to LU factorization") solve(prob, verbose = LinearVerbosity(default_lu_fallback = Verbosity.Warn())) + +@test_logs (:info, "Falling back to LU factorization") solve(prob, verbose = LinearVerbosity(default_lu_fallback = Verbosity.Info())) + +@test_logs min_level = Logging.Info solve(prob, verbose = LinearVerbosity(Verbosity.None())) \ No newline at end of file From b5bfe5544229042fae3433220b49332f4892228f Mon Sep 17 00:00:00 2001 From: jClugstor Date: Mon, 21 Jul 2025 00:29:15 -0400 Subject: [PATCH 23/36] fix verbosity tests --- test/verbosity.jl | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-) diff --git a/test/verbosity.jl b/test/verbosity.jl index eb6787da6..ceb0e982d 100644 --- a/test/verbosity.jl +++ b/test/verbosity.jl @@ -1,7 +1,6 @@ using LinearSolve using LinearSolve: LinearVerbosity -using SciMLVerbosity: Verbosity -using Logging +using SciMLVerbosity: SciMLVerbosity, Verbosity using Test A = [1.0 0 0 0 @@ -11,8 +10,13 @@ A = [1.0 0 0 0 b = rand(4) prob = LinearProblem(A, b) -@test_logs (:warn, "Falling back to LU factorization") solve(prob, verbose = LinearVerbosity(default_lu_fallback = Verbosity.Warn())) +@test_logs (:warn, "LU factorization failed, falling back to QR factorization. `A` is potentially rank-deficient.") solve(prob, +verbose=LinearVerbosity(default_lu_fallback=Verbosity.Warn())) -@test_logs (:info, "Falling back to LU factorization") solve(prob, verbose = LinearVerbosity(default_lu_fallback = Verbosity.Info())) +@test_logs (:warn, "LU factorization failed, falling back to QR factorization. `A` is potentially rank-deficient.") solve( + prob, verbose = true) -@test_logs min_level = Logging.Info solve(prob, verbose = LinearVerbosity(Verbosity.None())) \ No newline at end of file +@test_logs min_level = SciMLVerbosity.Logging.Warn solve(prob, verbose = false) + +@test_logs (:info, "LU factorization failed, falling back to QR factorization. `A` is potentially rank-deficient.") solve(prob, +verbose=LinearVerbosity(default_lu_fallback=Verbosity.Info())) From 9c1feecb7ffa15cffc29136bbdab9bc0fafdc545 Mon Sep 17 00:00:00 2001 From: jClugstor Date: Mon, 21 Jul 2025 09:43:55 -0400 Subject: [PATCH 24/36] correct import --- ext/LinearSolveSparseArraysExt.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ext/LinearSolveSparseArraysExt.jl b/ext/LinearSolveSparseArraysExt.jl index ba1f3655a..1b58d198c 100644 --- a/ext/LinearSolveSparseArraysExt.jl +++ b/ext/LinearSolveSparseArraysExt.jl @@ -5,7 +5,7 @@ using LinearSolve: LinearSolve, BLASELTYPES, pattern_changed, ArrayInterface, GenericLUFactorization, KLUFactorization, LUFactorization, NormalCholeskyFactorization, OperatorAssumptions, - QRFactorization, RFLUFactorization, UMFPACKFactorization, solve + QRFactorization, RFLUFactorization, UMFPACKFactorization, solve, LinearVerbosity using ArrayInterface: ArrayInterface using LinearAlgebra: LinearAlgebra, I, Hermitian, Symmetric, cholesky, ldiv!, lu, lu!, QR using SparseArrays: SparseArrays, AbstractSparseArray, AbstractSparseMatrixCSC, From 54508e9d8bb601eafbc0f69de7fddd155cdf84b0 Mon Sep 17 00:00:00 2001 From: jClugstor Date: Fri, 25 Jul 2025 10:54:06 -0400 Subject: [PATCH 25/36] these don't really need to be mutable --- src/verbosity.jl | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/verbosity.jl b/src/verbosity.jl index 88eb51e3e..5f29d0e27 100644 --- a/src/verbosity.jl +++ b/src/verbosity.jl @@ -10,7 +10,7 @@ const linear_defaults = Dict{Symbol, Verbosity.Type}( :KrylovJL_verbosity => Verbosity.None(), :HYPRE_verbosity => Verbosity.Level(1) ) -mutable struct LinearErrorControlVerbosity +struct LinearErrorControlVerbosity default_lu_fallback::Verbosity.Type function LinearErrorControlVerbosity(; @@ -41,7 +41,7 @@ mutable struct LinearErrorControlVerbosity end end -mutable struct LinearPerformanceVerbosity +struct LinearPerformanceVerbosity no_right_preconditioning::Verbosity.Type function LinearPerformanceVerbosity(; @@ -72,7 +72,7 @@ mutable struct LinearPerformanceVerbosity end end -mutable struct LinearNumericalVerbosity +struct LinearNumericalVerbosity using_IterativeSolvers::Verbosity.Type IterativeSolvers_iterations::Verbosity.Type KrylovKit_verbosity::Verbosity.Type From b2a54a4d70f2cf9f78ec8f813b33d5a1f411171f Mon Sep 17 00:00:00 2001 From: jClugstor Date: Fri, 25 Jul 2025 10:55:03 -0400 Subject: [PATCH 26/36] if verbose isa verbosity type, construct a LinearVerbosity from it --- src/common.jl | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/common.jl b/src/common.jl index f9e7d6f26..0520b4259 100644 --- a/src/common.jl +++ b/src/common.jl @@ -208,6 +208,8 @@ function SciMLBase.init(prob::LinearProblem, alg::SciMLLinearSolveAlgorithm, else verbose = LinearVerbosity(Verbosity.None()) end + elseif verbose isa Verbosity.Type + verbose = LinearVerbosity(verbose) end b = if issparsematrix(b) && !(A isa Diagonal) From da74146966e96ff9a342dad982a2eac61ccfe696 Mon Sep 17 00:00:00 2001 From: jClugstor Date: Fri, 25 Jul 2025 14:07:45 -0400 Subject: [PATCH 27/36] fix doc string --- docs/src/basics/common_solver_opts.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/src/basics/common_solver_opts.md b/docs/src/basics/common_solver_opts.md index bb45a537a..100b566f4 100644 --- a/docs/src/basics/common_solver_opts.md +++ b/docs/src/basics/common_solver_opts.md @@ -50,7 +50,7 @@ These settings are meant for individual settings within a category. These can al - Verbosity.Level(n) - Show messages with a log level setting of n #### Group Settings -These settings are meant for +These settings are meant for controlling a group of settings. - Verbosity.Default() - Use the default settings - Verbosity.All() - Show all possible messages From f6c58f6cacc7fbc2443174f701f5c52453dcaa80 Mon Sep 17 00:00:00 2001 From: jClugstor Date: Fri, 25 Jul 2025 14:35:21 -0400 Subject: [PATCH 28/36] they actually do need to be mutable --- src/verbosity.jl | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/verbosity.jl b/src/verbosity.jl index 5f29d0e27..88eb51e3e 100644 --- a/src/verbosity.jl +++ b/src/verbosity.jl @@ -10,7 +10,7 @@ const linear_defaults = Dict{Symbol, Verbosity.Type}( :KrylovJL_verbosity => Verbosity.None(), :HYPRE_verbosity => Verbosity.Level(1) ) -struct LinearErrorControlVerbosity +mutable struct LinearErrorControlVerbosity default_lu_fallback::Verbosity.Type function LinearErrorControlVerbosity(; @@ -41,7 +41,7 @@ struct LinearErrorControlVerbosity end end -struct LinearPerformanceVerbosity +mutable struct LinearPerformanceVerbosity no_right_preconditioning::Verbosity.Type function LinearPerformanceVerbosity(; @@ -72,7 +72,7 @@ struct LinearPerformanceVerbosity end end -struct LinearNumericalVerbosity +mutable struct LinearNumericalVerbosity using_IterativeSolvers::Verbosity.Type IterativeSolvers_iterations::Verbosity.Type KrylovKit_verbosity::Verbosity.Type From a41e96e76d4d22a7ed4335c32a51732f98325e40 Mon Sep 17 00:00:00 2001 From: jClugstor Date: Fri, 25 Jul 2025 15:45:25 -0400 Subject: [PATCH 29/36] update compat --- Project.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Project.toml b/Project.toml index 4768ecb4c..f287116b0 100644 --- a/Project.toml +++ b/Project.toml @@ -110,7 +110,7 @@ Reexport = "1" SafeTestsets = "0.1" SciMLBase = "2.70" SciMLOperators = "0.3.7, 0.4, 1" -SciMLVerbosity = "1.0" +SciMLVerbosity = "1.2.0" Setfield = "1" SparseArrays = "1.10" Sparspak = "0.3.6" From 35cf60d6a1e451a516fc6ec1e47e0b5566f7e6d1 Mon Sep 17 00:00:00 2001 From: jClugstor Date: Fri, 25 Jul 2025 15:45:50 -0400 Subject: [PATCH 30/36] make use of new SciMLVerbosity stuff --- ext/LinearSolveHYPREExt.jl | 12 ++---------- ext/LinearSolveKrylovKitExt.jl | 15 ++------------- ext/LinearSolvePardisoExt.jl | 5 ++++- src/LinearSolve.jl | 2 +- src/iterative_wrappers.jl | 6 +----- src/verbosity.jl | 7 +++++-- 6 files changed, 15 insertions(+), 32 deletions(-) diff --git a/ext/LinearSolveHYPREExt.jl b/ext/LinearSolveHYPREExt.jl index 4ac0bfa5b..314deb59d 100644 --- a/ext/LinearSolveHYPREExt.jl +++ b/ext/LinearSolveHYPREExt.jl @@ -7,7 +7,7 @@ using LinearSolve: HYPREAlgorithm, LinearCache, LinearProblem, LinearSolve, OperatorAssumptions, default_tol, init_cacheval, __issquare, __conditioning, LinearSolveAdjoint, LinearVerbosity using SciMLBase: LinearProblem, LinearAliasSpecifier, SciMLBase -using SciMLVerbosity: @match, Verbosity +using SciMLVerbosity: @match, Verbosity, verbosity_to_int using UnPack: @unpack using Setfield: @set! @@ -162,15 +162,7 @@ function create_solver(alg::HYPREAlgorithm, cache::LinearCache) # Construct solver options - # This should be a function in SciMLVerbosity - verbose = @match cache.verbose.numerical.HYPRE_verbosity begin - Verbosity.None() => 0 - Verbosity.Info() => 1 - Verbosity.Warn() => 2 - Verbosity.Error() => 3 - Verbosity.Level(i) => i - end - + verbose = verbosity_to_int(cache.verbose.numerical.HYPRE_verbosity) solver_options = (; AbsoluteTol = cache.abstol, diff --git a/ext/LinearSolveKrylovKitExt.jl b/ext/LinearSolveKrylovKitExt.jl index 4a50bcdeb..55b0af4b0 100644 --- a/ext/LinearSolveKrylovKitExt.jl +++ b/ext/LinearSolveKrylovKitExt.jl @@ -1,7 +1,7 @@ module LinearSolveKrylovKitExt using LinearSolve, KrylovKit, LinearAlgebra -using SciMLVerbosity: @match, Verbosity +using SciMLVerbosity: @match, Verbosity, verbosity_to_int using LinearSolve: LinearCache, DEFAULT_PRECS function LinearSolve.KrylovKitJL(args...; @@ -26,7 +26,7 @@ function SciMLBase.solve!(cache::LinearCache, alg::KrylovKitJL; kwargs...) atol = float(cache.abstol) rtol = float(cache.reltol) maxiter = cache.maxiters - verbosity = verbosity_to_KrylovKit(cache.verbose.numerical.KrylovKit_verbosity) + verbosity = verbosity_to_int(cache.verbose.numerical.KrylovKit_verbosity) krylovdim = (alg.gmres_restart == 0) ? min(20, size(cache.A, 1)) : alg.gmres_restart kwargs = (atol = atol, rtol = rtol, maxiter = maxiter, verbosity = verbosity, @@ -42,15 +42,4 @@ function SciMLBase.solve!(cache::LinearCache, alg::KrylovKitJL; kwargs...) iters = iters) end -function verbosity_to_KrylovKit(verb::Verbosity.Type) - @match verb begin - Verbosity.None() => 0 - Verbosity.Warn() => 1 - Verbosity.Error() => 2 - Verbosity.Info() => 3 - Verbosity.Level(x) => x - _ => error("Not a valid verbosity level for KrylovKit.") - end -end - end diff --git a/ext/LinearSolvePardisoExt.jl b/ext/LinearSolvePardisoExt.jl index 670e1388e..6de338e4a 100644 --- a/ext/LinearSolvePardisoExt.jl +++ b/ext/LinearSolvePardisoExt.jl @@ -73,7 +73,10 @@ function LinearSolve.init_cacheval(alg::PardisoJL, error("Number type not supported by Pardiso") end end - verbose && Pardiso.set_msglvl!(solver, Pardiso.MESSAGE_LEVEL_ON) + + @SciMLMessage(verbose, :pardiso_verbosity, :numerical) do + Pardiso.set_msglvl!(solver, Pardiso.MESSAGE_LEVEL_ON) + end #= Note: It is recommended to use IPARM(11)=1 (scaling) and IPARM(13)=1 (matchings) for diff --git a/src/LinearSolve.jl b/src/LinearSolve.jl index bb515851d..8da3efd72 100644 --- a/src/LinearSolve.jl +++ b/src/LinearSolve.jl @@ -21,7 +21,7 @@ using SciMLBase: SciMLBase, LinearAliasSpecifier, AbstractSciMLOperator, using SciMLOperators: SciMLOperators, AbstractSciMLOperator, IdentityOperator, MatrixOperator, has_ldiv!, issquare -using SciMLVerbosity: Verbosity, @SciMLMessage, @match, AbstractVerbositySpecifier +using SciMLVerbosity: Verbosity, @SciMLMessage, @match, AbstractVerbositySpecifier, verbosity_to_int, verbosity_to_bool using Setfield: @set, @set! using UnPack: @unpack using DocStringExtensions: DocStringExtensions diff --git a/src/iterative_wrappers.jl b/src/iterative_wrappers.jl index 3be8c37a6..de32f3b7b 100644 --- a/src/iterative_wrappers.jl +++ b/src/iterative_wrappers.jl @@ -284,11 +284,7 @@ function SciMLBase.solve!(cache::LinearCache, alg::KrylovJL; kwargs...) cache.cacheval end - krylovJL_verbose = SciMLBase.@match verbose.numerical.KrylovJL_verbosity begin - Verbosity.None() => 0 - ::Verbosity.Type => 1 - _ => error("Invalid verbosity.") - end + krylovJL_verbose = verbosity_to_int(verbose.numerical.KrylovJL_verbosity) args = (cacheval, cache.A, cache.b) kwargs = (atol = atol, rtol, itmax, verbose = krylovJL_verbose, diff --git a/src/verbosity.jl b/src/verbosity.jl index 88eb51e3e..8ee324b3a 100644 --- a/src/verbosity.jl +++ b/src/verbosity.jl @@ -8,7 +8,8 @@ const linear_defaults = Dict{Symbol, Verbosity.Type}( :IterativeSolvers_iterations => Verbosity.Warn(), :KrylovKit_verbosity => Verbosity.Warn(), :KrylovJL_verbosity => Verbosity.None(), - :HYPRE_verbosity => Verbosity.Level(1) + :HYPRE_verbosity => Verbosity.Level(1), + :pardiso_verbosity => Verbosity.None() ) mutable struct LinearErrorControlVerbosity default_lu_fallback::Verbosity.Type @@ -78,13 +79,15 @@ mutable struct LinearNumericalVerbosity KrylovKit_verbosity::Verbosity.Type KrylovJL_verbosity::Verbosity.Type HYPRE_verbosity::Verbosity.Type + pardiso_verbosity::Verbosity.Type function LinearNumericalVerbosity(; using_IterativeSolvers = linear_defaults[:using_IterativeSolvers], IterativeSolvers_iterations = linear_defaults[:IterativeSolvers_iterations], KrylovKit_verbosity = linear_defaults[:KrylovKit_verbosity], KrylovJL_verbosity = linear_defaults[:KrylovJL_verbosity], - HYPRE_verbosity = linear_defaults[:HYPRE_verbosity]) + HYPRE_verbosity = linear_defaults[:HYPRE_verbosity], + pardiso_verbosity = linear_defaults[:pardiso_verbosity]) new(using_IterativeSolvers, IterativeSolvers_iterations, KrylovKit_verbosity, KrylovJL_verbosity, HYPRE_verbosity) end From 9d4e434e15a6d48254d2c30a3ab805833392dcc6 Mon Sep 17 00:00:00 2001 From: jClugstor Date: Sat, 26 Jul 2025 21:13:25 -0400 Subject: [PATCH 31/36] import SciMLMessage --- ext/LinearSolvePardisoExt.jl | 1 + 1 file changed, 1 insertion(+) diff --git a/ext/LinearSolvePardisoExt.jl b/ext/LinearSolvePardisoExt.jl index 6de338e4a..c8a2b1854 100644 --- a/ext/LinearSolvePardisoExt.jl +++ b/ext/LinearSolvePardisoExt.jl @@ -1,6 +1,7 @@ module LinearSolvePardisoExt using Pardiso, LinearSolve +using SciMLVerbosity: @SciMLMessage using SparseArrays using SparseArrays: nonzeros, rowvals, getcolptr using LinearSolve: PardisoJL, @unpack From ff706637af8b129a2e6dc397d5f869e0c7cb3db4 Mon Sep 17 00:00:00 2001 From: jClugstor Date: Sat, 26 Jul 2025 21:13:46 -0400 Subject: [PATCH 32/36] get rid of unused import --- src/LinearSolve.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/LinearSolve.jl b/src/LinearSolve.jl index 8da3efd72..b0a1378ab 100644 --- a/src/LinearSolve.jl +++ b/src/LinearSolve.jl @@ -21,7 +21,7 @@ using SciMLBase: SciMLBase, LinearAliasSpecifier, AbstractSciMLOperator, using SciMLOperators: SciMLOperators, AbstractSciMLOperator, IdentityOperator, MatrixOperator, has_ldiv!, issquare -using SciMLVerbosity: Verbosity, @SciMLMessage, @match, AbstractVerbositySpecifier, verbosity_to_int, verbosity_to_bool +using SciMLVerbosity: Verbosity, @SciMLMessage, @match, AbstractVerbositySpecifier, verbosity_to_int using Setfield: @set, @set! using UnPack: @unpack using DocStringExtensions: DocStringExtensions From 6b96b98c42c51e283a4cb27dad76d76c96695b82 Mon Sep 17 00:00:00 2001 From: jClugstor Date: Sat, 26 Jul 2025 22:22:06 -0400 Subject: [PATCH 33/36] fix pardiso verbosity --- src/verbosity.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/verbosity.jl b/src/verbosity.jl index 8ee324b3a..e4b73988f 100644 --- a/src/verbosity.jl +++ b/src/verbosity.jl @@ -89,7 +89,7 @@ mutable struct LinearNumericalVerbosity HYPRE_verbosity = linear_defaults[:HYPRE_verbosity], pardiso_verbosity = linear_defaults[:pardiso_verbosity]) new(using_IterativeSolvers, IterativeSolvers_iterations, - KrylovKit_verbosity, KrylovJL_verbosity, HYPRE_verbosity) + KrylovKit_verbosity, KrylovJL_verbosity, HYPRE_verbosity, pardiso_verbosity) end function LinearNumericalVerbosity(verbose::Verbosity.Type) From f064f8e43c8fcfb9f9794f02adcbc96a8f62bbf5 Mon Sep 17 00:00:00 2001 From: jClugstor Date: Sat, 26 Jul 2025 23:07:19 -0400 Subject: [PATCH 34/36] actually fix pardiso verbosity --- ext/LinearSolvePardisoExt.jl | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ext/LinearSolvePardisoExt.jl b/ext/LinearSolvePardisoExt.jl index c8a2b1854..d63dcbbc7 100644 --- a/ext/LinearSolvePardisoExt.jl +++ b/ext/LinearSolvePardisoExt.jl @@ -1,7 +1,7 @@ module LinearSolvePardisoExt using Pardiso, LinearSolve -using SciMLVerbosity: @SciMLMessage +using SciMLVerbosity: @SciMLMessage, verbosity_to_bool using SparseArrays using SparseArrays: nonzeros, rowvals, getcolptr using LinearSolve: PardisoJL, @unpack @@ -75,7 +75,7 @@ function LinearSolve.init_cacheval(alg::PardisoJL, end end - @SciMLMessage(verbose, :pardiso_verbosity, :numerical) do + if verbosity_to_bool(verbose.numerical.pardiso_verbosity) Pardiso.set_msglvl!(solver, Pardiso.MESSAGE_LEVEL_ON) end From 70a31448a31bcd8cb44ae338b19111d06d2cc3ce Mon Sep 17 00:00:00 2001 From: jClugstor Date: Sun, 27 Jul 2025 21:09:28 -0400 Subject: [PATCH 35/36] format things related to verbosity --- docs/src/basics/common_solver_opts.md | 69 ++++++++++++++++----------- ext/LinearSolveCUDAExt.jl | 9 ++-- ext/LinearSolveHYPREExt.jl | 1 - ext/LinearSolveIterativeSolversExt.jl | 8 ++-- ext/LinearSolveSparseArraysExt.jl | 7 +-- src/LinearSolve.jl | 6 ++- src/default.jl | 4 +- src/factorization.jl | 3 +- src/iterative_wrappers.jl | 2 - src/verbosity.jl | 2 +- test/hypretests.jl | 3 +- test/verbosity.jl | 15 ++++-- 12 files changed, 77 insertions(+), 52 deletions(-) diff --git a/docs/src/basics/common_solver_opts.md b/docs/src/basics/common_solver_opts.md index 100b566f4..835e42290 100644 --- a/docs/src/basics/common_solver_opts.md +++ b/docs/src/basics/common_solver_opts.md @@ -32,52 +32,57 @@ The verbosity system in LinearSolve.jl provides fine-grained control over the di The verbosity system is organized hierarchically into three main categories: -1. Error Control - Messages related to fallbacks and error handling -2. Performance - Messages related to performance considerations -3. Numerical - Messages related to numerical solvers and iterations + 1. Error Control - Messages related to fallbacks and error handling + 2. Performance - Messages related to performance considerations + 3. Numerical - Messages related to numerical solvers and iterations Each category can be configured independently, and individual settings can be adjusted to suit your needs. ### Verbosity Levels + The following verbosity levels are available: #### Individual Settings + These settings are meant for individual settings within a category. These can also be used to set all of the individual settings in a group to the same value. -- Verbosity.None() - Suppress all messages -- Verbosity.Info() - Show message as log message at info level -- Verbosity.Warn() - Show warnings (default for most settings) -- Verbosity.Error() - Throw errors instead of warnings -- Verbosity.Level(n) - Show messages with a log level setting of n + + - Verbosity.None() - Suppress all messages + - Verbosity.Info() - Show message as log message at info level + - Verbosity.Warn() - Show warnings (default for most settings) + - Verbosity.Error() - Throw errors instead of warnings + - Verbosity.Level(n) - Show messages with a log level setting of n #### Group Settings -These settings are meant for controlling a group of settings. -- Verbosity.Default() - Use the default settings -- Verbosity.All() - Show all possible messages -### Basic Usage +These settings are meant for controlling a group of settings. + + - Verbosity.Default() - Use the default settings + - Verbosity.All() - Show all possible messages + +### Basic Usage #### Global Verbosity Control -```julia +```julia using LinearSolve # Suppress all messages verbose = LinearVerbosity(Verbosity.None()) prob = LinearProblem(A, b) -sol = solve(prob; verbose=verbose) +sol = solve(prob; verbose = verbose) # Show all messages verbose = LinearVerbosity(Verbosity.All()) -sol = solve(prob; verbose=verbose) +sol = solve(prob; verbose = verbose) # Use default settings verbose = LinearVerbosity(Verbosity.Default()) -sol = solve(prob; verbose=verbose) +sol = solve(prob; verbose = verbose) ``` -#### Group Level Control +#### Group Level Control -```julia +```julia # Customize by category verbose = LinearVerbosity( error_control = Verbosity.Warn(), # Show warnings for error control related issues @@ -85,12 +90,14 @@ verbose = LinearVerbosity( numerical = Verbosity.Info() # Show all numerical related log messages at info level ) -sol = solve(prob; verbose=verbose) +sol = solve(prob; verbose = verbose) ``` #### Fine-grained Control -The constructor for `LinearVerbosity` allows you to set verbosity for each specific message toggle, giving you fine-grained control. -The verbosity settings for the toggles are automatically passed to the group objects. + +The constructor for `LinearVerbosity` allows you to set verbosity for each specific message toggle, giving you fine-grained control. +The verbosity settings for the toggles are automatically passed to the group objects. + ```julia # Set specific message types verbose = LinearVerbosity( @@ -100,17 +107,23 @@ verbose = LinearVerbosity( KrylovKit_verbosity = Verbosity.Level(KrylovKit.WARN_LEVEL) # Set KrylovKit verbosity level using KrylovKit's own verbosity levels ) -sol = solve(prob; verbose=verbose) +sol = solve(prob; verbose = verbose) ``` #### Verbosity Levels + ##### Error Control Settings -- default_lu_fallback: Controls messages when falling back to LU factorization (default: Warn) + + - default_lu_fallback: Controls messages when falling back to LU factorization (default: Warn) + ##### Performance Settings -- no_right_preconditioning: Controls messages when right preconditioning is not used (default: Warn) + + - no_right_preconditioning: Controls messages when right preconditioning is not used (default: Warn) + ##### Numerical Settings -- using_IterativeSolvers: Controls messages when using the IterativeSolvers.jl package (default: Warn) -- IterativeSolvers_iterations: Controls messages about iteration counts from IterativeSolvers.jl (default: Warn) -- KrylovKit_verbosity: Controls messages from the KrylovKit.jl package (default: Warn) -- KrylovJL_verbosity: Controls verbosity of the KrylovJL.jl package (default: None) \ No newline at end of file + + - using_IterativeSolvers: Controls messages when using the IterativeSolvers.jl package (default: Warn) + - IterativeSolvers_iterations: Controls messages about iteration counts from IterativeSolvers.jl (default: Warn) + - KrylovKit_verbosity: Controls messages from the KrylovKit.jl package (default: Warn) + - KrylovJL_verbosity: Controls verbosity of the KrylovJL.jl package (default: None) diff --git a/ext/LinearSolveCUDAExt.jl b/ext/LinearSolveCUDAExt.jl index 90a65f65a..2978f2c49 100644 --- a/ext/LinearSolveCUDAExt.jl +++ b/ext/LinearSolveCUDAExt.jl @@ -55,19 +55,22 @@ end function LinearSolve.init_cacheval( ::SparspakFactorization, A::CUDA.CUSPARSE.CuSparseMatrixCSR, b, u, - Pl, Pr, maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) + Pl, Pr, maxiters::Int, abstol, reltol, + verbose::LinearVerbosity, assumptions::OperatorAssumptions) nothing end function LinearSolve.init_cacheval( ::KLUFactorization, A::CUDA.CUSPARSE.CuSparseMatrixCSR, b, u, - Pl, Pr, maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) + Pl, Pr, maxiters::Int, abstol, reltol, + verbose::LinearVerbosity, assumptions::OperatorAssumptions) nothing end function LinearSolve.init_cacheval( ::UMFPACKFactorization, A::CUDA.CUSPARSE.CuSparseMatrixCSR, b, u, - Pl, Pr, maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) + Pl, Pr, maxiters::Int, abstol, reltol, + verbose::LinearVerbosity, assumptions::OperatorAssumptions) nothing end diff --git a/ext/LinearSolveHYPREExt.jl b/ext/LinearSolveHYPREExt.jl index 314deb59d..10525d149 100644 --- a/ext/LinearSolveHYPREExt.jl +++ b/ext/LinearSolveHYPREExt.jl @@ -161,7 +161,6 @@ function create_solver(alg::HYPREAlgorithm, cache::LinearCache) # Construct solver options - verbose = verbosity_to_int(cache.verbose.numerical.HYPRE_verbosity) solver_options = (; diff --git a/ext/LinearSolveIterativeSolversExt.jl b/ext/LinearSolveIterativeSolversExt.jl index d834c9788..db9d72ced 100644 --- a/ext/LinearSolveIterativeSolversExt.jl +++ b/ext/LinearSolveIterativeSolversExt.jl @@ -66,7 +66,7 @@ function LinearSolve.init_cacheval(alg::IterativeSolversJL, A, b, u, Pl, Pr, max kwargs...) elseif alg.generate_iterator === IterativeSolvers.idrs_iterable! !!LinearSolve._isidentity_struct(Pr) && - @SciMLMessage("$(alg.generate_iterator) doesn't support right preconditioning", + @SciMLMessage("$(alg.generate_iterator) doesn't support right preconditioning", verbose, :no_right_preconditioning, :performance) history = IterativeSolvers.ConvergenceHistory(partial = true) history[:abstol] = abstol @@ -107,11 +107,13 @@ function SciMLBase.solve!(cache::LinearCache, alg::IterativeSolversJL; kwargs... end purge_history!(cache.cacheval, cache.u, cache.b) - @SciMLMessage("Using IterativeSolvers.$(alg.generate_iterator)", cache.verbose, :using_IterativeSolvers, :numerical) + @SciMLMessage("Using IterativeSolvers.$(alg.generate_iterator)", + cache.verbose, :using_IterativeSolvers, :numerical) i = 0 for iter in enumerate(cache.cacheval) i += 1 - @SciMLMessage("Iter: $(iter[1]), residual: $(iter[2])", cache.verbose, :IterativeSolvers_iterations, :numerical) + @SciMLMessage("Iter: $(iter[1]), residual: $(iter[2])", + cache.verbose, :IterativeSolvers_iterations, :numerical) # TODO inject callbacks KSP into solve! cb!(cache.cacheval) end diff --git a/ext/LinearSolveSparseArraysExt.jl b/ext/LinearSolveSparseArraysExt.jl index 1b58d198c..ecd4c434a 100644 --- a/ext/LinearSolveSparseArraysExt.jl +++ b/ext/LinearSolveSparseArraysExt.jl @@ -5,7 +5,8 @@ using LinearSolve: LinearSolve, BLASELTYPES, pattern_changed, ArrayInterface, GenericLUFactorization, KLUFactorization, LUFactorization, NormalCholeskyFactorization, OperatorAssumptions, - QRFactorization, RFLUFactorization, UMFPACKFactorization, solve, LinearVerbosity + QRFactorization, RFLUFactorization, UMFPACKFactorization, solve, + LinearVerbosity using ArrayInterface: ArrayInterface using LinearAlgebra: LinearAlgebra, I, Hermitian, Symmetric, cholesky, ldiv!, lu, lu!, QR using SparseArrays: SparseArrays, AbstractSparseArray, AbstractSparseMatrixCSC, @@ -289,7 +290,7 @@ function LinearSolve.init_cacheval(alg::CHOLMODFactorization, Pl, Pr, maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) where {T <: - Float64} + Float64} PREALLOCATED_CHOLMOD end @@ -298,7 +299,7 @@ function LinearSolve.init_cacheval(alg::CHOLMODFactorization, Pl, Pr, maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) where {T <: - BLASELTYPES} + BLASELTYPES} cholesky(sparse(reshape([one(T)], 1, 1))) end diff --git a/src/LinearSolve.jl b/src/LinearSolve.jl index b0a1378ab..299b83c54 100644 --- a/src/LinearSolve.jl +++ b/src/LinearSolve.jl @@ -21,7 +21,8 @@ using SciMLBase: SciMLBase, LinearAliasSpecifier, AbstractSciMLOperator, using SciMLOperators: SciMLOperators, AbstractSciMLOperator, IdentityOperator, MatrixOperator, has_ldiv!, issquare -using SciMLVerbosity: Verbosity, @SciMLMessage, @match, AbstractVerbositySpecifier, verbosity_to_int +using SciMLVerbosity: Verbosity, @SciMLMessage, @match, AbstractVerbositySpecifier, + verbosity_to_int using Setfield: @set, @set! using UnPack: @unpack using DocStringExtensions: DocStringExtensions @@ -237,7 +238,8 @@ error_no_cudss_lu(A) = nothing cudss_loaded(A) = false is_cusparse(A) = false -export LinearVerbosity, LinearErrorControlVerbosity, LinearPerformanceVerbosity, LinearNumericalVerbosity +export LinearVerbosity, LinearErrorControlVerbosity, LinearPerformanceVerbosity, + LinearNumericalVerbosity export LUFactorization, SVDFactorization, QRFactorization, GenericFactorization, GenericLUFactorization, SimpleLUFactorization, RFLUFactorization, diff --git a/src/default.jl b/src/default.jl index 866e6d171..d5762da01 100644 --- a/src/default.jl +++ b/src/default.jl @@ -365,8 +365,8 @@ end newex = quote sol = SciMLBase.solve!(cache, $(algchoice_to_alg(alg)), args...; kwargs...) if sol.retcode === ReturnCode.Failure && alg.safetyfallback - @SciMLMessage("LU factorization failed, falling back to QR factorization. `A` is potentially rank-deficient.", - cache.verbose, :default_lu_fallback, :error_control) + @SciMLMessage("LU factorization failed, falling back to QR factorization. `A` is potentially rank-deficient.", + cache.verbose, :default_lu_fallback, :error_control) sol = SciMLBase.solve!( cache, QRFactorization(ColumnNorm()), args...; kwargs...) diff --git a/src/factorization.jl b/src/factorization.jl index 6107e4df2..95025dc28 100644 --- a/src/factorization.jl +++ b/src/factorization.jl @@ -385,7 +385,8 @@ function init_cacheval(alg::CholeskyFactorization, A::SMatrix{S1, S2}, b, u, Pl, end function init_cacheval(alg::CholeskyFactorization, A::GPUArraysCore.AnyGPUArray, b, u, Pl, - Pr, maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) + Pr, maxiters::Int, abstol, reltol, verbose::LinearVerbosity, + assumptions::OperatorAssumptions) cholesky(A; check = false) end diff --git a/src/iterative_wrappers.jl b/src/iterative_wrappers.jl index de32f3b7b..2fe193239 100644 --- a/src/iterative_wrappers.jl +++ b/src/iterative_wrappers.jl @@ -335,5 +335,3 @@ function SciMLBase.solve!(cache::LinearCache, alg::KrylovJL; kwargs...) return SciMLBase.build_linear_solution(alg, cache.u, Ref(resid), cache; iters = stats.niter, retcode, stats) end - - diff --git a/src/verbosity.jl b/src/verbosity.jl index e4b73988f..6bd5d5ac2 100644 --- a/src/verbosity.jl +++ b/src/verbosity.jl @@ -181,4 +181,4 @@ function LinearVerbosity(; LinearVerbosity{true}(error_control_verbosity, performance_verbosity, numerical_verbosity) -end \ No newline at end of file +end diff --git a/test/hypretests.jl b/test/hypretests.jl index b5d02bc16..f6d5d59ef 100644 --- a/test/hypretests.jl +++ b/test/hypretests.jl @@ -79,7 +79,8 @@ function test_interface(alg; kw...) atol = 1e-6 rtol = 1e-6 - cache_kwargs = (; verbose = LinearVerbosity(), abstol = atol, reltol = rtol, maxiters = 50) + cache_kwargs = (; + verbose = LinearVerbosity(), abstol = atol, reltol = rtol, maxiters = 50) cache_kwargs = merge(cache_kwargs, kw) # prob1, prob3 with initial guess, prob2, prob4 without diff --git a/test/verbosity.jl b/test/verbosity.jl index ceb0e982d..ad7007a57 100644 --- a/test/verbosity.jl +++ b/test/verbosity.jl @@ -10,13 +10,18 @@ A = [1.0 0 0 0 b = rand(4) prob = LinearProblem(A, b) -@test_logs (:warn, "LU factorization failed, falling back to QR factorization. `A` is potentially rank-deficient.") solve(prob, -verbose=LinearVerbosity(default_lu_fallback=Verbosity.Warn())) +@test_logs (:warn, + "LU factorization failed, falling back to QR factorization. `A` is potentially rank-deficient.") solve( + prob, + verbose = LinearVerbosity(default_lu_fallback = Verbosity.Warn())) -@test_logs (:warn, "LU factorization failed, falling back to QR factorization. `A` is potentially rank-deficient.") solve( +@test_logs (:warn, + "LU factorization failed, falling back to QR factorization. `A` is potentially rank-deficient.") solve( prob, verbose = true) @test_logs min_level = SciMLVerbosity.Logging.Warn solve(prob, verbose = false) -@test_logs (:info, "LU factorization failed, falling back to QR factorization. `A` is potentially rank-deficient.") solve(prob, -verbose=LinearVerbosity(default_lu_fallback=Verbosity.Info())) +@test_logs (:info, + "LU factorization failed, falling back to QR factorization. `A` is potentially rank-deficient.") solve( + prob, + verbose = LinearVerbosity(default_lu_fallback = Verbosity.Info())) From 62311ae8bec2da099a74f162c7ee8fee07b892bc Mon Sep 17 00:00:00 2001 From: jClugstor Date: Sun, 27 Jul 2025 23:43:00 -0400 Subject: [PATCH 36/36] DualCache init verbose should be LinearVerbosity as well --- ext/LinearSolveForwardDiffExt.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ext/LinearSolveForwardDiffExt.jl b/ext/LinearSolveForwardDiffExt.jl index 79a88f18d..6f60264d8 100644 --- a/ext/LinearSolveForwardDiffExt.jl +++ b/ext/LinearSolveForwardDiffExt.jl @@ -128,7 +128,7 @@ function SciMLBase.init( abstol = LinearSolve.default_tol(real(eltype(prob.b))), reltol = LinearSolve.default_tol(real(eltype(prob.b))), maxiters::Int = length(prob.b), - verbose::Bool = false, + verbose = LinearVerbosity(), Pl = nothing, Pr = nothing, assumptions = OperatorAssumptions(issquare(prob.A)),