Fix tests

Author: avik-pal

src/ad.jl

@@ -7,10 +7,30 @@ function SciMLBase.solve(prob::NonlinearProblem{<:Union{Number, <:AbstractArray}
         sol.original)
 end
 
-function __nlsolve_ad(prob::NonlinearProblem{uType, iip}, alg, args...;
-        kwargs...) where {uType, iip}
+# Handle Ambiguities
+for algType in (Bisection, Brent, Alefeld, Falsi, ITP, Ridder)
+    @eval begin
+        function SciMLBase.solve(prob::IntervalNonlinearProblem{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, left = Dual{T, V, P}(sol.left, partials),
+                right = Dual{T, V, P}(sol.right, partials))
+        end
+    end
+end
+
+function __nlsolve_ad(prob, alg, args...; kwargs...)
     p = value(prob.p)
-    newprob = NonlinearProblem(prob.f, value(prob.u0), p; prob.kwargs...)
+    if prob isa IntervalNonlinearProblem
+        tspan = value.(prob.tspan)
+        newprob = IntervalNonlinearProblem(prob.f, tspan, p; prob.kwargs...)
+    else
+        u0 = value(prob.u0)
+        newprob = NonlinearProblem(prob.f, u0, p; prob.kwargs...)
+    end
 
     sol = solve(newprob, alg, args...; kwargs...)
 
@@ -77,24 +97,3 @@ end
     _partials = _restructure(u, partials)
     return map(((uᵢ, pᵢ),) -> Dual{T, V, P}(uᵢ, pᵢ), zip(u, _partials))
 end
-
-# avoid ambiguities
-for Alg in [Bisection]
-    @eval function SciMLBase.solve(prob::IntervalNonlinearProblem{uType, iip,
-                <:Dual{T, V, P}}, alg::$Alg, args...; kwargs...) where {uType, iip, T, V, P}
-        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,
-            left = Dual{T, V, P}(sol.left, partials),
-            right = Dual{T, V, P}(sol.right, partials))
-    end
-    @eval function SciMLBase.solve(prob::IntervalNonlinearProblem{uType, iip,
-                <:AbstractArray{<:Dual{T, V, P}}}, alg::$Alg, args...;
-            kwargs...) where {uType, iip, T, V, P}
-        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,
-            left = Dual{T, V, P}(sol.left, partials),
-            right = Dual{T, V, P}(sol.right, partials))
-    end
-end

src/nlsolve/halley.jl

@@ -71,7 +71,7 @@ function SciMLBase.__solve(prob::NonlinearProblem, alg::SimpleHalley, args...;
 
         @bb Aaᵢ = A × aᵢ
         @bb A .*= -1
-        bᵢ = dfx_fact \ Aaᵢ
+        bᵢ = dfx_fact \ _vec(Aaᵢ)
 
         cᵢ_ = _vec(cᵢ)
         @bb @. cᵢ_ = (aᵢ * aᵢ) / (-aᵢ + (T(0.5) * bᵢ))

test/forward_ad.jl

@@ -1,4 +1,5 @@
 using ForwardDiff, SimpleNonlinearSolve, StaticArrays, Test, LinearAlgebra
+import SimpleNonlinearSolve: AbstractSimpleNonlinearSolveAlgorithm
 
 test_f!(du, u, p) = (@. du = u^2 - p)
 test_f(u, p) = (@. u^2 - p)
@@ -26,24 +27,12 @@ __compatible(::Any, ::Number) = true
 __compatible(::Number, ::AbstractArray) = false
 __compatible(u::AbstractArray, p::AbstractArray) = size(u) == size(p)
 
-__compatible(u::Number, ::SimpleNonlinearSolve.AbstractSimpleNonlinearSolveAlgorithm) = true
-function __compatible(u::AbstractArray,
-        ::SimpleNonlinearSolve.AbstractSimpleNonlinearSolveAlgorithm)
-    true
-end
-function __compatible(u::StaticArray,
-        ::SimpleNonlinearSolve.AbstractSimpleNonlinearSolveAlgorithm)
-    true
-end
+__compatible(u::Number, ::AbstractSimpleNonlinearSolveAlgorithm) = true
+__compatible(u::AbstractArray, ::AbstractSimpleNonlinearSolveAlgorithm) = true
+__compatible(u::StaticArray, ::AbstractSimpleNonlinearSolveAlgorithm) = true
 
-function __compatible(::SimpleNonlinearSolve.AbstractSimpleNonlinearSolveAlgorithm,
-        ::Val{:iip})
-    true
-end
-function __compatible(::SimpleNonlinearSolve.AbstractSimpleNonlinearSolveAlgorithm,
-        ::Val{:oop})
-    true
-end
+__compatible(::AbstractSimpleNonlinearSolveAlgorithm, ::Val{:iip}) = true
+__compatible(::AbstractSimpleNonlinearSolveAlgorithm, ::Val{:oop}) = true
 __compatible(::SimpleHalley, ::Val{:iip}) = false
 
 @testset "ForwardDiff.jl Integration: $(alg)" for alg in (SimpleNewtonRaphson(),