Test ConstraintDual for bridges

Author: blegat

src/Bridges/Bridges.jl

@@ -293,12 +293,57 @@ function runtests(args...; kwargs...)
     return
 end
 
+# A good way to check that the linear mapping implemented in the setter of
+# `ConstraintDual` is the inverse-adjoint of the mapping implemented in the
+# constraint transformation is to check `get_fallback` for `DualObjectiveValue`.
+# Indeed, it will check that the inner product between the constraint constants
+# and the dual is the same before and after the bridge transformations.
+# For this test to be enabled, the bridge should implement `supports`
+# for `ConstraintDual` and implement `MOI.set` for `ConstraintDual`.
+# Typically, this would be achieved using
+# `Union{ConstraintDual,ConstraintDualStart}` for `MOI.get`, `MOI.set` and
+# `MOI.supports`
+function _test_dual(
+    Bridge::Type{<:AbstractBridge},
+    input_fn::Function;
+    dual,
+    model_eltype,
+)
+    inner = MOI.Utilities.MockOptimizer(MOI.Utilities.Model{model_eltype}())
+    model = _bridged_model(Bridge{model_eltype}, inner)
+    input_fn(model)
+    final_touch(model)
+    # Should be able to call final_touch multiple times.
+    final_touch(model)
+    # If the bridges does not support `ConstraintDualStart`, it probably won't
+    # support `ConstraintDual` so we skip these tests
+    list_of_constraints = MOI.get(model, MOI.ListOfConstraintTypesPresent())
+    attr = MOI.ConstraintDual()
+    for (F, S) in list_of_constraints
+        Test.@test MOI.supports(model, attr, MOI.ConstraintIndex{F,S})
+        if !MOI.supports(model, attr, MOI.ConstraintIndex{F,S})
+            # We need all duals for `DualObjectiveValue` fallback
+            # TODO except the ones with no constants, we could ignore them
+            return
+        end
+        for ci in MOI.get(model, MOI.ListOfConstraintIndices{F,S}())
+            set = MOI.get(model, MOI.ConstraintSet(), ci)
+            MOI.set(model, MOI.ConstraintDual(), ci, _fake_start(dual, set))
+        end
+    end
+    model_dual = MOI.Utilities.get_fallback(model, MOI.DualObjectiveValue(), model_eltype)
+    inner_dual = MOI.Utilities.get_fallback(inner, MOI.DualObjectiveValue(), model_eltype)
+    # Need `atol` in case one of them is zero and the other one almost zero
+    Test.@test model_dual ≈ inner_dual atol = 1e-6
+end
+
 function _runtests(
     Bridge::Type{<:AbstractBridge},
     input_fn::Function,
     output_fn::Function;
     variable_start = 1.2,
     constraint_start = 1.2,
+    dual = constraint_start,
     eltype = Float64,
     model_eltype = eltype,
     print_inner_model::Bool = false,
@@ -403,6 +448,11 @@ function _runtests(
     Test.@testset "Test delete" begin                                           # COV_EXCL_LINE
         _test_delete(Bridge, model, inner)
     end
+    if !isnothing(dual)
+        Test.@testset "Test ConstraintDual" begin
+            _test_dual(Bridge, input_fn; dual, model_eltype)
+        end
+    end
     return
 end
 

src/Bridges/Constraint/bridges/SplitHyperRectangleBridge.jl

@@ -174,7 +174,7 @@ end
 
 function MOI.supports(
     model::MOI.ModelLike,
-    attr::Union{MOI.ConstraintPrimalStart,MOI.ConstraintDualStart},
+    attr::Union{MOI.ConstraintPrimalStart,MOI.ConstraintDualStart,MOI.ConstraintDual},
     ::Type{<:SplitHyperRectangleBridge{T,G}},
 ) where {T,G}
     return MOI.supports(model, attr, MOI.ConstraintIndex{G,MOI.Nonnegatives})
@@ -222,7 +222,7 @@ end
 
 function MOI.set(
     model::MOI.ModelLike,
-    attr::MOI.ConstraintDualStart,
+    attr::Union{MOI.ConstraintDualStart,MOI.ConstraintDual},
     bridge::SplitHyperRectangleBridge{T},
     values::AbstractVector{T},
 ) where {T}

src/Utilities/results.jl

@@ -119,14 +119,26 @@ function _dual_objective_value(
     set = MOI.get(model, MOI.ConstraintSet(), ci)
     dual = MOI.get(model, MOI.ConstraintDual(result_index), ci)
     constant = map(eachindex(func_constant)) do i
-        return func_constant[i] - if dual[i] < zero(dual[i])
-            # The dual is negative so it is in the dual of the MOI.LessThan cone
-            # hence the upper bound of the Interval set is tight
-            set.upper[i]
+        constant = func_constant[i]
+        if isfinite(set.upper[i])
+            if isfinite(set.lower[i])
+                if dual[i] < zero(dual[i])
+                    # The dual is negative so it is in the dual of the MOI.LessThan cone
+                    # hence the upper bound of the Interval set is tight
+                    constant -= set.upper[i]
+                else
+                    # the lower bound is tight
+                    constant -= set.lower[i]
+                end
+            else
+                constant -= set.upper[i]
+            end
         else
-            # the lower bound is tight
-            set.lower[i]
+            if isfinite(set.lower[i])
+                constant -= set.lower[i]
+            end
         end
+        return constant
     end
     return set_dot(constant, dual, set)
 end