adjust tests

Author: dpo

src/stats.jl

@@ -63,7 +63,10 @@ It contains the following fields:
 - `elapsed_time`: The elapsed time computed by the solver (default: `Inf`);
 - `solver_specific::Dict{Symbol,Any}`: A solver specific dictionary.
 
-The constructor tries to preallocate storage for the fields above.
+The constructor preallocates storage for the fields above.
+Special storage may be used for `multipliers_L` and `multipliers_U` by passing them to the constructor.
+For instance, if a problem has few bound constraints, those multipliers could be held in sparse vectors.
+
 The following fields indicate whether the information above has been updated and is reliable:
 
 - `solution_reliable`
@@ -84,7 +87,7 @@ All other variables can be input as keyword arguments.
 
 Notice that `GenericExecutionStats` does not compute anything, it simply stores.
 """
-mutable struct GenericExecutionStats{T, S, V} <: AbstractExecutionStats
+mutable struct GenericExecutionStats{T, S, V, Tsp} <: AbstractExecutionStats
   status::Symbol
   solution_reliable::Bool
   solution::S # x
@@ -102,7 +105,7 @@ mutable struct GenericExecutionStats{T, S, V} <: AbstractExecutionStats
   time_reliable::Bool
   elapsed_time::Float64
   solver_specific_reliable::Bool
-  solver_specific::Dict{Symbol, Any}
+  solver_specific::Dict{Symbol, Tsp}
 end
 
 function GenericExecutionStats(
@@ -111,10 +114,10 @@ function GenericExecutionStats(
   solution::S = similar(nlp.meta.x0),
   objective::T = T(Inf),
   dual_feas::T = T(Inf),
-  primal_feas::T = unconstrained(nlp) || bound_constrained(nlp) ? zero(T) : T(Inf),
+  primal_feas::T = unconstrained(nlp) ? zero(T) : T(Inf),
   multipliers::S = similar(nlp.meta.y0),
-  multipliers_L::V = similar(nlp.meta.y0, bound_constrained(nlp) ? nlp.meta.nvar : 0),
-  multipliers_U::V = similar(nlp.meta.y0, bound_constrained(nlp) ? nlp.meta.nvar : 0),
+  multipliers_L::V = similar(nlp.meta.y0, has_bounds(nlp) ? nlp.meta.nvar : 0),
+  multipliers_U::V = similar(nlp.meta.y0, has_bounds(nlp) ? nlp.meta.nvar : 0),
   iter::Int = -1,
   elapsed_time::Real = Inf,
   solver_specific::Dict{Symbol, Tsp} = Dict{Symbol, Any}(),
@@ -126,7 +129,7 @@ function GenericExecutionStats(
     )
     throw(KeyError(status))
   end
-  return GenericExecutionStats{T, S, V}(
+  return GenericExecutionStats{T, S, V, Tsp}(
     status,
     false,
     solution,

test/dummy_solver.jl

@@ -61,17 +61,13 @@ function dummy_solver(
     :max_eval
   end
 
-  return GenericExecutionStats(
-    :unknown,
-    nlp,
-    objective = fx,
-    dual_feas = norm(dual),
-    primal_feas = norm(cx),
-    multipliers = y,
-    multipliers_L = zeros(T, nvar),
-    multipliers_U = zeros(T, nvar),
-    elapsed_time = elapsed_time,
-    solution = x,
-    iter = iter,
-  )
+  stats = GenericExecutionStats(status, nlp)
+  set_objective!(stats, fx)
+  set_residuals!(stats, norm(cx), norm(dual))
+  z = has_bounds(nlp) ? zeros(T, nvar) : zeros(T, 0)
+  set_multipliers!(stats, y, z, z)
+  set_time!(stats, elapsed_time)
+  set_solution!(stats, x)
+  set_iter!(stats, iter)
+  return stats
 end

test/test_stats.jl

@@ -1,22 +1,16 @@
 function test_stats()
   show_statuses()
   nlp = ADNLPModel(x -> dot(x, x), zeros(2))
-  stats = GenericExecutionStats(
-    :first_order,
-    nlp,
-    objective = 1.0,
-    dual_feas = 1e-12,
-    solution = ones(100),
-    iter = 10,
-    solver_specific = Dict(
-      :matvec => 10,
-      :dot => 25,
-      :empty_vec => [],
-      :small_vec => [2.0; 3.0],
-      :axpy => 20,
-      :ray => -1 ./ (1:100),
-    ),
-  )
+  stats = GenericExecutionStats(:first_order, nlp)
+  set_objective!(stats, 1.0)
+  set_residuals!(stats, 0.0, 1e-12)
+  set_solution!(stats, ones(2))
+  set_iter!(stats, 10)
+  set_solver_specific!(stats, :matvec, 10)
+  set_solver_specific!(stats, :dot, 25)
+  set_solver_specific!(stats, :empty_vec, [])
+  set_solver_specific!(stats, :axpy, 20)
+  set_solver_specific!(stats, :ray, -1 ./ (1:100))
 
   show(stats)
   print(stats)