minor changes

Author: hdavid16

examples/ex1.jl

@@ -20,10 +20,10 @@ print(m)
 # Subject to
 #  XOR(disj_y) : y[1] + y[2] == 1.0         <- XOR constraint
 #  y[1] ∨ y[2] : y[1] + y[2] >= 1.0         <- reformulated logical proposition (name is the proposition)
-#  disj_y[1][lb] : -x + 5 y[1] <= 5.0       <- left-side of constraint in 1st disjunct (name is assigned to disj_y[1][lb])
-#  disj_y[1][ub] : x + 7 y[1] <= 10.0       <- right-side of constraint in 1st disjunct (name is assigned to disj_y[1][ub])
-#  disj_y[2][lb] : -x + 10 y[2] <= 5.0      <- left-side of constraint in 2nd disjunct (name is assigned to disj_y[2][lb])
-#  disj_y[2][ub] : x + y[2] <= 10.0         <- right-side of constraint in 2nd disjunct (name is assigned to disj_y[2][ub])
+#  disj_y[1,lb] : -x + 5 y[1] <= 5.0       <- left-side of constraint in 1st disjunct (name is assigned to disj_y[1][lb])
+#  disj_y[1,ub] : x + 7 y[1] <= 10.0       <- right-side of constraint in 1st disjunct (name is assigned to disj_y[1][ub])
+#  disj_y[2,lb] : -x + 10 y[2] <= 5.0      <- left-side of constraint in 2nd disjunct (name is assigned to disj_y[2][lb])
+#  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

examples/ex2.jl

@@ -22,14 +22,14 @@ print(m)
 # Feasibility
 # Subject to
 #  XOR(disj_y) : y[1] + y[2] == 1.0         <- XOR constraint
-#  con1[1][lb] : -x[1] + 5 y[1] <= 5.0      <- left-side of con1[1]
-#  con1[1][ub] : x[1] + 7 y[1] <= 10.0      <- right-side of con1[1]
-#  con1[2][lb] : -x[2] + 5 y[1] <= 5.0      <- left-side of con1[2]
-#  con1[2][ub] : x[2] + 6 y[1] <= 10.0      <- right-side of con1[2]
-#  con2[1][lb] : -x[1] + 10 y[2] <= 5.0     <- left-side of con2[1]
-#  con2[1][ub] : x[1] + y[2] <= 10.0        <- right-side of con2[1]
-#  con2[2][lb] : -x[2] + 9 y[2] <= 5.0      <- left-side of con2[2]
-#  con2[2][ub] : x[2] + 4 y[2] <= 10.0      <- right-side of con2[2]
+#  con1[1,lb] : -x[1] + 5 y[1] <= 5.0      <- left-side of con1[1]
+#  con1[1,ub] : x[1] + 7 y[1] <= 10.0      <- right-side of con1[1]
+#  con1[2,lb] : -x[2] + 5 y[1] <= 5.0      <- left-side of con1[2]
+#  con1[2,ub] : x[2] + 6 y[1] <= 10.0      <- right-side of con1[2]
+#  con2[1,lb] : -x[1] + 10 y[2] <= 5.0     <- left-side of con2[1]
+#  con2[1,ub] : x[1] + y[2] <= 10.0        <- right-side of con2[1]
+#  con2[2,lb] : -x[2] + 9 y[2] <= 5.0      <- left-side of con2[2]
+#  con2[2,ub] : x[2] + 4 y[2] <= 10.0      <- right-side of con2[2]
 #  x[1] >= -5.0                             <- varaible bounds
 #  x[2] >= -5.0                             <- variable bounds
 #  x[1] <= 10.0                             <- variable bounds

examples/ex3.jl

@@ -37,6 +37,10 @@ print(m)
 #  x <= 10.0                                    <- upper-bound on x
 #  x_z1 <= 10.0                                 <- upper-bound on x_z1 (disaggregated x in 1st disjunct)
 #  x_z2 <= 10.0                                 <- upper-bound on x_z2 (disaggregated x in 2nd disjunct)
