Shift from Symbols to Enum for Retcode

Author: kanav99

src/bisection.jl

@@ -33,7 +33,7 @@ function perform_step(solver::BracketingImmutableSolver, alg::Bisection, cache)
 
     if left == mid || right == mid
       @set! solver.force_stop = true
-      @set! solver.retcode = :FloatingPointLimit
+      @set! solver.retcode = FLOATING_POINT_LIMIT
       return solver
     end
 

src/falsi.jl

@@ -20,7 +20,7 @@ function perform_step(solver, alg::Falsi, cache)
 
   if right == mid || right == mid
     @set! solver.force_stop = true
-    @set! solver.retcode = :FloatingPointLimit
+    @set! solver.retcode = FLOATING_POINT_LIMIT
     return solver
   end
 
@@ -31,7 +31,7 @@ function perform_step(solver, alg::Falsi, cache)
     @set! solver.force_stop = true
     @set! solver.left = mid
     @set! solver.fl = fm
-    @set! solver.retcode = :ExactSolutionAtLeft
+    @set! solver.retcode = EXACT_SOLUTION_LEFT
   else
     if sign(fm) == sign(fl)
       @set! solver.left = mid

src/scalar.jl

@@ -8,15 +8,15 @@ function DiffEqBase.solve(prob::NonlinearProblem{<:Number}, ::NewtonRaphson, arg
   xo = oftype(x, Inf)
   for i in 1:maxiters
     fx, dfx = value_derivative(f, x)
-    iszero(fx) && return NewtonSolution(x, :Default)
+    iszero(fx) && return NewtonSolution(x, DEFAULT)
     Δx = dfx \ fx
     x -= Δx
     if isapprox(x, xo, atol=atol, rtol=rtol)
-        return NewtonSolution(x, :Default)
+        return NewtonSolution(x, DEFAULT)
     end
     xo = x
   end
-  return NewtonSolution(x, :MaxitersExceeded)
+  return NewtonSolution(x, MAXITERS_EXCEED)
 end
 
 function DiffEqBase.solve(prob::NonlinearProblem, ::Bisection, args...; maxiters = 1000, kwargs...)
@@ -25,14 +25,14 @@ function DiffEqBase.solve(prob::NonlinearProblem, ::Bisection, args...; maxiters
   fl, fr = f(left), f(right)
 
   if iszero(fl)
-    return BracketingSolution(left, right, :ExactSolutionAtLeft)
+    return BracketingSolution(left, right, EXACT_SOLUTION_LEFT)
   end
 
   i = 1
   if !iszero(fr)
     while i < maxiters
       mid = (left + right) / 2
-      (mid == left || mid == right) && return BracketingSolution(left, right, :FloatingPointLimit)
+      (mid == left || mid == right) && return BracketingSolution(left, right, FLOATING_POINT_LIMIT)
       fm = f(mid)
       if iszero(fm)
         right = mid
@@ -51,7 +51,7 @@ function DiffEqBase.solve(prob::NonlinearProblem, ::Bisection, args...; maxiters
 
   while i < maxiters
     mid = (left + right) / 2
-    (mid == left || mid == right) && return BracketingSolution(left, right, :FloatingPointLimit)
+    (mid == left || mid == right) && return BracketingSolution(left, right, FLOATING_POINT_LIMIT)
     fm = f(mid)
     if iszero(fm)
       right = mid
@@ -63,5 +63,5 @@ function DiffEqBase.solve(prob::NonlinearProblem, ::Bisection, args...; maxiters
     i += 1
   end
 
-  return BracketingSolution(left, right, :MaxitersExceeded)
+  return BracketingSolution(left, right, MAXITERS_EXCEED)
 end

src/solve.jl

@@ -30,7 +30,7 @@ function DiffEqBase.init(prob::NonlinearProblem{uType, iip}, alg::AbstractBracke
   fl = f(left, p)
   fr = f(right, p)
   cache = alg_cache(alg, left, right,p, Val(iip))
-  return BracketingImmutableSolver(1, f, alg, left, right, fl, fr, p, false, maxiters, :Default, cache, iip)
+  return BracketingImmutableSolver(1, f, alg, left, right, fl, fr, p, false, maxiters, DEFAULT, cache, iip)
 end
 
 function DiffEqBase.init(prob::NonlinearProblem{uType, iip}, alg::AbstractNewtonAlgorithm, args...;
@@ -55,7 +55,7 @@ function DiffEqBase.init(prob::NonlinearProblem{uType, iip}, alg::AbstractNewton
     fu = f(u, p)
   end
   cache = alg_cache(alg, f, u, p, Val(iip))
-  return NewtonImmutableSolver(1, f, alg, u, fu, p, false, maxiters, internalnorm, :Default, tol, cache, iip)
+  return NewtonImmutableSolver(1, f, alg, u, fu, p, false, maxiters, internalnorm, DEFAULT, tol, cache, iip)
 end
 
 function DiffEqBase.solve!(solver::AbstractImmutableNonlinearSolver)
@@ -65,7 +65,7 @@ function DiffEqBase.solve!(solver::AbstractImmutableNonlinearSolver)
     @set! solver.iter += 1
   end
   if solver.iter == solver.maxiters
-    @set! solver.retcode = :MaxitersExceeded
+    @set! solver.retcode = MAXITERS_EXCEED
   end
   sol = get_solution(solver)
   return sol
@@ -84,10 +84,10 @@ function mic_check(solver::BracketingImmutableSolver)
   (flr > fzero) && error("Non bracketing interval passed in bracketing method.")
   if fl == fzero
     @set! solver.force_stop = true
-    @set! solver.retcode = :ExactSolutionAtLeft
+    @set! solver.retcode = EXACT_SOLUTION_LEFT
   elseif fr == fzero
     @set! solver.force_stop = true
-    @set! solver.retcode = :ExactSolutionAtRight
+    @set! solver.retcode = EXACT_SOLUTION_RIGHT
   end
   solver
 end

src/types.jl

@@ -1,3 +1,11 @@
+@enum Retcode::Int begin
+    DEFAULT
+    EXACT_SOLUTION_LEFT
+    EXACT_SOLUTION_RIGHT
+    MAXITERS_EXCEED
+    FLOATING_POINT_LIMIT
+end
+
 struct BracketingImmutableSolver{fType, algType, uType, resType, pType, cacheType} <: AbstractImmutableNonlinearSolver
     iter::Int
     f::fType
@@ -9,7 +17,7 @@ struct BracketingImmutableSolver{fType, algType, uType, resType, pType, cacheTyp
     p::pType
     force_stop::Bool
     maxiters::Int
-    retcode::Symbol
+    retcode::Retcode
     cache::cacheType
     iip::Bool
 end
@@ -29,7 +37,7 @@ struct NewtonImmutableSolver{fType, algType, uType, resType, pType, INType, tolT
     force_stop::Bool
     maxiters::Int
     internalnorm::INType
-    retcode::Symbol
+    retcode::Retcode
     tol::tolType
     cache::cacheType
     iip::Bool
@@ -43,12 +51,12 @@ end
 struct BracketingSolution{uType}
     left::uType
     right::uType
-    retcode::Symbol
+    retcode::Retcode
 end
 
 struct NewtonSolution{uType}
     u::uType
-    retcode::Symbol
+    retcode::Retcode
 end
 
 function sync_residuals!(solver::BracketingImmutableSolver)

test/runtests.jl

@@ -23,13 +23,13 @@ end
 f, u0 = (u,p) -> u .* u .- 2, @SVector[1.0, 1.0]
 sf, su0 = (u,p) -> u * u - 2, 1.0
 sol = benchmark_immutable(f, u0)
-@test sol.retcode === :Default
+@test sol.retcode === NonlinearSolve.DEFAULT
 @test all(sol.u .* sol.u .- 2 .< 1e-9)
 sol = benchmark_mutable(f, u0)
-@test sol.retcode === :Default
+@test sol.retcode === NonlinearSolve.DEFAULT
 @test all(sol.u .* sol.u .- 2 .< 1e-9)
 sol = benchmark_scalar(sf, su0)
-@test sol.retcode === :Default
+@test sol.retcode === NonlinearSolve.DEFAULT
 @test sol.u * sol.u - 2 < 1e-9
 
 @test (@ballocated benchmark_immutable($f, $u0)) == 0