overload functions (rewrite a lot of functions); rename functions; now use :hull

Author: hdavid16

Project.toml

@@ -1,7 +1,7 @@
 name = "DisjunctiveProgramming"
 uuid = "0d27d021-0159-4c7d-b4a7-9ccb5d9366cf"
 authors = ["hdavid16 <[email protected]>"]
-version = "0.1.7"
+version = "0.2.0"
 
 [deps]
 IntervalArithmetic = "d1acc4aa-44c8-5952-acd4-ba5d80a2a253"

README.md

@@ -24,12 +24,12 @@ NOTES:
 - 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`: `: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)
+- `reformulation::Symbol`: `:big_m` for [Big-M Reformulation](https://optimization.mccormick.northwestern.edu/index.php/Disjunctive_inequalities#Big-M_Reformulation), `:hull` for [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`.
+- `ϵ`: 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 = :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.
+When a disjunction is defined using the `@disjunction` macro, the disjunctions are reformulated to algebraic constraints via either Big-M or Hull reformulations. For the 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 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 = :big_m)`).
 
@@ -51,7 +51,7 @@ The example below is from the [Northwestern University Process Optimization Open
 
 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 = :convex_hull`. Variables must have bounds for the reformulation to work.
+To perform the Hull reformulation, `reformulation = :hull`. Variables must have bounds for the reformulation to work.
 
 ```julia
 using JuMP

examples/ex3.jl

@@ -13,7 +13,7 @@ m = Model()
         3 ≤ exp(x)
         5 ≤ x
     end,
-    reformulation=:convex_hull,
+    reformulation=:hull,
     name=:z
 )
 print(m)
@@ -22,7 +22,6 @@ print(m)
 # Subject to
 #  XOR(disj_z) : z[1] + z[2] == 1.0             <- XOR constraint
 #  x_aggregation : x - x_z1 - x_z2 == 0.0       <- aggregation of disaggregated variables
-#  disj_z[1,2] : -x_z1 - 3 z[1] <= 0.0          <- convex-hull reformulation of 2nd constraint if 1st disjunct (named disj_z[1,2] to indicate 1st disjunct, 2nd constraint)
 #  x_z1_lb : -5 z[1] - x_z1 <= 0.0              <- lower-bound constraint on disaggregated variable x_z1 (x in 1st disjunct)
 #  x_z1_ub : -10 z[1] + x_z1 <= 0.0             <- upper-bound constraint on disaggregated variable x_z1 (x in 1st disjunct)
 #  x_z2_lb : -5 z[2] - x_z2 <= 0.0              <- lower-bound constraint on disaggregated variable x_z2 (x in 2nd disjunct)

src/DisjunctiveProgramming.jl

@@ -8,8 +8,8 @@ export @disjunction, @proposition
 include("constraint.jl")
 include("logic.jl")
 include("utils.jl")
-include("big_M.jl")
-include("convex_hull.jl")
+include("bigm.jl")
+include("hull.jl")
 include("reformulate.jl")
 include("macros.jl")
 

src/big_M.jl

@@ -0,0 +1,56 @@
+# function big_m_reformulation!(constr, bin_var, i, k, M)
+#     if ismissing(k)
+#         ref = constr
+#     elseif k isa CartesianIndex
+#         ref = constr[k]
+#     else
+#         ref = constr[k...]
+#     end
+#     if ismissing(M)
+#         M = apply_interval_arithmetic(ref)
+#         # @warn "No M value passed for $ref. M = $M was inferred from the variable bounds."
+#     elseif !ismissing(k) && !isa(M,Real)
+#         M = M[k]
+#     end
+#     if ref isa NonlinearConstraintRef
+#         nonlinear_bigM(ref, bin_var, M, i)
+#     elseif ref isa ConstraintRef
+#         linear_bigM(ref, bin_var, M, i)
+#     end
+# end
+
+function big_m_reformulation!(constr::ConstraintRef, bin_var, M, i, j, k)
+    M = get_reform_param(M, i, j, k; constr)
+    linear_bigM(constr, bin_var, M, i)
+end
+function big_m_reformulation!(constr::NonlinearConstraintRef, bin_var, M, i, j, k)
+    M = get_reform_param(M, i, j, k; constr)
+    nonlinear_bigM(constr, bin_var, M, i)
+end
+big_m_reformulation!(constr::AbstractArray, bin_var, M, i, j, k) =
+    big_m_reformulation(constr[k], bin_var, M, i, j, k)
+
+function linear_bigM(ref, bin_var, M, i)
+    bin_var_ref = ref.model[bin_var][i]
+    add_to_function_constant(ref, -M)
+    set_normalized_coefficient(ref, bin_var_ref , M)
+end
+
+function nonlinear_bigM(ref, bin_var, M, i)
+    #create symbolic variables (using Symbolics.jl)
+    for var_ref in ref.model[:gdp_variable_refs]
+        var_sym = Symbol(var_ref)
+        eval(:(Symbolics.@variables($var_sym)[1]))
+    end
+    bin_var_sym = Symbol("$bin_var[$i]")
+    λ = Num(Symbolics.Sym{Float64}(bin_var_sym))
+    
+    #parse ref
+    op, lhs, rhs = parse_NLconstraint(ref)
+    replace_Symvars!(lhs, ref.model) #convert JuMP variables into Symbolic variables
+    gx = eval(lhs) #convert the LHS of the constraint into a Symbolic expression
+    gx = gx - M*(1-λ) #add bigM
+    
+    #update constraint
+    replace_NLconstraint(ref, gx, op, rhs)
+end