Resolve ambiguities

Author: avik-pal

src/SimpleNonlinearSolve.jl

@@ -65,15 +65,6 @@ function SciMLBase.solve(prob::NonlinearProblem, alg::AbstractSimpleNonlinearSol
     return SciMLBase.__solve(prob, alg, args...; kwargs...)
 end
 
-function SciMLBase.solve(prob::NonlinearProblem{<:Union{<:Number, <:SArray}},
-        alg::AbstractSimpleNonlinearSolveAlgorithm, args...; abstol = nothing,
-        reltol = nothing, kwargs...)
-    _abstol = __get_tolerance(prob.u0, abstol, eltype(prob.u0))
-    _reltol = __get_tolerance(prob.u0, reltol, eltype(prob.u0))
-    return SciMLBase.__solve(prob, alg, args...; abstol = _abstol, reltol = _reltol,
-        kwargs...)
-end
-
 @setup_workload begin
     for T in (Float32, Float64)
         prob_no_brack_scalar = NonlinearProblem{false}((u, p) -> u .* u .- p, T(0.1), T(2))

src/ad.jl

@@ -7,21 +7,6 @@ function SciMLBase.solve(prob::NonlinearProblem{<:Union{Number, <:AbstractArray}
         sol.original)
 end
 
-# Handle Ambiguities
-for algType in (SimpleNewtonRaphson, SimpleDFSane, SimpleTrustRegion, SimpleBroyden,
-    SimpleLimitedMemoryBroyden, SimpleKlement, SimpleHalley)
-    @eval begin
-        function SciMLBase.solve(prob::NonlinearProblem{uType, iip,
-                    <:Union{<:Dual{T, V, P}, <:AbstractArray{<:Dual{T, V, P}}}},
-                alg::$(algType), args...; kwargs...) where {uType, T, V, P, iip}
-            sol, partials = __nlsolve_ad(prob, alg, args...; kwargs...)
-            dual_soln = __nlsolve_dual_soln(sol.u, partials, prob.p)
-            return SciMLBase.build_solution(prob, alg, dual_soln, sol.resid; sol.retcode,
-                sol.stats, sol.original)
-        end
-    end
-end
-
 for algType in (Bisection, Brent, Alefeld, Falsi, ITP, Ridder)
     @eval begin
         function SciMLBase.solve(prob::IntervalNonlinearProblem{uType, iip,

src/nlsolve/broyden.jl

@@ -6,10 +6,10 @@ and static array problems.
 
 ### Keyword Arguments
 
-  * `linesearch`: If `linesearch` is `Val(true)`, then we use the `LiFukushimaLineSearch`
+  - `linesearch`: If `linesearch` is `Val(true)`, then we use the `LiFukushimaLineSearch`
     [1] line search else no line search is used. For advanced customization of the line
     search, use the [`Broyden`](@ref) algorithm in `NonlinearSolve.jl`.
-  * `alpha`: Scale the initial jacobian initialization with `alpha`. If it is `nothing`, we
+  - `alpha`: Scale the initial jacobian initialization with `alpha`. If it is `nothing`, we
     will compute the scaling using `2 * norm(fu) / max(norm(u), true)`.
 
 ### References

src/nlsolve/lbroyden.jl

@@ -35,12 +35,6 @@ function SimpleLimitedMemoryBroyden(; threshold::Union{Val, Int} = Val(27),
     return SimpleLimitedMemoryBroyden{_unwrap_val(threshold), _unwrap_val(linesearch)}(alpha)
 end
 
-# Don't resolve the `abstol` and `reltol` here
-function SciMLBase.solve(prob::NonlinearProblem{<:Union{<:Number, <:SArray}},
-        alg::SimpleLimitedMemoryBroyden, args...; kwargs...)
-    return SciMLBase.__solve(prob, alg, args...; kwargs...)
-end
-
 function SciMLBase.__solve(prob::NonlinearProblem, alg::SimpleLimitedMemoryBroyden,
         args...; termination_condition = nothing, kwargs...)
     if prob.u0 isa SArray

src/utils.jl

@@ -282,8 +282,8 @@ function init_termination_cache(abstol, reltol, du, u, ::Nothing)
 end
 function init_termination_cache(abstol, reltol, du, u, tc::AbstractNonlinearTerminationMode)
     T = promote_type(eltype(du), eltype(u))
-    abstol !== nothing && (abstol = T(abstol))
-    reltol !== nothing && (reltol = T(reltol))
+    abstol = __get_tolerance(u, abstol, T)
+    reltol = __get_tolerance(u, reltol, T)
     tc_cache = init(du, u, tc; abstol, reltol)
     return DiffEqBase.get_abstol(tc_cache), DiffEqBase.get_reltol(tc_cache), tc_cache
 end