Update

Author: odow

src/MultiObjectiveAlgorithms.jl

@@ -667,53 +667,6 @@ function optimize_inner!(model::Optimizer)
     return
 end
 
-"""
-    _log_solution(model::Optimizer, variables::Vector{MOI.VariableIndex})
-
-Log the solution. We don't have a pre-computed point, so compute one from the
-variable values.
-"""
-function _log_solution(model::Optimizer, variables::Vector{MOI.VariableIndex})
-    if !model.silent
-        _, Y = _compute_point(model, variables, model.f)
-        _log_solution(model, Y)
-    end
-    return
-end
-
-"""
-    _log_solution(model::Optimizer, variables::Vector{MOI.VariableIndex})
-
-Log the solution. We have a pre-computed point.
-"""
-function _log_solution(model::Optimizer, Y)
-    if !model.silent
-        print(_format(model.subproblem_count), "  ")
-        for y in Y
-            print(" ", _format(y))
-        end
-        println(" ", _format(time() - model.start_time))
-    end
-    return
-end
-"""
-    _log_solution(model::Optimizer, msg::String)
-
-Log the solution. Assume the subproblem failed to solve.
-"""
-function _log_solution(model::Optimizer, msg::String)
-    if !model.silent
-        print(_format(model.subproblem_count), "  ")
-        print(rpad(msg, 13 * MOI.output_dimension(model.f)))
-        println(" ", _format(time() - model.start_time))
-    end
-    return
-end
-
-_format(x::Int) = Printf.@sprintf("%5d", x)
-_format(x::Float64) = Printf.@sprintf("% .5e", x)
-_format(::Nothing) = "            "
-
 function _compute_ideal_point(model::Optimizer)
     for (i, f) in enumerate(MOI.Utilities.eachscalar(model.f))
         if _check_premature_termination(model) !== nothing
@@ -822,6 +775,82 @@ function MOI.optimize!(model::Optimizer)
     return
 end
 
+function _print_header(io::IO, model::Optimizer)
+    rule = "-"^(7 + 13 * (MOI.output_dimension(model.f) + 1))
+    println(io, rule)
+    println(io, "        MultiObjectiveAlgorithms.jl")
+    println(io, rule)
+    println(
+        io,
+        "Algorithm: ",
+        replace(
+            string(typeof(model.algorithm)),
+            "MultiObjectiveAlgorithms." => "",
+        ),
+    )
+    println(io, rule)
+    print(io, "solve #")
+    for i in 1:MOI.output_dimension(model.f)
+        print(io, lpad("Obj. $i  ", 13))
+    end
+    println(io, "     Time    ")
+    println(io, rule)
+    return
+end
+
+function _print_footer(io::IO, model::Optimizer)
+    rule = "-"^(7 + 13 * (MOI.output_dimension(model.f) + 1))
+    println(io, rule)
+    println(io, "TerminationStatus: ", model.termination_status)
+    println(io, "ResultCount: ", length(model.solutions))
+    println(io, rule)
+    return
+end
+
+"""
+    _log_subproblem_solve(model::Optimizer, variables::Vector{MOI.VariableIndex})
+
+Log the solution. We don't have a pre-computed point, so compute one from the
+variable values.
+"""
+function _log_subproblem_solve(model::Optimizer, arg)
+    if !model.silent
+        _log_subproblem_inner(model, arg)
+    end
+    return
+end
+
+# Variables; compute the associated Y
+function _log_subproblem_inner(model::Optimizer, x::Vector{MOI.VariableIndex})
+    _, Y = _compute_point(model, x, model.f)
+    _log_subproblem_solve(model, Y)
+    return
+end
+
+# We have a pre-computed point.
+function _log_subproblem_inner(model::Optimizer, Y::Vector)
+    print(_format(model.subproblem_count), "  ")
+    for y in Y
+        print(" ", _format(y))
+    end
+    println(" ", _format(time() - model.start_time))
+    return
+end
+
+# Assume the subproblem failed to solve.
+function _log_subproblem_inner(model::Optimizer, msg::String)
+    print(_format(model.subproblem_count), "  ")
+    print(rpad(msg, 13 * MOI.output_dimension(model.f)))
+    println(" ", _format(time() - model.start_time))
+    return
+end
+
+_format(x::Int) = Printf.@sprintf("%5d", x)
+
+_format(x::Float64) = Printf.@sprintf("% .5e", x)
+
+_format(::Nothing) = "            "
+
 function _optimize!(model::Optimizer)
     model.start_time = time()
     empty!(model.solutions)
@@ -833,18 +862,7 @@ function _optimize!(model::Optimizer)
         return
     end
     if !model.silent
