Remove regex matching and use strings for retcode determination

lib/OptimizationManopt/src/OptimizationManopt.jl

@@ -394,8 +394,10 @@ function SciMLBase.__solve(cache::OptimizationCache{
     local x, cur, state
 
     manifold = haskey(cache.solver_args, :manifold) ? cache.solver_args[:manifold] : nothing
-    gradF = haskey(cache.solver_args, :riemannian_grad) ? cache.solver_args[:riemannian_grad] : nothing
-    hessF = haskey(cache.solver_args, :riemannian_hess) ? cache.solver_args[:riemannian_hess] : nothing
+    gradF = haskey(cache.solver_args, :riemannian_grad) ?
+            cache.solver_args[:riemannian_grad] : nothing
+    hessF = haskey(cache.solver_args, :riemannian_hess) ?
+            cache.solver_args[:riemannian_hess] : nothing
 
     if manifold === nothing
         throw(ArgumentError("Manifold not specified in the problem for e.g. `OptimizationProblem(f, x, p; manifold = SymmetricPositiveDefinite(5))`."))

src/lbfgsb.jl

@@ -171,9 +171,11 @@ function SciMLBase.__solve(cache::OptimizationCache{
         n = length(cache.u0)
 
         if cache.lb === nothing
-            optimizer, bounds = LBFGSB._opt_bounds(n, cache.opt.m, [-Inf for i in 1:n], [Inf for i in 1:n])
+            optimizer, bounds = LBFGSB._opt_bounds(
+                n, cache.opt.m, [-Inf for i in 1:n], [Inf for i in 1:n])
         else
-            optimizer, bounds = LBFGSB._opt_bounds(n, cache.opt.m, solver_kwargs.lb, solver_kwargs.ub)
+            optimizer, bounds = LBFGSB._opt_bounds(
+                n, cache.opt.m, solver_kwargs.lb, solver_kwargs.ub)
         end
 
         solver_kwargs = Base.structdiff(solver_kwargs, (; lb = nothing, ub = nothing))
@@ -182,7 +184,8 @@ function SciMLBase.__solve(cache::OptimizationCache{
             prev_eqcons .= cons_tmp[eq_inds]
             prevβ .= copy(β)
 
-            res = optimizer(_loss, aug_grad, θ, bounds; solver_kwargs..., m = cache.opt.m, pgtol = sqrt(ϵ), maxiter = maxiters / 100)
+            res = optimizer(_loss, aug_grad, θ, bounds; solver_kwargs...,
+                m = cache.opt.m, pgtol = sqrt(ϵ), maxiter = maxiters / 100)
             # @show res[2]
             # @show res[1]
             # @show cons_tmp
@@ -211,7 +214,8 @@ function SciMLBase.__solve(cache::OptimizationCache{
         stats = Optimization.OptimizationStats(; iterations = maxiters,
             time = 0.0, fevals = maxiters, gevals = maxiters)
         return SciMLBase.build_solution(
-            cache, cache.opt, res[2], cache.f(res[2], cache.p)[1], stats = stats, retcode = opt_ret)
+            cache, cache.opt, res[2], cache.f(res[2], cache.p)[1],
+            stats = stats, retcode = opt_ret)
     else
         _loss = function (θ)
             x = cache.f(θ, cache.p)
@@ -226,16 +230,19 @@ function SciMLBase.__solve(cache::OptimizationCache{
         n = length(cache.u0)
 
         if cache.lb === nothing
-            optimizer, bounds= LBFGSB._opt_bounds(n, cache.opt.m, [-Inf for i in 1:n], [Inf for i in 1:n])
+            optimizer, bounds = LBFGSB._opt_bounds(
+                n, cache.opt.m, [-Inf for i in 1:n], [Inf for i in 1:n])
         else
-            optimizer, bounds= LBFGSB._opt_bounds(n, cache.opt.m, solver_kwargs.lb, solver_kwargs.ub)
+            optimizer, bounds = LBFGSB._opt_bounds(
+                n, cache.opt.m, solver_kwargs.lb, solver_kwargs.ub)
         end
 
         solver_kwargs = Base.structdiff(solver_kwargs, (; lb = nothing, ub = nothing))
 
         t0 = time()
 
-        res = optimizer(_loss, cache.f.grad, cache.u0, bounds; m = cache.opt.m, solver_kwargs...)
+        res = optimizer(
+            _loss, cache.f.grad, cache.u0, bounds; m = cache.opt.m, solver_kwargs...)
 
         # Extract the task message from the result
         stop_reason = task_message_to_string(optimizer.task)
@@ -247,6 +254,7 @@ function SciMLBase.__solve(cache::OptimizationCache{
         stats = Optimization.OptimizationStats(; iterations = maxiters,
             time = t1 - t0, fevals = maxiters, gevals = maxiters)
 
-        return SciMLBase.build_solution(cache, cache.opt, res[2], res[1], stats = stats, retcode = opt_ret)
+        return SciMLBase.build_solution(cache, cache.opt, res[2], res[1], stats = stats,
+            retcode = opt_ret, original = optimizer)
     end
 end

src/utils.jl

@@ -67,46 +67,45 @@ function check_pkg_version(pkg::String, ver::String;
            pkg_info[pkg].version > VersionNumber(ver)
 end
 
-
 # RetCode handling for BBO and others.
 using SciMLBase: ReturnCode
 
 # Define a dictionary to map regular expressions to ReturnCode values
 const STOP_REASON_MAP = Dict(
-    r"Delta fitness .* below tolerance .*" => ReturnCode.Success,
-    r"Fitness .* within tolerance .* of optimum" => ReturnCode.Success,
-    r"CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL" => ReturnCode.Success,
-    r"Unrecognized stop reason: CONVERGENCE: REL_REDUCTION_OF_F_<=_FACTR*EPSMCH" => ReturnCode.Success, 
-    r"Terminated" => ReturnCode.Terminated,
-    r"MaxIters|MAXITERS_EXCEED|Max number of steps .* reached" => ReturnCode.MaxIters,
-    r"MaxTime|TIME_LIMIT" => ReturnCode.MaxTime,
-    r"Max time" => ReturnCode.MaxTime,
-    r"DtLessThanMin" => ReturnCode.DtLessThanMin,
-    r"Unstable" => ReturnCode.Unstable,
-    r"InitialFailure" => ReturnCode.InitialFailure,
-    r"ConvergenceFailure|ITERATION_LIMIT" => ReturnCode.ConvergenceFailure,
-    r"Infeasible|INFEASIBLE|DUAL_INFEASIBLE|LOCALLY_INFEASIBLE|INFEASIBLE_OR_UNBOUNDED" => ReturnCode.Infeasible,
-    r"STOP: TOTAL NO. of ITERATIONS REACHED LIMIT" => ReturnCode.MaxIters,
-    r"STOP: TOTAL NO. of f AND g EVALUATIONS EXCEEDS LIMIT" => ReturnCode.MaxIters,
-    r"STOP: ABNORMAL_TERMINATION_IN_LNSRCH" => ReturnCode.Unstable,
-    r"STOP: ERROR INPUT DATA" => ReturnCode.InitialFailure,
-    r"STOP: FTOL.TOO.SMALL" => ReturnCode.ConvergenceFailure,
-    r"STOP: GTOL.TOO.SMALL" => ReturnCode.ConvergenceFailure,
-    r"STOP: XTOL.TOO.SMALL" => ReturnCode.ConvergenceFailure,
-    r"STOP: TERMINATION" => ReturnCode.Terminated,
-    r"Optimization completed" => ReturnCode.Success,
-    r"Convergence achieved" => ReturnCode.Success
+    "Delta fitness .* below tolerance .*" => ReturnCode.Success,
+    "Fitness .* within tolerance .* of optimum" => ReturnCode.Success,
+    "CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL" => ReturnCode.Success,
+    "CONVERGENCE: REL_REDUCTION_OF_F_<=_FACTR*EPSMCH" => ReturnCode.Success,
+    "Terminated" => ReturnCode.Terminated,
+    "MaxIters|MAXITERS_EXCEED|Max number of steps .* reached" => ReturnCode.MaxIters,
+    "MaxTime|TIME_LIMIT" => ReturnCode.MaxTime,
+    "Max time" => ReturnCode.MaxTime,
+    "DtLessThanMin" => ReturnCode.DtLessThanMin,
+    "Unstable" => ReturnCode.Unstable,
+    "InitialFailure" => ReturnCode.InitialFailure,
+    "ConvergenceFailure|ITERATION_LIMIT" => ReturnCode.ConvergenceFailure,
+    "Infeasible|INFEASIBLE|DUAL_INFEASIBLE|LOCALLY_INFEASIBLE|INFEASIBLE_OR_UNBOUNDED" => ReturnCode.Infeasible,
+    "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT" => ReturnCode.MaxIters,
+    "STOP: TOTAL NO. of f AND g EVALUATIONS EXCEEDS LIMIT" => ReturnCode.MaxIters,
+    "STOP: ABNORMAL_TERMINATION_IN_LNSRCH" => ReturnCode.Unstable,
+    "STOP: ERROR INPUT DATA" => ReturnCode.InitialFailure,
+    "STOP: FTOL.TOO.SMALL" => ReturnCode.ConvergenceFailure,
+    "STOP: GTOL.TOO.SMALL" => ReturnCode.ConvergenceFailure,
+    "STOP: XTOL.TOO.SMALL" => ReturnCode.ConvergenceFailure,
+    "STOP: TERMINATION" => ReturnCode.Terminated,
+    "Optimization completed" => ReturnCode.Success,
+    "Convergence achieved" => ReturnCode.Success
 )
 
 # Function to deduce ReturnCode from a stop_reason string using the dictionary
 function deduce_retcode(stop_reason::String)
     for (pattern, retcode) in STOP_REASON_MAP
         if occursin(pattern, stop_reason)
-        	return retcode
+            return retcode
         end
     end
-    @warn "Unrecognized stop reason: $stop_reason. Defaulting to ReturnCode.Failure."
-    return ReturnCode.Failure
+    @warn "Unrecognized stop reason: $stop_reason. Defaulting to ReturnCode.Default."
+    return ReturnCode.Default
 end
 
 # Function to deduce ReturnCode from a Symbol
@@ -141,4 +140,3 @@ function deduce_retcode(retcode::Symbol)
         return ReturnCode.Failure
     end
 end
-

test/ADtests.jl

@@ -202,12 +202,15 @@ prob = OptimizationProblem(optf, x0)
 
 sol = solve(prob, Optim.BFGS())
 @test 10 * sol.objective < l1
+@test sol.retcode == ReturnCode.Success
 
 sol = solve(prob, Optim.Newton())
 @test 10 * sol.objective < l1
+@test sol.retcode == ReturnCode.Success
 
 sol = solve(prob, Optim.KrylovTrustRegion())
 @test 10 * sol.objective < l1
+@test sol.retcode == ReturnCode.Success
 
 optf = OptimizationFunction(rosenbrock, Optimization.AutoZygote())
 optprob = Optimization.instantiate_function(optf, x0, Optimization.AutoZygote(), nothing)
@@ -403,10 +406,12 @@ for consf in [cons, con2_c]
     prob1 = OptimizationProblem(optf1, [0.3, 0.5], lb = [0.2, 0.4], ub = [0.6, 0.8],
         lcons = lcons, ucons = ucons)
     sol1 = solve(prob1, Optim.IPNewton())
+    @test sol1.retcode == ReturnCode.Success
     optf2 = OptimizationFunction(rosenbrock, Optimization.AutoForwardDiff(); cons = consf)
     prob2 = OptimizationProblem(optf2, [0.3, 0.5], lb = [0.2, 0.4], ub = [0.6, 0.8],
         lcons = lcons, ucons = ucons)
     sol2 = solve(prob2, Optim.IPNewton())
+    @test sol2.retcode == ReturnCode.Success
     @test sol1.objective≈sol2.objective rtol=1e-4
     @test sol1.u ≈ sol2.u
     res = Array{Float64}(undef, length(lcons))
@@ -421,9 +426,11 @@ for consf in [cons, con2_c]
     optf1 = OptimizationFunction(rosenbrock, Optimization.AutoFiniteDiff(); cons = consf)
     prob1 = OptimizationProblem(optf1, [0.5, 0.5], lcons = lcons, ucons = ucons)
     sol1 = solve(prob1, Optim.IPNewton())
+    @test sol1.retcode == ReturnCode.Success
     optf2 = OptimizationFunction(rosenbrock, Optimization.AutoForwardDiff(); cons = consf)
     prob2 = OptimizationProblem(optf2, [0.5, 0.5], lcons = lcons, ucons = ucons)
     sol2 = solve(prob2, Optim.IPNewton())
+    @test sol2.retcode == ReturnCode.Success
     @test sol1.objective≈sol2.objective rtol=1e-4
     @test sol1.u≈sol2.u rtol=1e-4
     res = Array{Float64}(undef, length(lcons))

test/lbfgsb.jl

@@ -6,12 +6,14 @@ x0 = zeros(2)
 rosenbrock(x, p = nothing) = (1 - x[1])^2 + 100 * (x[2] - x[1]^2)^2
 l1 = rosenbrock(x0)
 
-optf = OptimizationFunction(rosenbrock, AutoEnzyme())
+optf = OptimizationFunction(rosenbrock, AutoForwardDiff())
 prob = OptimizationProblem(optf, x0)
 @time res = solve(prob, Optimization.LBFGS(), maxiters = 100)
+@test res.retcode == Optimization.SciMLBase.ReturnCode.Success
 
-prob = OptimizationProblem(optf, x0,  lb = [-1.0, -1.0], ub = [1.0, 1.0])
+prob = OptimizationProblem(optf, x0, lb = [-1.0, -1.0], ub = [1.0, 1.0])
 @time res = solve(prob, Optimization.LBFGS(), maxiters = 100)
+@test res.retcode == Optimization.SciMLBase.ReturnCode.Success
 
 function con2_c(res, x, p)
     res .= [x[1]^2 + x[2]^2, (x[2] * sin(x[1]) + x[1]) - 5]
@@ -22,3 +24,4 @@ prob = OptimizationProblem(optf, x0, lcons = [1.0, -Inf],
     ucons = [1.0, 0.0], lb = [-1.0, -1.0],
     ub = [1.0, 1.0])
 @time res = solve(prob, Optimization.LBFGS(), maxiters = 100)
+@test res.retcode == Optimization.SciMLBase.ReturnCode.MaxIters