Solution Summary Addition

docs/src/develop/extensions.md

@@ -770,6 +770,7 @@ extended using the following steps:
     - [`JuMP.backend`](@ref JuMP.backend(::AbstractTransformationBackend))
     - [`JuMP.unsafe_backend`](@ref JuMP.unsafe_backend(::AbstractTransformationBackend))
     - [`JuMP.variable_ref_type`](@ref JuMP.variable_ref_type(::AbstractTransformationBackend))
+    - [`JuMP.solution_summary`](@ref JuMP.solution_summary(::AbstractTransformationBackend))
 6. Extend the following, if possible (also enables result queries for `JuMPBackend`s):
     - [`transformation_variable`](@ref transformation_variable(::GeneralVariableRef, ::AbstractTransformationBackend))
     - [`transformation_expression`](@ref transformation_expression(::Any, ::AbstractTransformationBackend))

docs/src/manual/backend.md

@@ -66,6 +66,7 @@ JuMP.print_bridge_graph(::IO, ::AbstractTransformationBackend)
 JuMP.variable_ref_type(::AbstractTransformationBackend)
 JuMP.backend(::AbstractTransformationBackend)
 JuMP.unsafe_backend(::AbstractTransformationBackend)
+JuMP.solution_summary(::AbstractTransformationBackend)
 transformation_variable(::GeneralVariableRef, ::AbstractTransformationBackend)
 transformation_expression(::Any, ::AbstractTransformationBackend)
 transformation_constraint(::InfOptConstraintRef, ::AbstractTransformationBackend)

src/backends.jl

@@ -191,6 +191,22 @@ function JuMP.get_attribute(
           "of type `$(typeof(backend))` with attribute `$attr`.")
 end
 