-        rule = "-"^(7 + 13 * (MOI.output_dimension(model.f) + 1))
-        println(rule)
-        println("        MultiObjectiveAlgorithms.jl")
-        println(rule)
-        println("Algorithm: ", _describe(model.algorithm))
-        println(rule)
-        print("solve #")
-        for i in 1:MOI.output_dimension(model.f)
-            print(lpad("Obj. $i  ", 13))
-        end
-        println("     Time    ")
-        println(rule)
+        _print_header(stdout, model)
     end
     # We need to clear the ideal point prior to starting the solve. Algorithms
     # may update this during the solve, otherwise we will update it at the end.
@@ -857,10 +875,7 @@ function _optimize!(model::Optimizer)
         _sort!(model.solutions, MOI.get(model, MOI.ObjectiveSense()))
     end
     if !model.silent
-        println(rule)
-        println("Terminating with status: ", status)
-        println("Number of non-dominated solutions: ", length(model.solutions))
-        println(rule)
+        _print_footer(stdout, model)
     end
     if MOI.get(model, ComputeIdealPoint())
         _compute_ideal_point(model)

src/algorithms/Chalmet.jl

@@ -25,8 +25,6 @@ This algorithm is restricted to problems with:
 """
 struct Chalmet <: AbstractAlgorithm end
 
-_describe(::Chalmet) = "Chalmet()"
-
 function _solve_constrained_model(
     model::Optimizer,
     ::Chalmet,
@@ -40,13 +38,13 @@ function _solve_constrained_model(
     optimize_inner!(model)
     status = MOI.get(model.inner, MOI.TerminationStatus())
     if !_is_scalar_status_optimal(status)
-        _log_solution(model, "subproblem not optimal")
+        _log_subproblem_solve(model, "subproblem not optimal")
         MOI.delete.(model, c)
         return status, nothing
     end
     variables = MOI.get(model.inner, MOI.ListOfVariableIndices())
     X, Y = _compute_point(model, variables, model.f)
-    _log_solution(model, Y)
+    _log_subproblem_solve(model, Y)
     MOI.delete.(model, c)
     return status, SolutionPoint(X, Y)
 end
@@ -69,7 +67,7 @@ function minimize_multiobjective!(algorithm::Chalmet, model::Optimizer)
         return status, solutions
     end
     _, y1[2] = _compute_point(model, variables, f2)
-    _log_solution(model, variables)
+    _log_subproblem_solve(model, variables)
     MOI.set(model.inner, MOI.ObjectiveFunction{typeof(f1)}(), f1)
     y1_constraint = MOI.Utilities.normalize_and_add_constraint(
         model.inner,
@@ -82,7 +80,7 @@ function minimize_multiobjective!(algorithm::Chalmet, model::Optimizer)
         return status, solutions
     end
     x1, y1[1] = _compute_point(model, variables, f1)
-    _log_solution(model, y1)
+    _log_subproblem_solve(model, y1)
     MOI.delete(model.inner, y1_constraint)
     push!(solutions, SolutionPoint(x1, y1))
     MOI.set(model.inner, MOI.ObjectiveFunction{typeof(f1)}(), f1)
@@ -92,7 +90,7 @@ function minimize_multiobjective!(algorithm::Chalmet, model::Optimizer)
         return status, solutions
     end
     _, y2[1] = _compute_point(model, variables, f1)
-    _log_solution(model, variables)
+    _log_subproblem_solve(model, variables)
     if y2[1] ≈ solutions[1].y[1]
         return MOI.OPTIMAL, solutions
     end
@@ -108,7 +106,7 @@ function minimize_multiobjective!(algorithm::Chalmet, model::Optimizer)
         return status, solutions
     end
     x2, y2[2] = _compute_point(model, variables, f2)
-    _log_solution(model, y2)
+    _log_subproblem_solve(model, y2)
     MOI.delete(model.inner, y2_constraint)
     push!(solutions, SolutionPoint(x2, y2))
     push!(Q, (1, 2))

src/algorithms/Dichotomy.jl

@@ -30,8 +30,6 @@ mutable struct Dichotomy <: AbstractAlgorithm
     Dichotomy() = new(nothing)
 end
 
-_describe(::Dichotomy) = "Dichotomy()"
-
 """
     NISE()
 
