Merge pull request #52 from hdavid16:ext_dict

use extension dictionary

Author: hdavid16

Project.toml

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

examples/ex1.jl

@@ -11,7 +11,7 @@ m = Model()
     name=:y
 )
 choose!(m, 1, m[:y]...; mode = :exactly, name = "XOR") #XOR constraint
-@proposition(m, y[1] ∨ y[2]) #this is a redundant proposition
+@proposition(m, y[1] ∨ y[2], name = "prop") #this is a redundant proposition
 
 print(m)
 

examples/ex2.jl

@@ -18,8 +18,6 @@ m = Model()
 choose!(m, 1, m[:y]...; mode = :exactly, name = "XOR") #XOR constraint
 print(m)
 
-# ┌ Warning: [con1[1] : x[1] in [0.0, 3.0], con1[2] : x[2] in [0.0, 4.0]] uses the `MOI.Interval` set. Each instance of the interval set has been split into two constraints, one for each bound.
-# ┌ Warning: [con2[1] : x[1] in [5.0, 9.0], con2[2] : x[2] in [4.0, 6.0]] uses the `MOI.Interval` set. Each instance of the interval set has been split into two constraints, one for each bound.
 # Feasibility
 # Subject to
 #  XOR(disj_y) : y[1] + y[2] == 1.0         <- XOR constraint

src/bigm.jl

@@ -33,7 +33,7 @@ function big_m_reformulation!(constr::NonlinearConstraintRef, bin_var, M, i, j,
     gx = gx - M*(1-λ) #add bigM
 
     #update constraint
-    replace_constraint(constr, gx, op, rhs)
+    replace_constraint(constr, bin_var, gx, op, rhs)
 end
 big_m_reformulation!(constr::AbstractArray{<:ConstraintRef}, bin_var, M, i, j, k) =
     big_m_reformulation(constr[k], bin_var, M, i, j, k)

src/constraint.jl

@@ -41,10 +41,7 @@ function check_constraint!(m::Model, constr::ConstraintRef)
     if isnothing(new_constr)
         new_constr = constr
     else
-        constr_name = gen_constraint_name(constr)
-        delete_constraint!(m, constr, constr_name)
-        m[constr_name] = new_constr
-        m.ext[:object_dict][constr_name] = new_constr
+        delete(m, constr)
     end
     return new_constr
 end
@@ -64,10 +61,7 @@ function check_constraint!(m::Model, constr::AbstractArray{<:ConstraintRef})
             ]...
         ))
         new_constr = Containers.SparseAxisArray(constr_dict)
-        constr_name = gen_constraint_name(constr)
-        delete_constraint!.(m, constr, constr_name)
-        m[constr_name] = new_constr
-        m.ext[:object_dict][constr_name] = new_constr
+        delete(m, constr)
     end
     return new_constr
 end
@@ -166,11 +160,11 @@ function parse_constraint(constr::ConstraintRef)
 end
 
 """
-    replace_constraint(constr::ConstraintRef, sym_expr, op, rhs)
+    replace_constraint(constr::ConstraintRef, bin_var::Symbol, sym_expr, op, rhs)
 
 Replace nonlinear or quadratic constraint with its hull reformulation.
 """
-function replace_constraint(constr::ConstraintRef, sym_expr, op, rhs)
+function replace_constraint(constr::ConstraintRef, bin_var::Symbol, sym_expr, op, rhs)
     #convert symbolic function to expression
     op = eval(op)
     expr = Base.remove_linenums!(build_function(op(sym_expr,rhs))).args[2].args[1]
@@ -179,12 +173,6 @@ function replace_constraint(constr::ConstraintRef, sym_expr, op, rhs)
     replace_JuMPvars!(expr, m)
     replace_operators!(expr)
     #replace constraint with prespective function
-    constr_name = gen_constraint_name(constr)
-    delete_constraint!(m, constr, constr_name)
-    m[constr_name] = add_nonlinear_constraint(m, expr)
-end
-
-function delete_constraint!(m, constr, constr_name)
+    push!(m.ext[bin_var], add_nonlinear_constraint(m, expr))
     delete(m, constr)
-    unregister(m, constr_name)
 end

src/hull.jl

@@ -63,7 +63,7 @@ function hull_reformulation!(constr::ConstraintRef, bin_var, eps, i, j, k)
     pers_func = substitute(pers_func, Dict(FSG1 => (1-ϵ)*λ+ϵ,
                                            FSG2 => ϵ*(1-λ)))
     pers_func = simplify(pers_func)
-    replace_constraint(constr, pers_func, op, rhs)
+    replace_constraint(constr, bin_var, pers_func, op, rhs)
 end
 hull_reformulation!(constr::AbstractArray{<:ConstraintRef}, bin_var, eps, i, j, k) = 
     hull_reformulation!(constr[k], bin_var, eps, i, j, k)
@@ -93,14 +93,20 @@ function disaggregate_variables(m::Model, disj, bin_var)
             #apply bounding constraints on disaggregated variable
             var_i_lb = "$(var_name_i)_lb" 
             var_i_ub = "$(var_name_i)_ub" 
-            m[Symbol(var_i_lb)] = @constraint(m, LB * m[bin_var][i] .- m[var_name_i] .<= 0, base_name = var_i_lb)
-            m[Symbol(var_i_ub)] = @constraint(m, m[var_name_i] .- UB * m[bin_var][i] .<= 0, base_name = var_i_ub)
+            push!(
+                m.ext[bin_var], 
+                @constraint(m, LB * m[bin_var][i] .- m[var_name_i] .<= 0, base_name = var_i_lb),
+                @constraint(m, m[var_name_i] .- UB * m[bin_var][i] .<= 0, base_name = var_i_ub)
+            )
             #update disaggregated sum expression
             add_to_expression!(sum_vars, 1, m[var_name_i])
         end
         #sum disaggregated variables
         aggr_con = "$(var)_$(bin_var)_aggregation"
