format things related to verbosity

Author: jClugstor

docs/src/basics/common_solver_opts.md

@@ -32,65 +32,72 @@ 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
     performance = Verbosity.None(),     # Suppress performance messages
     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)
+
+  - 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)

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
 

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 = (;

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
 

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
 

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,

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...)

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
 

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
-
-

src/verbosity.jl

@@ -181,4 +181,4 @@ function LinearVerbosity(;
 
     LinearVerbosity{true}(error_control_verbosity,
         performance_verbosity, numerical_verbosity)
-end
+end