renaming of key word argument for reformulation (:big_m, :convex_hull)

Author: hdavid16

README.md

@@ -17,17 +17,19 @@ After defining a JuMP model, disjunctions can be added to the model by using the
 4. A valid expression accepted by [JuMP.@NLconstraints](https://jump.dev/JuMP.jl/stable/reference/nlp/#JuMP.@NLconstraints) (using `begin...end)
 5. `Tuple` of expressions accepted by options 1 and/or 3.
 
-NOTE: Any constraints that are of `Interval` type are split into two constraints (one for each bound). It is assumed that the disjuncts belonging to a disjunction are proper disjunctions (mutually exclussive) and only one of them will be selected (`XOR`).
+NOTES: 
+- Vectorized constraints (using `.` notation) are not currently supported. The current workarround is to first creating the constraint outside of the `@disjunction` macro and then passing the reference to the constraint to the `@disjunction` macro.
+- Any constraints that are of `Interval` type are split into two constraints (one for each bound). It is assumed that the disjuncts belonging to a disjunction are proper disjunctions (mutually exclussive) and only one of them will be selected (`XOR`).
 
 The valid key-word arguments for the `@disjunction` macro are:
-- `reformulation::Symbol`: `:BMR` for [Big-M Reformulation](https://optimization.mccormick.northwestern.edu/index.php/Disjunctive_inequalities#Big-M_Reformulation), `:CHR` for [Convex-Hull Reformulation](https://optimization.mccormick.northwestern.edu/index.php/Disjunctive_inequalities#Convex-Hull_Reformulation)
-- `M`: Big-M value used when `reformulation = :BMR`.
-- `ϵ`: epsilon tolerance for the perspective function proposed by [Furman, et al. [2020]](https://link.springer.com/article/10.1007/s10589-020-00176-0). Only used when `reformulation = :CHR`.
+- `reformulation::Symbol`: `:big_m` for [Big-M Reformulation](https://optimization.mccormick.northwestern.edu/index.php/Disjunctive_inequalities#Big-M_Reformulation), `:convex_hull` for [Convex-Hull Reformulation](https://optimization.mccormick.northwestern.edu/index.php/Disjunctive_inequalities#Convex-Hull_Reformulation)
+- `M`: Big-M value used when `reformulation = :big_m`.
+- `ϵ`: epsilon tolerance for the perspective function proposed by [Furman, et al. [2020]](https://link.springer.com/article/10.1007/s10589-020-00176-0). Only used when `reformulation = :convex_hull`.
 - `name::Symbol`: Name for the disjunction (also name for indicator variable used on that disjunction). If not passed (`name = missing`), a symbolic name will be generated with the prefix `disj`. The mutual exclussion constraint on the binary indicator variables can be accessed with `model[Symbol("XOR(disj_$name)")]`.
 
 When a disjunction is defined using the `@disjunction` macro, the disjunctions are reformulated to algebraic constraints via either Big-M or Convex-Hull reformulations. For the Convex-Hull reformulation, disaggregated variables are generated by adding the suffix `_$name$i` to the original variables, where `i` is the index of the disjunct in that disjunction. Bounding constraints are applied to the disaggregated variables and can be accessed with `model[Symbol("$<original var>_$name$i_lb")]` and `model[Symbol("$<original var>_$name$i_ub")]` for the lower bound and upper bound constraints, respectively. The aggregation constraint can be accessed with `model[Symbol("$<original var>_aggregation")]`. For Big-M reformulations, the user may provide an `M` object that represents the BigM value(s). The `M` object can be a `Number` that is applied to all constraints in the disjuncts, or a `Vector`/`Tuple` of values that are used for each of the disjuncts. For Convex-Hull reformulations, the user may provide an `ϵ` value for the perspective function (default is `ϵ = 1e-6`). The `ϵ` object can be a `Number` that is applied to all perspective functions, or a `Vector`/`Tuple` of values that are used for each of the disjuncts.
 
-For empty disjuncts, use `nothing` for their positional argument (e.g., `@disjunction(m, x <= 1, nothing, reformulation = :BMR)`).
+For empty disjuncts, use `nothing` for their positional argument (e.g., `@disjunction(m, x <= 1, nothing, reformulation = :big_m)`).
 
 NOTE: `:gdp_variable_refs` and `:gdp_variable_names` are forbidden JuMP model object names when using *DisjunctiveProgramming.jl*. They are used to store the variable names and variable references in the original model.
 
@@ -45,9 +47,9 @@ The logical proposition is then internally reformulated to an algebraic constrai
 
 The example below is from the [Northwestern University Process Optimization Open Textbook](https://optimization.mccormick.northwestern.edu/index.php/Disjunctive_inequalities).
 
-To perform the Big-M reformulation, `:BMR` is passed to the `reformulation` keyword argument. If nothing is passed to the keyword argument `M`, tight Big-M values will be inferred from the variable bounds using IntervalArithmetic.jl. If `x` is not bounded, Big-M values must be provided for either the whole system (e.g., `M = 10`) or for each of the constraint arrays in the example (e.g., `M = (10,10)`).
+To perform the Big-M reformulation, `:big_m` is passed to the `reformulation` keyword argument. If nothing is passed to the keyword argument `M`, tight Big-M values will be inferred from the variable bounds using IntervalArithmetic.jl. If `x` is not bounded, Big-M values must be provided for either the whole system (e.g., `M = 10`) or for each of the constraint arrays in the example (e.g., `M = (10,10)`).
 
-To perform the Convex-Hull reformulation, `reformulation = :CHR`. Variables must have bounds for the reformulation to work.
+To perform the Convex-Hull reformulation, `reformulation = :convex_hull`. Variables must have bounds for the reformulation to work.
 
 ```julia
 using JuMP
@@ -59,7 +61,7 @@ m = Model()
     m,
     0 ≤ x ≤ 3,
     5 ≤ x ≤ 9,
-    reformulation=:BMR,
+    reformulation=:big_m,
     name=:y
 )
 @proposition(m, y[1] ∨ y[2]) #this is a redundant proposition

examples/ex1.jl

@@ -7,7 +7,7 @@ m = Model()
     m,
     0 ≤ x ≤ 3,
     5 ≤ x ≤ 9,
-    reformulation=:BMR,
+    reformulation=:big_m,
     name=:y
 )
 @proposition(m, y[1] ∨ y[2]) #this is a redundant proposition
@@ -26,5 +26,9 @@ print(m)
 #  disj_y[2][ub] : x + y[2] <= 10.0         <- right-side of constraint in 2nd disjunct (name is assigned to disj_y[2][ub])
 #  x >= -5.0                                <- variable lower bound
 #  x <= 10.0                                <- variable upper bound
+#  y[1] >= 0.0                              <- lower bound on binary
+#  y[2] >= 0.0                              <- lower bound on binary
+#  y[1] <= 1.0                              <- upper bound on binary
+#  y[2] <= 1.0                              <- upper bound on binary
 #  y[1] binary                              <- indicator variable (1st disjunct) is binary
 #  y[2] binary                              <- indicator variable (2nd disjunct) is binary

examples/ex2.jl

@@ -12,7 +12,7 @@ m = Model()
     begin
         con2[i=1:2], [5,4][i] ≤ x[i] ≤ [9,6][i]
     end,
-    reformulation = :BMR,
+    reformulation = :big_m,
     name = :y
 )
 print(m)
@@ -34,5 +34,9 @@ print(m)
 #  x[2] >= -5.0                             <- variable bounds
 #  x[1] <= 10.0                             <- variable bounds
 #  x[2] <= 10.0                             <- variable bounds
+#  y[1] >= 0.0                              <- lower bound on binary
+#  y[2] >= 0.0                              <- lower bound on binary
+#  y[1] <= 1.0                              <- upper bound on binary
+#  y[2] <= 1.0                              <- upper bound on binary
 #  y[1] binary                              <- indicator variable (1st disjunct) is binary
 #  y[2] binary                              <- indicator variable (2nd disjunct) is binary

examples/ex3.jl

@@ -5,6 +5,10 @@ m = Model()
 @variable(m, -5 ≤ x ≤ 10)
 @disjunction(
     m,
+    # begin
+    #     exp(x) ≤ 2
+    #     -3 ≤ x
+    # end,
     (
         exp(x) ≤ 2,
         -3 ≤ x
@@ -13,7 +17,7 @@ m = Model()
         3 ≤ exp(x)
         5 ≤ x
     end,
-    reformulation=:CHR,
+    reformulation=:convex_hull,
     name=:z
 )
 print(m)

src/big_M.jl

@@ -1,4 +1,4 @@
-function BMR!(constr, bin_var, i, k, M)
+function big_m_reformulation!!(constr, bin_var, i, k, M)
     if ismissing(k)
         ref = constr
     else

src/convex_hull.jl

@@ -1,4 +1,4 @@
-function CHR!(constr, bin_var, i, k, eps)
+function convex_hull_reformulation!!(constr, bin_var, i, k, eps)
     ref = ismissing(k) ? constr : constr[k...] #get constraint
     #create convex hull constraint
     if ref isa NonlinearConstraintRef || constraint_object(ref).func isa QuadExpr

src/macros.jl

@@ -8,11 +8,11 @@ macro disjunction(m, args...)
     if !isempty(reformulation)
         reformulation = reformulation[1].args[2]
         reformulation_kind = eval(reformulation)
-        @assert reformulation_kind in [:BMR, :CHR] "Invalid reformulation method passed to keyword argument `:reformulation`. Valid options are :BMR (Big-M Reformulation) and :CHR (Convex-Hull Reormulation)."
-        if reformulation_kind == :BMR
+        @assert reformulation_kind in [:big_m, :convex_hull] "Invalid reformulation method passed to keyword argument `:reformulation`. Valid options are :big_m (Big-M Reformulation) and :convex_hull (Convex-Hull Reormulation)."
+        if reformulation_kind == :big_m
             M = filter(i -> i.args[1] == :M, kw_args)
             param = !isempty(M) ? M[1].args[2] : :(missing)
-        elseif reformulation_kind == :CHR
+        elseif reformulation_kind == :convex_hull
             ϵ = filter(i -> i.args[1] == :ϵ, kw_args)
             param = !isempty(ϵ) ? ϵ[1].args[2] : :(1e-6)
         else
@@ -66,25 +66,61 @@ function add_disjunction_constraint(m, d, dname)
                 @constraints($m,$d)
             catch e
                 if e isa ErrorException
-                    for di in $d
-                        add_nonlinear_constraint($m,di)
-                    end
+                    @NLconstraints($m,$d)
                 else
                     throw(e)
                 end
             end
+            # for di in $d
+            #     try
+            #         if Meta.isexpr(di, :call)
+            #             op, lhs, rhs = d.args
+            #             set = op == :(<=) ? MOI.LessThan(0) : MOI.GreaterThan(0)
+            #             func = lhs - rhs
+            #         elseif Meta.isexpr(di, :comparison)
+            #             lb, op1, func, op2, ub = d.args
+            #             @assert op1 == op2
+            #             set = op1 == :(<=) ? MOI.Interval(lb,ub) : MOI.Interval(ub,lb)
+            #         end
+            #         add_constraint($m, ScalarConstraint(func,set), $dname)
+            #     catch e
+            #         if e isa ErrorException
+            #             add_nonlinear_constraint($m,di)
+            #         else
+            #             throw(e)
+            #         end
+            #     end
+            # end
         end
     elseif Meta.isexpr(d, (:call, :comparison))
         d = quote
             try
                 @constraint($m,$dname,$d)
             catch e
                 if e isa ErrorException
-                    add_nonlinear_constraint($m,$d)
+                    @NLconstraint($m,$d)
                 else
                     throw(e)
                 end
             end
+            # try
+            #     if Meta.isexpr($d, :call)
+            #         op, lhs, rhs = d.args
+            #         set = op == :(<=) ? MOI.LessThan(0) : MOI.GreaterThan(0)
+            #         func = lhs - rhs
+            #     elseif Meta.isexpr($d, :comparison)
+            #         lb, op1, func, op2, ub = d.args
+            #         @assert op1 == op2
+            #         set = op1 == :(<=) ? MOI.Interval(lb,ub) : MOI.Interval(ub,lb)
+            #     end
+            #     add_constraint($m, ScalarConstraint(func,set), $dname)
+            # catch e
+            #     if e isa ErrorException
+            #         add_nonlinear_constraint($m,$d)
+            #     else
+            #         throw(e)
+            #     end
+            # end
         end
     end
 
@@ -93,7 +129,7 @@ end
 
 function add_disjunction!(m::Model,disj...;reformulation::Symbol,M=missing,ϵ=1e-6,name=missing)
     #run checks
-    @assert reformulation in [:BMR, :CHR] "Invalid reformulation method passed to keyword argument `:reformulation`. Valid options are :BMR (Big-M Reformulation) and :CHR (Convex-Hull Reormulation)."
+    @assert reformulation in [:big_m, :convex_hull] "Invalid reformulation method passed to keyword argument `:reformulation`. Valid options are :big_m (Big-M Reformulation) and :convex_hull (Convex-Hull Reormulation)."
     @assert length(disj) > 1 "At least 2 disjuncts must be included. If there is an empty disjunct, use `nothing`."
 
     #create binary indicator variables for each disjunction
@@ -108,7 +144,7 @@ function add_disjunction!(m::Model,disj...;reformulation::Symbol,M=missing,ϵ=1e
     m[Symbol(xor_con)] = @constraint(m, sum(m[bin_var]) == 1, base_name = xor_con)
 
     #apply reformulation
-    param = reformulation == :BMR ? M : ϵ
+    param = reformulation == :big_m ? M : ϵ
     reformulate_disjunction(m, disj; bin_var, reformulation, param)
 end
 

src/reformulate.jl

@@ -11,7 +11,7 @@ function reformulate_disjunction(m::Model, disj...; bin_var, reformulation, para
         @expression(m, gdp_variable_names, var_names)
     end
     #run reformulation
-    if reformulation == :CHR
+    if reformulation == :convex_hull
         disaggregate_variables(m, disj, bin_var)
         sum_disaggregated_variables(m, disj, bin_var)
     end
@@ -83,10 +83,10 @@ function apply_reformulation(constr, bin_var, reformulation, param, i, j = missi
 end
 
 function call_reformulation(reformulation, constr, bin_var, i, k, param)
-    if reformulation == :BMR
-        BMR!(constr, bin_var, i, k, param)
-    elseif reformulation == :CHR
-        CHR!(constr, bin_var, i, k, param)
+    if reformulation == :big_m
+        big_m_reformulation!!(constr, bin_var, i, k, param)
+    elseif reformulation == :convex_hull
+        convex_hull_reformulation!!(constr, bin_var, i, k, param)
     end
 end
 

src/utils.jl

@@ -128,7 +128,7 @@ function replace_JuMPvars!(expr, model)
 end
 
 function replace_operators!(expr)
-    #replace operators with their symbol. NOTE: Is this still needed for the CHR of nl constraints? (check this)
+    #replace operators with their symbol. NOTE: Is this still needed for the convex_hull_reformulation! of nl constraints? (check this)
     if expr isa Expr #run recursion
         for i in eachindex(expr.args)
             expr.args[i] = replace_operators!(expr.args[i])