change in interval constraints handling

Author: dnguyen227

src/mbm.jl

@@ -8,24 +8,24 @@ function reformulate_disjunction(
     method::MBM
 )
     ref_cons = Vector{JuMP.AbstractConstraint}() 
-    for d in disj.indicators
-        # Make a copy to avoid modifying during iteration
-        constraints = copy(_indicator_to_constraints(model)[d])
-        for cref in constraints
-            con = JuMP.constraint_object(cref)
-            if con isa JuMP.ScalarConstraint{<:Any, <:MOI.Interval}
-                # Create lower and upper bound constraints
-                lower_con = JuMP.build_constraint(error, con.func, 
-                    MOI.GreaterThan(con.set.lower))
-                upper_con = JuMP.build_constraint(error, con.func, 
-                    MOI.LessThan(con.set.upper))
-                # Create new disjunct constraints
-                JuMP.add_constraint(model,_DisjunctConstraint(lower_con, d))
-                JuMP.add_constraint(model,_DisjunctConstraint(upper_con, d))
-                JuMP.delete(model, cref)
-            end 
-        end
-    end
+    # for d in disj.indicators
+    #     # Make a copy to avoid modifying during iteration
+    #     constraints = copy(_indicator_to_constraints(model)[d])
+    #     for cref in constraints
+    #         con = JuMP.constraint_object(cref)
+    #         if con isa JuMP.ScalarConstraint{<:Any, <:MOI.Interval}
+    #             # Create lower and upper bound constraints
+    #             lower_con = JuMP.build_constraint(error, con.func, 
+    #                 MOI.GreaterThan(con.set.lower))
+    #             upper_con = JuMP.build_constraint(error, con.func, 
+    #                 MOI.LessThan(con.set.upper))
+    #             # Create new disjunct constraints
+    #             JuMP.add_constraint(model,_DisjunctConstraint(lower_con, d))
+    #             JuMP.add_constraint(model,_DisjunctConstraint(upper_con, d))
+    #             JuMP.delete(model, cref)
+    #         end 
+    #     end
+    # end
     for d in disj.indicators
         method.conlvref = [x for x in disj.indicators if x != d]
         _reformulate_disjunct(model, ref_cons, d, method)
@@ -191,6 +191,31 @@ function reformulate_disjunct_constraint(
     return [lower_con, upper_con]
 end
 
+function reformulate_disjunct_constraint(
+    model::JuMP.AbstractModel,
+    con::JuMP.ScalarConstraint{T, S},
+    bconref:: Union{Dict{<:LogicalVariableRef,<:JuMP.AbstractVariableRef},
+                   Dict{<:LogicalVariableRef,<:JuMP.GenericAffExpr}},
+    method::MBM
+) where {T, S <: _MOI.Interval}
+    set_values = _set_values(con.set)  
+    upper_func = JuMP.@expression(model, 
+        con.func - sum(method.M[i] * bconref[i] for i in keys(method.M))
+    )
+    upper_con = JuMP.build_constraint(error, upper_func, 
+        MOI.LessThan(set_values[2])
+    )
+    
+    lower_func = JuMP.@expression(model, 
+        con.func + sum(method.M[i] * bconref[i] for i in keys(method.M))
+    )
+    lower_con = JuMP.build_constraint(error, lower_func, 
+        MOI.GreaterThan(set_values[1])
+    )
+    
+    return [lower_con, upper_con]
+end
+
 function reformulate_disjunct_constraint(
     ::JuMP.AbstractModel, 
     ::F, 
@@ -300,6 +325,29 @@ function _maximize_M(
     )
 end
 
+function _maximize_M(
+    model::JuMP.AbstractModel, 
+    objective::JuMP.ScalarConstraint{T, S}, 
+    constraints::Vector{<:DisjunctConstraintRef}, 
+    method::MBM
+) where {T, S <: _MOI.Interval}
+    set_values = _set_values(objective.set)  # Returns (lower, upper)
+    return max(
+        _mini_model(
+            model, 
+            JuMP.ScalarConstraint(objective.func, MOI.GreaterThan(set_values[1])), 
+            constraints, 
+            method
+        ),
+        _mini_model(
+            model, 
+            JuMP.ScalarConstraint(objective.func, MOI.LessThan(set_values[2])), 
+            constraints, 
+            method
+        )
+    )
+end
+
 function _maximize_M(
     ::JuMP.AbstractModel, 
     ::F, 
@@ -351,7 +399,8 @@ function _mini_model(
 ) where {T,S <: Union{_MOI.Nonpositives, _MOI.Nonnegatives,_MOI.Zeros, MOI.EqualTo, MOI.Interval}, 
                       C <: Union{DisjunctConstraintRef, DisjunctionRef}}
     error("This type of constraints and objective constraint has " *
-          "not been implemented for MBM subproblems")
+          "not been implemented for MBM subproblems \n" * 
+          "Objective: $(T) $(S) \nConstraints: $(C)")
 end
 
 ################################################################################

test/constraints/mbm.jl

@@ -66,11 +66,12 @@ function test_mini_model()
     model = GDPModel()
     @variable(model, 0 <= x, start = 1)
     @variable(model, 0 <= y)
-    @variable(model, Y[1:3], Logical)
+    @variable(model, Y[1:4], Logical)
     @constraint(model, con, 3*-x <= 4, Disjunct(Y[1]))
     @constraint(model, con2, 3*x + y >= 15, Disjunct(Y[2]))
     @constraint(model, infeasiblecon, 3*x + y == 15, Disjunct(Y[3]))
-    @disjunction(model, [Y[1], Y[2], Y[3]])
+    @constraint(model, intervalcon, 0 <= x <= 55, Disjunct(Y[4]))
+    @disjunction(model, [Y[1], Y[2], Y[3], Y[4]])
     @test DP._mini_model(model, constraint_object(con), 
         DisjunctConstraintRef[con2], MBM(HiGHS.Optimizer))== -4
     set_upper_bound(x, 1)
@@ -105,6 +106,10 @@ function test_maximize_M()
         Disjunct(Y[5]))
     @constraint(model, zeros, -x .+ 1 in MOI.Zeros(2), Disjunct(Y[6]))
 
+    @test DP._maximize_M(model, constraint_object(interval), 
+        Vector{DisjunctConstraintRef}(
+            DP._indicator_to_constraints(model)[Y[2]]), 
+        MBM(HiGHS.Optimizer)) == 0.0
     @test DP._maximize_M(model, constraint_object(lessthan), 
         Vector{DisjunctConstraintRef}(
             DP._indicator_to_constraints(model)[Y[2]]),