Create Output struct

Author: abelsiqueira

src/SolverCore.jl

@@ -3,12 +3,14 @@ module SolverCore
 # stdlib
 using Logging, Printf
 
-# our packages
-using NLPModels
-
+# include("stats.jl")
+include("logger.jl")
+include("output.jl")
 include("solver.jl")
+include("traits.jl")
+
 include("grid-search-tuning.jl")
-include("logger.jl")
-include("stats.jl")
+
+include("optsolver.jl")
 
 end

src/optsolver.jl

@@ -1,4 +1,8 @@
-abstract type AbstractOptSolver{T} <: AbstractSolver{T}
+using NLPModels
+
+export AbstractOptSolver, OptSolverOutput
+
+abstract type AbstractOptSolver{T} <: AbstractSolver{T} end
 
 #=
 Constructors:
@@ -14,6 +18,54 @@ function (::Type{S})(::Type{T}, nlp :: AbstractNLPModel) where {T, S <: Abstract
   return output, solver
 end
 (::Type{S})(::Type{T}, ::Val{:nosolve}, nlp :: AbstractNLPModel) where {T, S <: AbstractOptSolver} = S(T, nlp.meta)
-(::Type{S})(::Val{:nosolve}, nlp :: AbstractNLPModel) where {S <: AbstractOptSolver} = S(Float64, Val(:nosolve), nlp)
-(::Type{S})(nlp :: AbstractNLPModel) where {S <: AbstractOptSolver} = S(Float64, nlp)
-(::Type{S})(meta :: AbstractNLPModelMeta) where {S <: AbstractOptSolver} = S(Float64, meta)
+(::Type{S})(::Val{:nosolve}, nlp :: AbstractNLPModel) where {S <: AbstractOptSolver} = S(eltype(nlp.meta.x0), Val(:nosolve), nlp)
+(::Type{S})(nlp :: AbstractNLPModel) where {S <: AbstractOptSolver} = S(eltype(nlp.meta.x0), nlp)
+(::Type{S})(meta :: AbstractNLPModelMeta) where {S <: AbstractOptSolver} = S(eltype(meta.x0), meta)
+
+mutable struct OptSolverOutput{T} <: AbstractSolverOutput{T}
+  status :: Symbol
+  solution
+  objective :: T # f(x)
+  dual_feas :: T # ‖∇f(x)‖₂ for unc, ‖P[x - ∇f(x)] - x‖₂ for bnd, etc.
+  primal_feas :: T # ‖c(x)‖ for equalities
+  multipliers
+  multipliers_L
+  multipliers_U
+  iter :: Int
+  counters :: NLPModels.NLSCounters
+  elapsed_time :: Float64
+  solver_specific :: Dict{Symbol,Any}
+end
+
+function OptSolverOutput(
+  status :: Symbol,
+  solution :: AbstractArray{T},
+  nlp :: AbstractNLPModel;
+  objective :: T = T(Inf),
+  dual_feas :: T = T(Inf),
+  primal_feas :: T = unconstrained(nlp) || bound_constrained(nlp) ? zero(T) : T(Inf),
+  multipliers :: Vector = T[],
+  multipliers_L :: Vector = T[],
+  multipliers_U :: Vector = T[],
+  iter :: Int=-1,
+  elapsed_time :: Float64=Inf,
+  solver_specific :: Dict = Dict{Symbol,Any}()
+) where T
+  if !(status in keys(STATUSES))
+    @error "status $status is not a valid status. Use one of the following: " join(keys(STATUSES), ", ")
+    throw(KeyError(status))
+  end
+  c = NLSCounters()
+  for counter in fieldnames(Counters)
+    setfield!(c.counters, counter, eval(Meta.parse("$counter"))(nlp))
+  end
+  if nlp isa AbstractNLSModel
+    for counter in fieldnames(NLSCounters)
+      counter == :counters && continue
+      setfield!(c, counter, eval(Meta.parse("$counter"))(nlp))
+    end
+  end
+  return OptSolverOutput{T}(status, solution, objective, dual_feas, primal_feas,
+    multipliers, multipliers_L, multipliers_U, iter,
+    c, elapsed_time, solver_specific)
+end

src/output.jl

@@ -0,0 +1,34 @@
+export AbstractSolverOutput
+
+"""
+    AbstractSolverOutput
+
+Base type for output of JSO-compliant solvers.
+An output must have at least the following:
+- `status :: Bool`
+- `solution`
+"""
+abstract type AbstractSolverOutput{T} end
+
+const STATUSES = Dict(
+  :exception      => "unhandled exception",
+  :first_order    => "first-order stationary",
+  :acceptable     => "solved to within acceptable tolerances",
+  :infeasible     => "problem may be infeasible",
+  :max_eval       => "maximum number of function evaluations",
+  :max_iter       => "maximum iteration",
+  :max_time       => "maximum elapsed time",
+  :neg_pred       => "negative predicted reduction",
+  :not_desc       => "not a descent direction",
+  :small_residual => "small residual",
+  :small_step     => "step too small",
+  :stalled        => "stalled",
+  :unbounded      => "objective function may be unbounded from below",
+  :unknown        => "unknown",
+  :user           => "user-requested stop",
+)
+
+function Base.show(io :: IO, output :: AbstractSolverOutput)
+  println(io, "Solver output of type $(typeof(output))")
+  println(io, "Status: $(STATUSES[output.status])")
+end

src/solver.jl

@@ -12,7 +12,7 @@ A solver must have three members:
 abstract type AbstractSolver{T} end
 
 function Base.show(io :: IO, solver :: AbstractSolver)
-    show(io, "Solver $(typeof(solver))")
+  println(io, "Solver $(typeof(solver))")
 end
 
 """
@@ -43,9 +43,4 @@ Each key of `named_tuple` is the name of a parameter, and its value is a NamedTu
 function parameters(::Type{AbstractSolver{T}}) where T end
 
 parameters(::Type{S}) where S <: AbstractSolver = parameters(S{Float64})
-parameters(solver :: AbstractSolver) = parameters(typeof(solver))
-
-# To be removed in the future
-
-include("optsolver.jl")
-# include("linearsolver.jl")
+parameters(solver :: AbstractSolver) = parameters(typeof(solver))

src/stats.jl

@@ -1,23 +1,6 @@
 export AbstractExecutionStats, GenericExecutionStats,
        statsgetfield, statshead, statsline, getStatus, show_statuses
 
-const STATUSES = Dict(
-        :exception      => "unhandled exception",
-        :first_order    => "first-order stationary",
-        :acceptable     => "solved to within acceptable tolerances",
-        :infeasible     => "problem may be infeasible",
-        :max_eval       => "maximum number of function evaluations",
-        :max_iter       => "maximum iteration",
-        :max_time       => "maximum elapsed time",
-        :neg_pred       => "negative predicted reduction",
-        :not_desc       => "not a descent direction",
-        :small_residual => "small residual",
-        :small_step     => "step too small",
-        :stalled        => "stalled",
-        :unbounded      => "objective function may be unbounded from below",
-        :unknown        => "unknown",
-        :user           => "user-requested stop",
-       )
 
 """
     show_statuses()

test/dummy_solver.jl

@@ -1,4 +1,4 @@
-mutable struct DummySolver{T} <: AbstractSolver{T}
+mutable struct DummySolver{T} <: AbstractOptSolver{T}
   initialized :: Bool
   params :: Dict
   workspace
@@ -59,7 +59,7 @@ function SolverCore.solve!(solver::DummySolver{T}, nlp :: AbstractNLPModel;
   x = solver.workspace.x  # Change reference
 
   cx = solver.workspace.cx .= ncon > 0 ? cons(nlp, x) : zeros(T, 0)
-  ct = solver.workspace.ct = zeros(T, ncon)
+  ct = solver.workspace.ct .= zero(T)
   grad!(nlp, x, solver.workspace.gx)
   gx = solver.workspace.gx
   Jx = ncon > 0 ? jac(nlp, x) : zeros(T, 0, nvar)
@@ -133,8 +133,9 @@ function SolverCore.solve!(solver::DummySolver{T}, nlp :: AbstractNLPModel;
     :max_eval
   end
 
-  return GenericExecutionStats(
+  return OptSolverOutput(
     status,
+    x,
     nlp,
     objective=fx,
     dual_feas=norm(dual),
@@ -143,7 +144,6 @@ function SolverCore.solve!(solver::DummySolver{T}, nlp :: AbstractNLPModel;
     multipliers_L=zeros(T, nvar),
     multipliers_U=zeros(T, nvar),
     elapsed_time=elapsed_time,
-    solution=x,
     iter=iter
   )
 end

test/test_logging.jl

@@ -9,8 +9,8 @@ function test_logging()
 
   with_logger(ConsoleLogger()) do
     @info "Testing dummy solver with logger"
-    solver = DummySolver()
-    solver(nlps[1], max_eval=20)
+    solver = DummySolver(nlps[1].meta)
+    solve!(solver, nlps[1], max_eval=20)
     reset!.(nlps)
   end
 end

test/test_stats.jl

@@ -1,12 +1,11 @@
 function test_stats()
-  show_statuses()
   nlp = ADNLPModel(x->dot(x,x), zeros(2))
-  stats = GenericExecutionStats(
+  stats = OptSolverOutput(
     :first_order,
+    ones(100),
     nlp,
     objective=1.0,
     dual_feas=1e-12,
-    solution=ones(100),
     iter=10,
     solver_specific=Dict(:matvec=>10,
       :dot=>25,
@@ -17,39 +16,23 @@ function test_stats()
     )
   )
 
-  show(stats)
-  print(stats)
-  println(stats)
-  open("teststats.out", "w") do f
-    println(f, stats)
-  end
-
-  println(stats, showvec=(io,x)->print(io,x))
-  open("teststats.out", "a") do f
-    println(f, stats, showvec=(io,x)->print(io,x))
-  end
-
-  line = [:status, :neval_obj, :objective, :iter]
-  for field in line
-    value = statsgetfield(stats, field)
-    println("$field -> $value")
-  end
-  println(statshead(line))
-  println(statsline(stats, line))
+  io = IOBuffer()
+  show(io, stats)
+  @test String(take!(io)) == "Solver output of type OptSolverOutput{Float64}\nStatus: first-order stationary\n"
 
   @testset "Testing inference" begin
     for T in (Float16, Float32, Float64, BigFloat)
       nlp = ADNLPModel(x->dot(x, x), ones(T, 2))
 
-      stats = GenericExecutionStats(:first_order, nlp)
+      stats = OptSolverOutput(:first_order, nlp.meta.x0, nlp)
       @test stats.status == :first_order
       @test typeof(stats.objective) == T
       @test typeof(stats.dual_feas) == T
       @test typeof(stats.primal_feas) == T
 
       nlp = ADNLPModel(x->dot(x, x), ones(T, 2), x->[sum(x)-1], [0.0], [0.0])
 
-      stats = GenericExecutionStats(:first_order, nlp)
+      stats = OptSolverOutput(:first_order, nlp.meta.x0, nlp)
       @test stats.status == :first_order
       @test typeof(stats.objective) == T
       @test typeof(stats.dual_feas) == T
@@ -58,17 +41,16 @@ function test_stats()
   end
 
   @testset "Test throws" begin
-    @test_throws Exception GenericExecutionStats(:bad, nlp)
-    @test_throws Exception GenericExecutionStats(:unkwown, nlp, bad=true)
+    @test_throws Exception OptSolverOutput(:bad, nlp)
+    @test_throws Exception OptSolverOutput(:unkwown, nlp, bad=true)
   end
 
   @testset "Testing Dummy Solver with multi-precision" begin
-    solver = DummySolver()
     for T in (Float16, Float32, Float64, BigFloat)
       nlp = ADNLPModel(x->dot(x, x), ones(T, 2))
 
-      with_logger(NullLogger()) do
-        stats = solver(nlp)
+      stats, solver = with_logger(NullLogger()) do
+        DummySolver(nlp)
       end
       @test typeof(stats.objective) == T
       @test typeof(stats.dual_feas) == T
@@ -80,8 +62,8 @@ function test_stats()
 
       nlp = ADNLPModel(x->dot(x, x), ones(T, 2), x->[sum(x)-1], [0.0], [0.0])
 
-      with_logger(NullLogger()) do
-        stats = solver(nlp)
+      stats, solver = with_logger(NullLogger()) do
+        DummySolver(nlp)
       end
       @test typeof(stats.objective) == T
       @test typeof(stats.dual_feas) == T