-        m[Symbol(aggr_con)] = @constraint(m, var == sum_vars, base_name = aggr_con)
+        push!(
+            m.ext[bin_var],
+            @constraint(m, var == sum_vars, base_name = aggr_con)
+        )
     end
 end
 

src/logic.jl

@@ -28,12 +28,14 @@ function add_selection!(m::Model, n, vars::VariableRef...; mode::Symbol, name::S
 end
 
 """
-    add_proposition!(m::Model, expr::Expr)
+    add_proposition!(m::Model, expr::Expr; name::String = "")
 
 Convert logical proposition expression into conjunctive normal form.
 """
-function add_proposition!(m::Model, expr::Expr)
-    expr_name = Symbol("{$expr}") #get name to register reformulated logical proposition
+function add_proposition!(m::Model, expr::Expr; name::String = "")
+    if isempty(name)
+        name = "{$expr}" #get name to register reformulated logical proposition
+    end
     replace_Symvars!(expr, m; logical_proposition = true) #replace all JuMP variables with Symbolic variables
     clause_list = to_cnf!(expr)
     #replace symbolic variables with JuMP variables and boolean operators with their algebraic counterparts
@@ -47,9 +49,9 @@ function add_proposition!(m::Model, expr::Expr)
     unique!(lhs)
     #generate JuMP constraints for the logical proposition
     if length(lhs) == 1
-        m[expr_name] = @constraint(m, lhs[1] >= 1, base_name = string(expr_name))
+        m[Symbol(name)] = @constraint(m, lhs[1] >= 1, base_name = name)
     else
-        m[expr_name] = @constraint(m, [i = eachindex(lhs)], lhs[i] >= 1, base_name = string(expr_name))
+        m[Symbol(name)] = @constraint(m, [i = eachindex(lhs)], lhs[i] >= 1, base_name = name)
     end
 end
 

src/macros.jl

@@ -106,10 +106,13 @@ end
 
 Add logical proposition macro.
 """
-macro proposition(m, expr)
+macro proposition(m, args...)
+    expr, kwargs, _ = Containers._extract_kw_args(args)
+    name_kwarg = filter(i -> i.args[1] == :name, kwargs)
+    name = isempty(name_kwarg) ? Symbol("") : name_kwarg[1].args[2]
     #get args
     expr = QuoteNode(expr)
-    code = :(DisjunctiveProgramming.add_proposition!($m, $expr))
+    code = :(DisjunctiveProgramming.add_proposition!($m, $expr[1]; name = $name))
 
     return esc(code)
 end

src/reformulate.jl

@@ -8,14 +8,16 @@ Reformulate disjunction on a JuMP model.
 Reformulate disjunction.
 """
 function reformulate_disjunction(m::Model, disj...; bin_var, reformulation, param)
-    m.ext[:object_dict] = copy(object_dictionary(m))
+    #placeholder to store new constraints (reformulated)
+    m.ext[bin_var] = []
     #check disj
     disj = [check_constraint!(m, constr) for constr in disj]#check_disjunction!(m, disj)
     #run reformulation
     if reformulation == :hull
         disaggregate_variables(m, disj, bin_var)
     end
     reformulate_disjunction(disj, bin_var, reformulation, param)
+    push!(m.ext[bin_var], Iterators.flatten(filter(i -> is_constraint(m, i), disj))...)
 end
 function reformulate_disjunction(disj, bin_var, reformulation, param)
     for (i,constr) in enumerate(disj)

src/utils.jl

@@ -57,46 +57,6 @@ function get_constraint_variables(m::Model, disjunction)
     )
 end
 
-"""
-    gen_constraint_name(constr)
-
-Generate constraint name for a constraint to be split (Interval or EqualTo).
-"""
-function gen_constraint_name(constr::ConstraintRef)
-    constr_name = name(constr)
-    if isempty(constr_name)
-        constr_name = gensym("constraint")
-    end
-
-    return Symbol(constr_name)
-end
-function gen_constraint_name(constr::NonlinearConstraintRef)
-    constr_name = findfirst(==(constr), constr.model.ext[:object_dict])
-    if isnothing(constr_name)
-        constr_name = gensym("constraint")
-    end
-
-    return Symbol(constr_name)
-end
-function gen_constraint_name(constr::AbstractArray{<:NonlinearConstraintRef})
-    constr_name = findfirst(==(constr), first(constr).model.ext[:object_dict])
-    if isnothing(constr_name)
-        constr_name = gensym("constraint")
-    end
-
-    return Symbol(constr_name)
-end
-function gen_constraint_name(constr::AbstractArray{<:ConstraintRef})
-    constr_name_set = union(first.(split.(string.(gen_constraint_name.(constr)), "[")))
-    if length(constr_name_set) == 1
-        constr_name = constr_name_set[1]
-    else
-        constr_name = gensym("constraint")
-    end
-
-    return Symbol(constr_name)
-end
-
 function replace_Symvars!(expr, model; logical_proposition = false)
     #replace JuMP variables with symbolic variables
     name = join(split(string(expr)," "))
@@ -191,4 +151,8 @@ function constraint_variables!(expr, model, var_list=[])
             constraint_variables!(expr.args[i], model, var_list)
         end
     end
-end
+end
+
+is_constraint(m::Model, constr::ConstraintRef) = is_valid(m,constr)
+is_constraint(m::Model, constr::AbstractArray{<:ConstraintRef}) = all(is_valid.(m,constr))
+is_constraint(m::Model, constr::Tuple) = all([is_constraint(m,i) for i in constr])