imports, other preparations

jClugstor · jClugstor · commit f9f48ce3bde3 · 2025-07-30T16:53:23.000-04:00
diff --git a/lib/BracketingNonlinearSolve/src/bisection.jl b/lib/BracketingNonlinearSolve/src/bisection.jl
@@ -47,7 +47,7 @@ function SciMLBase.__solve(
     if sign(fl) == sign(fr)
         @SciMLMessage("The interval is not an enclosing interval, opposite signs at the \
         boundaries are required.",
-        nonlinear_verbose[], :non_enclosing_interval, :error_control)
+        verbose, :non_enclosing_interval, :error_control)
         return SciMLBase.build_solution(
             prob, alg, left, fl; retcode = ReturnCode.InitialFailure, left, right
         )
diff --git a/lib/BracketingNonlinearSolve/src/brent.jl b/lib/BracketingNonlinearSolve/src/brent.jl
@@ -35,7 +35,7 @@ function SciMLBase.__solve(
     if sign(fl) == sign(fr)
         @SciMLMessage("The interval is not an enclosing interval, opposite signs at the \
         boundaries are required.",
-            nonlinear_verbose[], :non_enclosing_interval, :error_control)
+            verbose, :non_enclosing_interval, :error_control)
         return SciMLBase.build_solution(
             prob, alg, left, fl; retcode = ReturnCode.InitialFailure, left, right
         )
diff --git a/lib/BracketingNonlinearSolve/src/falsi.jl b/lib/BracketingNonlinearSolve/src/falsi.jl
@@ -34,7 +34,7 @@ function SciMLBase.__solve(
     if sign(fl) == sign(fr)
         @SciMLMessage("The interval is not an enclosing interval, opposite signs at the \
         boundaries are required.",
-            nonlinear_verbose[], :non_enclosing_interval, :error_control)
+            verbose, :non_enclosing_interval, :error_control)
         return SciMLBase.build_solution(
             prob, alg, left, fl; retcode = ReturnCode.InitialFailure, left, right
         )
diff --git a/lib/BracketingNonlinearSolve/src/itp.jl b/lib/BracketingNonlinearSolve/src/itp.jl
@@ -85,7 +85,7 @@ function SciMLBase.__solve(
     if sign(fl) == sign(fr)
         @SciMLMessage("The interval is not an enclosing interval, opposite signs at the \
         boundaries are required.",
-            nonlinear_verbose[], :non_enclosing_interval, :error_control)
+            verbose, :non_enclosing_interval, :error_control)
         return SciMLBase.build_solution(
             prob, alg, left, fl; retcode = ReturnCode.InitialFailure, left, right
         )
diff --git a/lib/BracketingNonlinearSolve/src/ridder.jl b/lib/BracketingNonlinearSolve/src/ridder.jl
@@ -34,7 +34,7 @@ function SciMLBase.__solve(
     if sign(fl) == sign(fr)
         @SciMLMessage("The interval is not an enclosing interval, opposite signs at the \
         boundaries are required.",
-            nonlinear_verbose[], :non_enclosing_interval, :error_control)
+            verbose, :non_enclosing_interval, :error_control)
         return SciMLBase.build_solution(
             prob, alg, left, fl; retcode = ReturnCode.InitialFailure, left, right
         )
diff --git a/lib/NonlinearSolveBase/ext/NonlinearSolveBaseLinearSolveExt.jl b/lib/NonlinearSolveBase/ext/NonlinearSolveBaseLinearSolveExt.jl
@@ -5,6 +5,7 @@ using ArrayInterface: ArrayInterface
 using CommonSolve: CommonSolve, init, solve!
 using LinearSolve: LinearSolve, QRFactorization, SciMLLinearSolveAlgorithm
 using SciMLBase: ReturnCode, LinearProblem, LinearAliasSpecifier
+using SciMLVerbosity: @SciMLMessage
 
 using LinearAlgebra: ColumnNorm
 