@@ -76,7 +74,7 @@ function _solve_weighted_sum(
     end
     variables = MOI.get(model.inner, MOI.ListOfVariableIndices())
     X, Y = _compute_point(model, variables, model.f)
-    _log_solution(model, Y)
+    _log_subproblem_solve(model, Y)
     return status, SolutionPoint(X, Y)
 end
 

src/algorithms/DominguezRios.jl

@@ -26,8 +26,6 @@ This algorithm is restricted to problems with:
 """
 struct DominguezRios <: AbstractAlgorithm end
 
-_describe(::DominguezRios) = "DominguezRios()"
-
 mutable struct _DominguezRiosBox
     l::Vector{Float64}
     u::Vector{Float64}
@@ -66,8 +64,8 @@ function _p_partition(
     ẑ = max.(z, B.l)
     ret = _DominguezRiosBox[]
     for i in 1:length(z)
-        new_l = vcat(B.l[1:i], ẑ[i+1:end])
-        new_u = vcat(B.u[1:i-1], ẑ[i], B.u[i+1:end])
+        new_l = vcat(B.l[1:i], ẑ[(i+1):end])
+        new_u = vcat(B.u[1:(i-1)], ẑ[i], B.u[(i+1):end])
         new_priority = _reduced_scaled_priority(new_l, new_u, i, ẑ, yI, yN)
         push!(ret, _DominguezRiosBox(new_l, new_u, new_priority))
     end
@@ -167,7 +165,7 @@ function minimize_multiobjective!(algorithm::DominguezRios, model::Optimizer)
             return status, nothing
         end
         _, Y = _compute_point(model, variables, f_i)
-        _log_solution(model, variables)
+        _log_subproblem_solve(model, variables)
         yI[i] = Y
         model.ideal_point[i] = Y
         MOI.set(model.inner, MOI.ObjectiveSense(), MOI.MAX_SENSE)
@@ -178,7 +176,7 @@ function minimize_multiobjective!(algorithm::DominguezRios, model::Optimizer)
             return status, nothing
         end
         _, Y = _compute_point(model, variables, f_i)
-        _log_solution(model, variables)
+        _log_subproblem_solve(model, variables)
         yN[i] = Y + 1
     end
     MOI.set(model.inner, MOI.ObjectiveSense(), MOI.MIN_SENSE)
@@ -219,7 +217,7 @@ function minimize_multiobjective!(algorithm::DominguezRios, model::Optimizer)
         optimize_inner!(model)
         if _is_scalar_status_optimal(model)
             X, Y = _compute_point(model, variables, model.f)
-            _log_solution(model, Y)
+            _log_subproblem_solve(model, Y)
             obj = MOI.get(model.inner, MOI.ObjectiveValue())
             # We need to undo the scaling of the scalar objective. There's no
             # need to unscale `Y` because we have evaluated this explicitly from
@@ -237,7 +235,7 @@ function minimize_multiobjective!(algorithm::DominguezRios, model::Optimizer)
             # fail and return something like OTHER_ERROR (e.g., because the
             # numerics are challenging). Rather than error completely, let's
             # just skip this box.
-            _log_solution(model, "subproblem not optimal")
+            _log_subproblem_solve(model, "subproblem not optimal")
             deleteat!(L[k], i)
         end
         MOI.delete.(model.inner, constraints)

src/algorithms/EpsilonConstraint.jl

@@ -36,8 +36,6 @@ mutable struct EpsilonConstraint <: AbstractAlgorithm
     EpsilonConstraint() = new(nothing, nothing)
 end
 
-_describe(::EpsilonConstraint) = "EpsilonConstraint()"
-
 MOI.supports(::EpsilonConstraint, ::SolutionLimit) = true
 
 function MOI.set(alg::EpsilonConstraint, ::SolutionLimit, value)
@@ -128,7 +126,7 @@ function minimize_multiobjective!(
             break
         end
         X, Y = _compute_point(model, variables, model.f)
-        _log_solution(model, Y)
+        _log_subproblem_solve(model, Y)
         if isempty(solutions) || !(Y ≈ solutions[end].y)
             push!(solutions, SolutionPoint(X, Y))
         end

src/algorithms/Hierarchical.jl

@@ -37,8 +37,6 @@ mutable struct Hierarchical <: AbstractAlgorithm
     Hierarchical() = new(Int[], Float64[], Float64[])
 end
 
-_describe(::Hierarchical) = "Hierarchical()"
-
 MOI.supports(::Hierarchical, ::ObjectivePriority) = true
 
 function MOI.get(alg::Hierarchical, attr::ObjectivePriority)
@@ -116,7 +114,7 @@ function minimize_multiobjective!(algorithm::Hierarchical, model::Optimizer)
         end
         if !model.silent
             X, Y = _compute_point(model, variables, model.f)
-            _log_solution(model, Y)
+            _log_subproblem_solve(model, Y)
         end
         # Add tolerance constraints
         X, Y = _compute_point(model, variables, new_vector_f)
@@ -128,7 +126,7 @@ function minimize_multiobjective!(algorithm::Hierarchical, model::Optimizer)
         end
     end
     X, Y = _compute_point(model, variables, model.f)
-    _log_solution(model, Y)
+    _log_subproblem_solve(model, Y)
     # Remove tolerance constraints
     for c in constraints
         MOI.delete(model, c)