Add resid param in struct and update build_solution in solve.jl

Author: utkarsh530

src/scalar.jl

@@ -1,6 +1,7 @@
 function SciMLBase.solve(prob::NonlinearProblem{<:Number}, alg::NewtonRaphson, args...; xatol = nothing, xrtol = nothing, maxiters = 1000, kwargs...)
   f = Base.Fix2(prob.f, prob.p)
   x = float(prob.u0)
+  fx = float(prob.u0)
   T = typeof(x)
   atol = xatol !== nothing ? xatol : oneunit(T) * (eps(one(T)))^(4//5)
   rtol = xrtol !== nothing ? xrtol : eps(one(T))^(4//5)
@@ -13,15 +14,15 @@ function SciMLBase.solve(prob::NonlinearProblem{<:Number}, alg::NewtonRaphson, a
       fx = f(x)
       dfx = FiniteDiff.finite_difference_derivative(f, x, alg.diff_type, eltype(x), fx)
     end
-    iszero(fx) && return NewtonSolution(x, DEFAULT)
+    iszero(fx) && return NewtonSolution(x, DEFAULT, fx)
     Δx = dfx \ fx
     x -= Δx
     if isapprox(x, xo, atol=atol, rtol=rtol)
-        return NewtonSolution(x, DEFAULT)
+        return NewtonSolution(x, DEFAULT, fx)
     end
     xo = x
   end
-  return NewtonSolution(x, MAXITERS_EXCEED)
+  return NewtonSolution(x, MAXITERS_EXCEED, fx)
 end
 
 function scalar_nlsolve_ad(prob, alg, args...; kwargs...)
@@ -50,22 +51,22 @@ end
 
 function SciMLBase.solve(prob::NonlinearProblem{<:Number, iip, <:Dual{T,V,P}}, alg::NewtonRaphson, args...; kwargs...) where {iip, T, V, P}
   sol, partials = scalar_nlsolve_ad(prob, alg, args...; kwargs...)
-  return NewtonSolution(Dual{T,V,P}(sol.u, partials), sol.retcode)
+  return NewtonSolution(Dual{T,V,P}(sol.u, partials), sol.retcode, sol.resid)
 end
 function SciMLBase.solve(prob::NonlinearProblem{<:Number, iip, <:AbstractArray{<:Dual{T,V,P}}}, alg::NewtonRaphson, args...; kwargs...) where {iip, T, V, P}
   sol, partials = scalar_nlsolve_ad(prob, alg, args...; kwargs...)
-  return NewtonSolution(Dual{T,V,P}(sol.u, partials), sol.retcode)
+  return NewtonSolution(Dual{T,V,P}(sol.u, partials), sol.retcode, sol.resid)
 end
 
 # avoid ambiguities
 for Alg in [Bisection]
   @eval function SciMLBase.solve(prob::NonlinearProblem{uType, iip, <:Dual{T,V,P}}, alg::$Alg, args...; kwargs...) where {uType, iip, T, V, P}
     sol, partials = scalar_nlsolve_ad(prob, alg, args...; kwargs...)
-    return BracketingSolution(Dual{T,V,P}(sol.left, partials), Dual{T,V,P}(sol.right, partials), sol.retcode)
+    return BracketingSolution(Dual{T,V,P}(sol.left, partials), Dual{T,V,P}(sol.right, partials), sol.retcode, sol.resid)
   end
   @eval function SciMLBase.solve(prob::NonlinearProblem{uType, iip, <:AbstractArray{<:Dual{T,V,P}}}, alg::$Alg, args...; kwargs...) where {uType, iip, T, V, P}
     sol, partials = scalar_nlsolve_ad(prob, alg, args...; kwargs...)
-    return BracketingSolution(Dual{T,V,P}(sol.left, partials), Dual{T,V,P}(sol.right, partials), sol.retcode)
+    return BracketingSolution(Dual{T,V,P}(sol.left, partials), Dual{T,V,P}(sol.right, partials), sol.retcode, sol.resid)
   end
 end
 
@@ -75,14 +76,14 @@ function SciMLBase.solve(prob::NonlinearProblem, ::Bisection, args...; maxiters
   fl, fr = f(left), f(right)
 
   if iszero(fl)
-    return BracketingSolution(left, right, EXACT_SOLUTION_LEFT)
+    return BracketingSolution(left, right, EXACT_SOLUTION_LEFT,fl)
   end
 
   i = 1
   if !iszero(fr)
     while i < maxiters
       mid = (left + right) / 2
-      (mid == left || mid == right) && return BracketingSolution(left, right, FLOATING_POINT_LIMIT)
+      (mid == left || mid == right) && return BracketingSolution(left, right, FLOATING_POINT_LIMIT, fl)
       fm = f(mid)
       if iszero(fm)
         right = mid
@@ -101,7 +102,7 @@ function SciMLBase.solve(prob::NonlinearProblem, ::Bisection, args...; maxiters
 
   while i < maxiters
     mid = (left + right) / 2
-    (mid == left || mid == right) && return BracketingSolution(left, right, FLOATING_POINT_LIMIT)
+    (mid == left || mid == right) && return BracketingSolution(left, right, FLOATING_POINT_LIMIT, fl)
     fm = f(mid)
     if iszero(fm)
       right = mid
@@ -113,7 +114,7 @@ function SciMLBase.solve(prob::NonlinearProblem, ::Bisection, args...; maxiters
     i += 1
   end
 
-  return BracketingSolution(left, right, MAXITERS_EXCEED)
+  return BracketingSolution(left, right, MAXITERS_EXCEED,fl)
 end
 
 function SciMLBase.solve(prob::NonlinearProblem, ::Falsi, args...; maxiters = 1000, kwargs...)
@@ -122,14 +123,14 @@ function SciMLBase.solve(prob::NonlinearProblem, ::Falsi, args...; maxiters = 10
   fl, fr = f(left), f(right)
 
   if iszero(fl)
-    return BracketingSolution(left, right, EXACT_SOLUTION_LEFT)
+    return BracketingSolution(left, right, EXACT_SOLUTION_LEFT,fl)
   end
 
   i = 1
   if !iszero(fr)
     while i < maxiters
       if nextfloat_tdir(left, prob.u0...) == right
-        return BracketingSolution(left, right, FLOATING_POINT_LIMIT)
+        return BracketingSolution(left, right, FLOATING_POINT_LIMIT, fx)
       end
       mid = (fr * left - fl * right) / (fr - fl)
       for i in 1:10
@@ -156,7 +157,7 @@ function SciMLBase.solve(prob::NonlinearProblem, ::Falsi, args...; maxiters = 10
 
   while i < maxiters
     mid = (left + right) / 2
-    (mid == left || mid == right) && return BracketingSolution(left, right, FLOATING_POINT_LIMIT)
+    (mid == left || mid == right) && return BracketingSolution(left, right, FLOATING_POINT_LIMIT, fl)
     fm = f(mid)
     if iszero(fm)
       right = mid
@@ -171,5 +172,5 @@ function SciMLBase.solve(prob::NonlinearProblem, ::Falsi, args...; maxiters = 10
     i += 1
   end
 
-  return BracketingSolution(left, right, MAXITERS_EXCEED)
+  return BracketingSolution(left, right, MAXITERS_EXCEED,fl)
 end

src/solve.jl

@@ -2,9 +2,11 @@ function SciMLBase.solve(prob::NonlinearProblem,
                          alg::AbstractNonlinearSolveAlgorithm, args...;
                          kwargs...)
   solver = init(prob, alg, args...; kwargs...)
-  sol, resid = solve!(solver)
+  sol = solve!(solver)
   if typeof(sol) <: NewtonSolution
-    return SciMLBase.build_solution(prob, alg, sol.u, resid;retcode=:Success)
+    SciMLBase.build_solution(prob, alg, getsolution(sol), sol.resid;retcode=Symbol(sol.retcode))
+  else
+    SciMLBase.build_solution(prob, alg, get_solution(sol),sol.resid;retcode=Symbol(sol.retcode),left = sol.left,right = sol.right)
   end
 end
 
@@ -70,7 +72,7 @@ function SciMLBase.solve!(solver::AbstractImmutableNonlinearSolver)
     @set! solver.retcode = MAXITERS_EXCEED
   end
   sol = get_solution(solver)
-  return sol, solver.fu
+  return sol
 end
 
 """
@@ -105,11 +107,11 @@ end
 Form solution object from solver types
 """
 function get_solution(solver::BracketingImmutableSolver)
-  return BracketingSolution(solver.left, solver.right, solver.retcode)
+  return BracketingSolution(solver.left, solver.right, solver.retcode, solver.fl)
 end
 
 function get_solution(solver::NewtonImmutableSolver)
-  return NewtonSolution(solver.u, solver.retcode)
+  return NewtonSolution(solver.u, solver.retcode, solver.fu)
 end
 
 """

src/types.jl

@@ -48,15 +48,17 @@ end
 #         typeof(fu), typeof(p), typeof(internalnorm), typeof(tol), typeof(cache)}(iter, f, alg, u, fu, p, force_stop, maxiters, internalnorm, retcode, tol, cache)
 # end
 
-struct BracketingSolution{uType}
+struct BracketingSolution{uType,resType}
     left::uType
     right::uType
     retcode::Retcode
+    resid::resType
 end
 
-struct NewtonSolution{uType}
+struct NewtonSolution{uType,resType}
     u::uType
     retcode::Retcode
+    resid::resType
 end
 
 function sync_residuals!(solver::BracketingImmutableSolver)