+#  z[1] >= 0.0                                  <- lower bound on binary
+#  z[2] >= 0.0                                  <- lower bound on binary
+#  z[1] <= 1.0                                  <- upper bound on binary
+#  z[2] <= 1.0                                  <- upper bound on binary
 #  z[1] binary                                  <- indicator variable (1st disjunct) is binary
 #  z[2] binary                                  <- indicator variable (2nd disjunct) is binary
 #  Perspective Functions:

src/constraint.jl

@@ -92,9 +92,11 @@ function split_interval_constraint(m, constr, constr_name = name(constr))
             lb = constr_obj.set.lower
             ub = constr_obj.set.upper
             ex = constr_obj.func
+            lb_name = name_split_constraint(constr_name, :lb)
+            ub_name = name_split_constraint(constr_name, :ub)
             return [
-                @constraint(m, lb <= ex, base_name = "$(constr_name)[lb]"),
-                @constraint(m, ex <= ub, base_name = "$(constr_name)[ub]")
+                @constraint(m, lb <= ex, base_name = lb_name),
+                @constraint(m, ex <= ub, base_name = ub_name)
             ]
         end
     end

src/convex_hull.jl

@@ -77,7 +77,7 @@ function sum_disaggregated_variables(m, disj, bin_var)
     for var in m[:gdp_variable_refs]
         dis_vars = []
         for i in eachindex(disj)
-            var_name_i = name_disaggregated(var, bin_var, i)
+            var_name_i = name_disaggregated_variable(var, bin_var, i)
             var_i = variable_by_name(m, var_name_i)
             push!(dis_vars, var_i)
         end
@@ -113,7 +113,7 @@ function linear_perspective_function(ref, bin_var, i)
     #replace each variable with its disaggregated version
     for var_ref in ref.model[:gdp_variable_refs]
         #get disaggregated variable reference
-        var_name_i = name_disaggregated(var_ref, bin_var, i)
+        var_name_i = name_disaggregated_variable(var_ref, bin_var, i)
         var_i_ref = variable_by_name(ref.model, var_name_i)
         #check var_ref is present in the constraint
         coeff = normalized_coefficient(ref, var_ref)
@@ -131,7 +131,7 @@ end
 function nonlinear_perspective_function(ref, bin_var, i, eps)
     #create symbolic variables (using Symbolics.jl)
     sym_vars = Dict(
-        symbolic_variable(var_ref) => symbolic_variable(name_disaggregated(var_ref, bin_var, i))
+        symbolic_variable(var_ref) => symbolic_variable(name_disaggregated_variable(var_ref, bin_var, i))
         for var_ref in ref.model[:gdp_variable_refs]
     )
     ϵ = eps #epsilon parameter for perspective function (See Furman, Sawaya, Grossmann [2020] perspecive function)

src/utils.jl

@@ -162,7 +162,7 @@ function symbolic_variable(var_ref)
     return eval(:(Symbolics.@variables($var_sym)[1]))
 end
 
-function name_disaggregated(var_ref, bin_var, i)
+function name_disaggregated_variable(var_ref, bin_var, i)
     #get disaggregated variable reference
     if occursin("[", string(var_ref))
         var_name_i = replace(string(var_ref), "[" => "_$bin_var$i[")
@@ -173,6 +173,17 @@ function name_disaggregated(var_ref, bin_var, i)
     return var_name_i
 end
 
+function name_split_constraint(con_name, side)
+    #get disaggregated variable reference
+    if occursin("[", string(con_name))
+        con_name = replace(string(con_name), "]" => ",$side]")
+    else
+        con_name = "$(con_name)[$side]"
+    end
+
+    return con_name
+end
+
 # function is_linear_func(expr::Expr, m)
 #     m = eval(m)
 #     if expr.head == :call