+"""
+    JuMP.solution_summary(backend::AbstractTransformationBackend)
+
+Extension point for implementing `JuMP.solution_summary` for an 
+`AbstractTransformationBackend`. This is not intended as a method to general 
+users, but rather as an extension point for those making a new backend type.
+"""
+function JuMP.solution_summary(
+    backend::AbstractTransformationBackend;
+    result::Int = 1,
+    verbose::Bool = false,
+    )
+    error("`JuMP.solution_summary` not implemented for transformation backends " * 
+          "of type `$(typeof(backend))`.")
+end
+
 """
     JuMP.get_attribute(model::InfiniteModel, attr)
 
@@ -545,6 +561,25 @@ function JuMP.variable_ref_type(backend::JuMPBackend)
     return JuMP.variable_ref_type(backend.model)
 end
 
+"""
+    JuMP.solution_summary(backend::JuMPBackend)
+
+Implement [`JuMP.solution_summary`](https://jump.dev/JuMP.jl/v1/api/JuMP/#JuMP.solution_summary)
+for transformation backends. If applicable, this should be extended for 
+new backend types. No extension is needed for [`JuMPBackend`](@ref)s.
+"""
+# Define for JuMPBackend
+function JuMP.solution_summary(
+    backend::JuMPBackend;
+    result::Int = 1,
+    verbose::Bool = false,
+    )
+    if verbose
+        @warn "`verbose = true` is not currently supported."
+    end
+    return JuMP.solution_summary(backend.model; result = result, verbose = verbose)
+end
+
 # Single argument methods that don't rely on `[get/set]_attribute`
 for func in (:bridge_constraints, :backend, :mode, :unsafe_backend, 
              :compute_conflict!, :copy_conflict)

src/results.jl

@@ -162,6 +162,135 @@ function JuMP.is_solved_and_feasible(
     return ret
 end
 
+"""
+JuMP.solution_summary(
+        model::InfiniteModel;
+        result::Int = 1,
+        verbose::Bool = false,
+        )
+
+Extend [`JuMP.solution_summary`](@ref) to return the summary of the 
+optimization solution. This method utilizes the solution_summary backend and prints solution information and
+termination status. 
+- `result::Int = 1`: indexes the solution result to be queried.
+- `verbose::Bool = false`: If `true`, throws a warning as it is not currently supported.
+
+Extend [`JuMP.solution_summary`](https://jump.dev/JuMP.jl/v1/api/JuMP/#solution_summary))
+for `model`. See the JuMP docs details. 
+
+**Example**
+```julia-repl
+julia> model = Model(Ipopt.Optimizer);
+
+julia> solution_summary(model)
+
+Infinite model showing results with: A TranscriptionBackend that uses a
+A JuMP Model
+├ solver: HiGHS
+├ objective_sense: MAX_SENSE
+│ └ objective_function_type: AffExpr
+├ num_variables: 17
+├ num_constraints: 18
+│ ├ AffExpr in MOI.LessThan{Float64}: 1
+│ └ VariableRef in MOI.ZeroOne: 17
+└ Names registered in the model: none
+solution_summary(; result = 1, verbose = false)
+├ solver_name          : HiGHS
+├ Termination
+│ ├ termination_status : OPTIMAL
+│ ├ result_count       : 1
+│ ├ raw_status         : kHighsModelStatusOptimal
+│ └ objective_bound    : 9.50100e+02
+├ Solution (result = 1)
+│ ├ primal_status        : FEASIBLE_POINT
+│ ├ dual_status          : NO_SOLUTION
+│ ├ objective_value      : 9.50100e+02
+│ ├ dual_objective_value : NaN
+│ └ relative_gap         : 0.00000e+00
+└ Work counters
+  ├ solve_time (sec)   : 6.86052e-02
+  ├ simplex_iterations : 10
+  ├ barrier_iterations : -1
+  └ node_count         : 1
+```
+"""
+
+function JuMP.solution_summary(
+    model::InfiniteModel;
+    result::Int = 1,
+    verbose::Bool = false,
+) 
+    backend = model.backend
+    println("Solution summary of infinite model with a ", typeof(model.backend) ," transformation backend:")
+    return JuMP.solution_summary(backend; result=result, verbose=verbose)
+
+end
+
+"""
+JuMP.assert_is_solved_and_feasible(
+        model::InfiniteModel;
+        result::Int = 1,
+        kwargs...,
+        )
+
+Extend [`JuMP.is_solved_and_feasible`](@ref) to return whether or not the model completed optimization and has found a
+feasible solution. 
+- `result::Int = 1`: indexes the solution result to be queried.
+The keyword arguments `kwargs` depend on the transformation backend that is 
+being used.
+If the return is false, assert_is_solved_and_feasible errors with an error message, along with a solution_summary to
+help in debugging.
+
+Extend [`JuMP.assert_is_solved_and_feasible`](https://jump.dev/JuMP.jl/v1/api/JuMP/#assert_is_solved_and_feasible))
+for `model`. See the JuMP docs details.
+For new transformation backend types, this relies on `JuMP.is_solved_and_feasible`.
+
+**Example**
+```julia-repl
+julia> model = Model(Ipopt.Optimizer);
+
+julia> assert_is_solved_and_feasible(model)
+
+ERROR: The model was not solved correctly. Here is the output of `solution_summary` to help debug why this happened:
+
+solution_summary(; result = 1, verbose = false)
+├ solver_name          : HiGHS
+├ Termination
+│ ├ termination_status : OPTIMAL
+│ ├ result_count       : 1
+│ ├ raw_status         : kHighsModelStatusOptimal
+│ └ objective_bound    : -0.00000e+00
+├ Solution (result = 1)
+│ ├ primal_status        : FEASIBLE_POINT
+│ ├ dual_status          : NO_SOLUTION
+│ ├ objective_value      : 0.00000e+00
+│ ├ dual_objective_value : NaN
+│ └ relative_gap         : 0.00000e+00
+└ Work counters
+  ├ solve_time (sec)   : 1.78261e-02
+  ├ simplex_iterations : 0
+  ├ barrier_iterations : -1
+  └ node_count         : 0
+```
+"""
+function JuMP.assert_is_solved_and_feasible(
+    model::InfiniteModel;
+    result::Int = 1,
+    kwargs...,
+)
+    if !JuMP.is_solved_and_feasible(model; result, kwargs...)
+        error(
+            string(
+                "The model was not solved correctly. Here is the output of ",
+                "`solution_summary` to help debug why this happened:\n\n",
+                JuMP.solution_summary(model; result),
+                "\n",
+            ),
+        )
+    end
+    return
+end
+
 ################################################################################
 #                                 VALUE QUERIES
 ################################################################################

test/backend_setup.jl

@@ -56,6 +56,10 @@
         @test set_attribute(m, "something", 42) isa Nothing
         @test get_attribute(m, "something") == 42
     end
+    # JuMP.solution_summary
+    @testset "JuMP.solution_summary" begin
+        @test_throws ErrorException solution_summary(TestBackend())
+    end
     # Base.empty!
     @testset "Base.empty!" begin
         @test empty!(JuMPBackend{TestJuMPTag}(Model(), [42])).data == []
@@ -142,6 +146,13 @@ end
         @test sprint(print_bridge_graph, m) == expected
         stdout_test(print_bridge_graph, expected, m)
     end
+    @testset "JuMP.solution_summary" begin
+        SolutionSummary = typeof(JuMP.solution_summary(bmodel))
+        @test solution_summary(jump_backend) isa SolutionSummary
+        @test_throws ErrorException solution_summary(TestBackend())
+        str = "`verbose = true` is not currently supported."
+        @test_logs (:warn, str) match_mode = :any solution_summary(jump_backend, verbose = true)
+    end
     @testset "JuMP.variable_ref_type" begin
         @test variable_ref_type(jump_backend) == JuMP.VariableRef
         @test variable_ref_type(m) == GeneralVariableRef

test/extensions/backend.jl

@@ -157,7 +157,8 @@ end
 # To the extend desired, extend any or all of the JuMP API below
 # Not needed for `JuMPBackend`s
 for func in (:bridge_constraints, :backend, :mode, :unsafe_backend,
-             :compute_conflict!, :copy_conflict, :variable_ref_type)
+             :compute_conflict!, :copy_conflict, :variable_ref_type,
+             :solution_summary)
     @eval begin
         # EXTEND FUNCTION AS APPROPRIATE
         function JuMP.$func(backend::NewReformBackend)

test/results.jl

@@ -55,6 +55,17 @@
         @test !is_solved_and_feasible(test_model)
         @test is_solved_and_feasible(test_model, allow_almost = true, dual = true)
     end
+    # test solution_summary
+    @testset "JuMP.solution_summary" begin
+        SolutionSummary = typeof(JuMP.solution_summary(tb))
+        @test solution_summary(m) isa SolutionSummary
+        @test_throws ErrorException solution_summary(test_model)
+    end
+    # test assert_is_solved_and_feasible
+    @testset "JuMP.assert_is_solved_and_feasible" begin
+        @test assert_is_solved_and_feasible(m) === nothing
+        @test_throws ErrorException assert_is_solved_and_feasible(test_model)
+    end
     # test primal_status
     @testset "JuMP.primal_status" begin
         @test primal_status(m) == MOI.FEASIBLE_POINT