@@ -28,10 +29,8 @@ function (cache::LinearSolveJLCache)(;
         is_gpuarray = ArrayInterface.device(cache.lincache.A) isa ArrayInterface.GPU
         if !(cache.linsolve isa QRFactorization{ColumnNorm}) && !is_gpuarray &&
            !structured_mat
-            if verbose
-                @warn "Potential Rank Deficient Matrix Detected. Attempting to solve using \
-                       Pivoted QR Factorization."
-            end
+            @SciMLMessage("Potential Rank Deficient Matrix Detected. Attempting to solve using \
+                       Pivoted QR Factorization.", cache.verbose, :default_lu_fallback, :error_control)
             @assert (A !== nothing)&&(b !== nothing) "This case is not yet supported. \
                                                       Please open an issue at \
                                                       https://github.com/SciML/NonlinearSolve.jl"
@@ -53,14 +52,12 @@ function (cache::LinearSolveJLCache)(;
                 return LinearSolveResult(; linres.u, success = false)
             return LinearSolveResult(; linres.u)
         elseif !(cache.linsolve isa QRFactorization{ColumnNorm})
-            if verbose
-                if structured_mat || is_gpuarray
-                    mat_desc = structured_mat ? "Structured" : "GPU"
-                    @warn "Potential Rank Deficient Matrix Detected. But Matrix is \
+            if structured_mat || is_gpuarray
+                mat_desc = structured_mat ? "Structured" : "GPU"
+                @SciMLMessage("Potential Rank Deficient Matrix Detected. But Matrix is \
                            $(mat_desc). Currently, we don't attempt to solve Rank Deficient \
                            $(mat_desc) Matrices. Please open an issue at \
-                           https://github.com/SciML/NonlinearSolve.jl"
-                end
+                           https://github.com/SciML/NonlinearSolve.jl", cache.verbose, :lu_fallback, :error_control)
             end
         end
         return LinearSolveResult(; linres.u, success = false)
diff --git a/lib/NonlinearSolveBase/src/abstract_types.jl b/lib/NonlinearSolveBase/src/abstract_types.jl
@@ -280,6 +280,7 @@ the cache:
   - `maxtime`: the maximum time limit for the solver. (Optional)
   - `timer`: the timer for the solver. (Optional)
   - `total_time`: the total time taken by the solver. (Optional)
+  - `verbose`: a verbosity object that contains options determining what log messages are emitted. 
 """
 abstract type AbstractNonlinearSolveCache <: AbstractNonlinearSolveBaseAPI end
 
diff --git a/lib/NonlinearSolveBase/src/descent/newton.jl b/lib/NonlinearSolveBase/src/descent/newton.jl
@@ -39,6 +39,10 @@ function InternalAPI.init(
     if Utils.unwrap_val(pre_inverted)
         lincache = nothing
     else
+        if haskey(kwargs, :verbose) 
+            linsolve_kwargs = merge((verbose = kwargs[:verbose].linear_verbosity,), linsolve_kwargs)
+        end
+
         lincache = construct_linear_solver(
             alg, alg.linsolve, J, Utils.safe_vec(fu), Utils.safe_vec(u);
             stats, abstol, reltol, linsolve_kwargs...
@@ -72,6 +76,11 @@ function InternalAPI.init(
         A, b = J, Utils.safe_vec(fu)
     end
 
+    if haskey(kwargs, :verbose)
+        linsolve_kwargs = merge(
+            (verbose = kwargs[:verbose].linear_verbosity,), linsolve_kwargs)
+    end
+
     lincache = construct_linear_solver(
         alg, alg.linsolve, A, b, Utils.safe_vec(u);
         stats, abstol, reltol, linsolve_kwargs...
diff --git a/lib/NonlinearSolveBase/src/descent/steepest.jl b/lib/NonlinearSolveBase/src/descent/steepest.jl
@@ -37,6 +37,12 @@ function InternalAPI.init(
         @bb δu_ = similar(u)
     end
     if Utils.unwrap_val(pre_inverted)
+
+        if haskey(kwargs, :verbose)
+            linsolve_kwargs = merge(
+                (verbose = kwargs[:verbose].linear_verbosity,), linsolve_kwargs)
+        end
+        
         lincache = construct_linear_solver(
             alg, alg.linsolve, transpose(J), Utils.safe_vec(fu), Utils.safe_vec(u);
             stats, abstol, reltol, linsolve_kwargs...
diff --git a/lib/NonlinearSolveBase/src/jacobian.jl b/lib/NonlinearSolveBase/src/jacobian.jl
@@ -180,15 +180,15 @@ function construct_concrete_adtype(f::NonlinearFunction, ad::AbstractADType)
     if f.sparsity === nothing
         if f.jac_prototype === nothing
             if SciMLBase.has_colorvec(f)
-                @SciMLMessage("`colorvec` is provided but `sparsity` and `jac_prototype` is not \
-                       specified. `colorvec` will be ignored.", nonlinear_verbose[], :colorvec_no_prototype, :performance )
+                @warn "`colorvec` is provided but `sparsity` and `jac_prototype` is not \
+                       specified. `colorvec` will be ignored."
             end
             return ad # No sparse AD
         else
             if !sparse_or_structured_prototype(f.jac_prototype)
                 if SciMLBase.has_colorvec(f)
-                    @SciMLMessage("`colorvec` is provided but `jac_prototype` is not a sparse \
-                           or structured matrix. `colorvec` will be ignored.", nonlinear_verbose[], :colorvec_non_sparse, :performance)
+                    @warn "`colorvec` is provided but `jac_prototype` is not a sparse \
+                           or structured matrix. `colorvec` will be ignored."
                 end
                 return ad
             end
diff --git a/lib/NonlinearSolveBase/src/polyalg.jl b/lib/NonlinearSolveBase/src/polyalg.jl
@@ -123,8 +123,8 @@ function SciMLBase.__init(
         initializealg = NonlinearSolveDefaultInit(), kwargs...
 )
     if alias_u0 && !ArrayInterface.ismutable(prob.u0)
-        verbose && @warn "`alias_u0` has been set to `true`, but `u0` is \
-                          immutable (checked using `ArrayInterface.ismutable`)."
+        @SciMLMessage("`alias_u0` has been set to `true`, but `u0` is 
+            immutable (checked using `ArrayInterface.ismutable``).", verbose, :alias_u0_immutable, :error_control)
         alias_u0 = false  # If immutable don't care about aliasing
     end
 
diff --git a/lib/NonlinearSolveBase/src/solve.jl b/lib/NonlinearSolveBase/src/solve.jl
@@ -1,9 +1,7 @@
 function SciMLBase.__solve(
-        prob::AbstractNonlinearProblem, alg::AbstractNonlinearSolveAlgorithm, args...;
-        verbose = NonlinearVerbosity(), linsolve_kwargs = (;), kwargs...
-)
-        cache = SciMLBase.__init(prob, alg, args...; kwargs...)
-        sol = CommonSolve.solve!(cache)
+        prob::AbstractNonlinearProblem, alg::AbstractNonlinearSolveAlgorithm, args...; kwargs...)
+    cache = SciMLBase.__init(prob, alg, args...; kwargs...)
+    sol = CommonSolve.solve!(cache)
 
     return sol
 end
@@ -140,8 +138,8 @@ end
     calls = [quote
         current = alg.start_index
         if alias_u0 && !ArrayInterface.ismutable(prob.u0)
-            verbose && @warn "`alias_u0` has been set to `true`, but `u0` is \
-                              immutable (checked using `ArrayInterface.ismutable`)."
+            @SciMLMessage("`alias_u0` has been set to `true`, but `u0` is
+            immutable (checked using `ArrayInterface.ismutable``).", verbose, :alias_u0_immutable, :error_control)
             alias_u0 = false  # If immutable don't care about aliasing
         end
     end]
@@ -314,11 +312,11 @@ end
 
 function SciMLBase.__init(
         prob::AbstractNonlinearProblem, alg::AbstractNonlinearSolveAlgorithm, args...;
-        initializealg = NonlinearSolveDefaultInit(),
+        initializealg = NonlinearSolveDefaultInit(), verbose = NonlinearVerbosity(),
         kwargs...
 )
     cache = NonlinearSolveNoInitCache(
-        prob, alg, args, kwargs, initializealg, ReturnCode.Default)
+        prob, alg, args, kwargs, initializealg, ReturnCode.Default, verbose)
     run_initialization!(cache)
     return cache
 end
diff --git a/lib/NonlinearSolveFirstOrder/src/NonlinearSolveFirstOrder.jl b/lib/NonlinearSolveFirstOrder/src/NonlinearSolveFirstOrder.jl
@@ -22,7 +22,8 @@ using NonlinearSolveBase: NonlinearSolveBase, AbstractNonlinearSolveAlgorithm,
                           Utils, InternalAPI, get_timer_output, @static_timeit,
                           update_trace!, L2_NORM, NonlinearSolvePolyAlgorithm,
                           NewtonDescent, DampedNewtonDescent, GeodesicAcceleration,
-                          Dogleg, NonlinearSolveForwardDiffCache, NonlinearVerbosity
+                          Dogleg, NonlinearSolveForwardDiffCache, NonlinearVerbosity,
+                          @SciMLMessage
 using SciMLBase: SciMLBase, AbstractNonlinearProblem, NLStats, ReturnCode,
                  NonlinearFunction,
                  NonlinearLeastSquaresProblem, NonlinearProblem, NoSpecialize
diff --git a/lib/NonlinearSolveFirstOrder/src/solve.jl b/lib/NonlinearSolveFirstOrder/src/solve.jl
@@ -124,7 +124,7 @@ function SciMLBase.__init(
         prob::AbstractNonlinearProblem, alg::GeneralizedFirstOrderAlgorithm, args...;
         stats = NLStats(0, 0, 0, 0, 0), alias_u0 = false, maxiters = 1000,
         abstol = nothing, reltol = nothing, maxtime = nothing,
-        termination_condition = nothing, internalnorm = L2_NORM,
+        termination_condition = nothing, internalnorm = L2_NORM, verbose = NonlinearVerbosity(),
         linsolve_kwargs = (;), initializealg = NonlinearSolveBase.NonlinearSolveDefaultInit(), kwargs...
 )
     @set! alg.autodiff = NonlinearSolveBase.select_jacobian_autodiff(prob, alg.autodiff)
@@ -215,7 +215,7 @@ function SciMLBase.__init(
             jac_cache, descent_cache, linesearch_cache, trustregion_cache,
             stats, 0, maxiters, maxtime, alg.max_shrink_times, timer,
             0.0, true, termination_cache, trace, ReturnCode.Default, false, kwargs,
-            initializealg
+            initializealg, verbose
         )
         NonlinearSolveBase.run_initialization!(cache)
     end
@@ -259,10 +259,8 @@ function InternalAPI.step!(
             return
         else
             # Jacobian Information is not current and linear solve failed, recompute it
-            if !haskey(cache.kwargs, :verbose) || cache.kwargs[:verbose]
-                @warn "Linear Solve Failed but Jacobian Information is not current. \
-                       Retrying with updated Jacobian."
-            end
+            @SciMLMessage("Linear Solve Failed but Jacobian information is not current. Retrying with updated Jacobian. \
+                Retrying with updated Jacobian.", cache.verbose, :linsolve_failed_noncurrent, :error_control)
             # In the 2nd call the `new_jacobian` is guaranteed to be `true`.
             cache.make_new_jacobian = true
             InternalAPI.step!(cache; recompute_jacobian = true, kwargs...)
diff --git a/lib/NonlinearSolveQuasiNewton/src/NonlinearSolveQuasiNewton.jl b/lib/NonlinearSolveQuasiNewton/src/NonlinearSolveQuasiNewton.jl
@@ -19,7 +19,8 @@ using NonlinearSolveBase: NonlinearSolveBase, AbstractNonlinearSolveAlgorithm,
                           AbstractApproximateJacobianUpdateRule, AbstractDescentDirection,
                           AbstractApproximateJacobianUpdateRuleCache,
                           Utils, InternalAPI, get_timer_output, @static_timeit,
-                          update_trace!, L2_NORM, NewtonDescent, NonlinearVerbosity
+                          update_trace!, L2_NORM, NewtonDescent, NonlinearVerbosity,
+                          @SciMLMessage
 using SciMLBase: SciMLBase, AbstractNonlinearProblem, NLStats, ReturnCode,
                  NonlinearProblem, NonlinearFunction, NoSpecialize
 using SciMLOperators: AbstractSciMLOperator
diff --git a/lib/NonlinearSolveQuasiNewton/src/initialization.jl b/lib/NonlinearSolveQuasiNewton/src/initialization.jl
@@ -153,7 +153,7 @@ NonlinearSolveBase.jacobian_initialized_preinverted(::BroydenLowRankInitializati
 function InternalAPI.init(
         prob::AbstractNonlinearProblem, alg::BroydenLowRankInitialization,
         solver, f::F, fu, u, p;
-        internalnorm::IN = L2_NORM, maxiters = 1000, kwargs...
+        internalnorm::IN = L2_NORM, maxiters = 1000, verbose = NonlinearVerbosity(), kwargs...
 ) where {F, IN}
     if u isa Number # Use the standard broyden
         return InternalAPI.init(
@@ -168,8 +168,8 @@ function InternalAPI.init(
     else
         threshold = min(Utils.unwrap_val(alg.threshold), maxiters)
         if threshold > length(u)
-            @warn "`threshold` is larger than the size of the state, which may cause \
-                   numerical instability. Consider reducing `threshold`."
+            @SciMLMessage("`threshold` is larger than the size of the state, which may cause \
+                   numerical instability. Consider reducing `threshold`.", verbose, :threshold_state, :numerical)
         end
         J = BroydenLowRankJacobian(fu, u; threshold, alpha = α)
     end
diff --git a/lib/NonlinearSolveQuasiNewton/src/solve.jl b/lib/NonlinearSolveQuasiNewton/src/solve.jl
@@ -143,6 +143,7 @@ function SciMLBase.__init(
         maxiters = 1000, abstol = nothing, reltol = nothing,
         linsolve_kwargs = (;), termination_condition = nothing,
         internalnorm::F = L2_NORM, initializealg = NonlinearSolveBase.NonlinearSolveDefaultInit(),
+        verbose = NonlinearVerbosity(),
         kwargs...
 ) where {F}
     timer = get_timer_output()
@@ -223,7 +224,7 @@ function SciMLBase.__init(
             trustregion_cache, update_rule_cache, reinit_rule_cache,
             inv_workspace, stats, 0, 0, alg.max_resets, maxiters, maxtime,
             alg.max_shrink_times, 0, timer, 0.0, termination_cache, trace,
-            ReturnCode.Default, false, false, kwargs, initializealg
+            ReturnCode.Default, false, false, kwargs, initializealg, verbose
         )
         NonlinearSolveBase.run_initialization!(cache)
     end
@@ -325,10 +326,10 @@ function InternalAPI.step!(
             return
         else
             # Force a reinit because the problem is currently un-solvable
-            if !haskey(cache.kwargs, :verbose) || cache.kwargs[:verbose]
-                @warn "Linear Solve Failed but Jacobian Information is not current. \
-                       Retrying with reinitialized Approximate Jacobian."
-            end
+            
+            @SciMLMessage("Linear Solve Failed but Jacobian information is not current. Retrying with updated Jacobian. \
+                Retrying with updated Jacobian.", cache.verbose, :linsolve_failed_noncurrent, :error_control)
+
             cache.force_reinit = true
             InternalAPI.step!(cache; recompute_jacobian = true)
             return
diff --git a/lib/NonlinearSolveSpectralMethods/src/NonlinearSolveSpectralMethods.jl b/lib/NonlinearSolveSpectralMethods/src/NonlinearSolveSpectralMethods.jl
@@ -10,7 +10,7 @@ using LineSearch: RobustNonMonotoneLineSearch
 using MaybeInplace: @bb
 using NonlinearSolveBase: NonlinearSolveBase, AbstractNonlinearSolveAlgorithm,
                           AbstractNonlinearSolveCache, Utils, InternalAPI, get_timer_output,
-                          @static_timeit, update_trace!, NonlinearVerbosity
+                          @static_timeit, update_trace!, NonlinearVerbosity, @SciMLMessage
 using SciMLBase: SciMLBase, AbstractNonlinearProblem, NLStats, ReturnCode,
                  NonlinearProblem, NonlinearFunction, NoSpecialize
 
diff --git a/lib/NonlinearSolveSpectralMethods/src/solve.jl b/lib/NonlinearSolveSpectralMethods/src/solve.jl
@@ -117,7 +117,8 @@ function SciMLBase.__init(
         prob::AbstractNonlinearProblem, alg::GeneralizedDFSane, args...;
         stats = NLStats(0, 0, 0, 0, 0), alias_u0 = false, maxiters = 1000,
         abstol = nothing, reltol = nothing, termination_condition = nothing,
-        maxtime = nothing, initializealg = NonlinearSolveBase.NonlinearSolveDefaultInit(), kwargs...
+        maxtime = nothing, verbose = NonlinearVerbosity(), 
+        initializealg = NonlinearSolveBase.NonlinearSolveDefaultInit(), kwargs...
 )
     timer = get_timer_output()
 
@@ -154,7 +155,7 @@ function SciMLBase.__init(
             fu, fu_cache, u, u_cache, prob.p, du, alg, prob,
             σ_n, T(alg.σ_min), T(alg.σ_max),
             linesearch_cache, stats, 0, maxiters, maxtime, timer, 0.0,
-            tc_cache, trace, ReturnCode.Default, false, kwargs, initializealg
+            tc_cache, trace, ReturnCode.Default, false, kwargs, initializealg, verbose
         )
         NonlinearSolveBase.run_initialization!(cache)
     end
@@ -167,8 +168,8 @@ function InternalAPI.step!(
         kwargs...
 )
     if recompute_jacobian !== nothing
-        @warn "GeneralizedDFSane is a Jacobian-Free Algorithm. Ignoring \
-              `recompute_jacobian`" maxlog=1
+        @SciMLMessage("GeneralizedDFSane is a Jacobian-Free Algorithm. Ignoring \
+              `recompute_jacobian`", cache.verbose, :jacobian_free, :error_control)
     end
 
     @static_timeit cache.timer "descent" begin
diff --git a/lib/SimpleNonlinearSolve/src/SimpleNonlinearSolve.jl b/lib/SimpleNonlinearSolve/src/SimpleNonlinearSolve.jl
@@ -12,7 +12,7 @@ using LineSearch: LiFukushimaLineSearch
 using MaybeInplace: @bb
 using NonlinearSolveBase: NonlinearSolveBase, ImmutableNonlinearProblem, L2_NORM,
                           nonlinearsolve_forwarddiff_solve, nonlinearsolve_dual_solution,
-                          AbstractNonlinearSolveAlgorithm, NonlinearVerbosity
+                          AbstractNonlinearSolveAlgorithm, NonlinearVerbosity, @SciMLMessage
 using SciMLBase: SciMLBase, NonlinearFunction, NonlinearProblem,
                  NonlinearLeastSquaresProblem, ReturnCode, remake
 
diff --git a/lib/SimpleNonlinearSolve/src/lbroyden.jl b/lib/SimpleNonlinearSolve/src/lbroyden.jl
@@ -36,18 +36,18 @@ end
 
 function SciMLBase.__solve(
         prob::ImmutableNonlinearProblem, alg::SimpleLimitedMemoryBroyden,
-        args...; termination_condition = nothing, kwargs...)
+        args...; termination_condition = nothing, verbose = NonlinearVerbosity(), kwargs...)
     if prob.u0 isa SArray
         if termination_condition === nothing ||
            termination_condition isa NonlinearSolveBase.AbsNormTerminationMode
             return internal_static_solve(
                 prob, alg, args...; termination_condition, kwargs...
             )
         end
-        @warn "Specifying `termination_condition = $(termination_condition)` for \
+        @SciMLMessage("Specifying `termination_condition = $(termination_condition)` for \
                `SimpleLimitedMemoryBroyden` with `SArray` is not non-allocating. Use \
                either `termination_condition = AbsNormTerminationMode(Base.Fix2(norm, Inf))` \
-               or `termination_condition = nothing`." maxlog=1
+               or `termination_condition = nothing`.", verbose, :termination_condition, :error_control)
     end
     return internal_generic_solve(prob, alg, args...; termination_condition, kwargs...)
 end

Original file line number	Diff line number	Diff line change
`@@ -47,7 +47,7 @@ function SciMLBase.__solve(`
`47`	`47`	`if sign(fl) == sign(fr)`
`48`	`48`	`@SciMLMessage("The interval is not an enclosing interval, opposite signs at the \`
`49`	`49`	`boundaries are required.",`
`50`		`- nonlinear_verbose[], :non_enclosing_interval, :error_control)`
	`50`	`+ verbose, :non_enclosing_interval, :error_control)`
`51`	`51`	`return SciMLBase.build_solution(`
`52`	`52`	`prob, alg, left, fl; retcode = ReturnCode.InitialFailure, left, right`
`53`	`53`	`)`
Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,7 @@ function SciMLBase.__solve(`
`35`	`35`	`if sign(fl) == sign(fr)`
`36`	`36`	`@SciMLMessage("The interval is not an enclosing interval, opposite signs at the \`
`37`	`37`	`boundaries are required.",`
`38`		`- nonlinear_verbose[], :non_enclosing_interval, :error_control)`
	`38`	`+ verbose, :non_enclosing_interval, :error_control)`
`39`	`39`	`return SciMLBase.build_solution(`
`40`	`40`	`prob, alg, left, fl; retcode = ReturnCode.InitialFailure, left, right`
`41`	`41`	`)`
Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,7 @@ function SciMLBase.__solve(`
`34`	`34`	`if sign(fl) == sign(fr)`
`35`	`35`	`@SciMLMessage("The interval is not an enclosing interval, opposite signs at the \`
`36`	`36`	`boundaries are required.",`
`37`		`- nonlinear_verbose[], :non_enclosing_interval, :error_control)`
	`37`	`+ verbose, :non_enclosing_interval, :error_control)`
`38`	`38`	`return SciMLBase.build_solution(`
`39`	`39`	`prob, alg, left, fl; retcode = ReturnCode.InitialFailure, left, right`
`40`	`40`	`)`
Original file line number	Diff line number	Diff line change
`@@ -85,7 +85,7 @@ function SciMLBase.__solve(`
`85`	`85`	`if sign(fl) == sign(fr)`
`86`	`86`	`@SciMLMessage("The interval is not an enclosing interval, opposite signs at the \`
`87`	`87`	`boundaries are required.",`
`88`		`- nonlinear_verbose[], :non_enclosing_interval, :error_control)`
	`88`	`+ verbose, :non_enclosing_interval, :error_control)`
`89`	`89`	`return SciMLBase.build_solution(`
`90`	`90`	`prob, alg, left, fl; retcode = ReturnCode.InitialFailure, left, right`
`91`	`91`	`)`