add binary_variable and fix tests

Author: pulsipher

src/datatypes.jl

@@ -52,17 +52,17 @@ struct Logical{T}
 end
 
 """
-    LogicalVariableData{V}
+    LogicalVariableData
 
 A type for storing [`LogicalVariable`](@ref)s and any meta-data they 
 possess.
 
 **Fields**
-- `variable::V`: The logical variable object.
+- `variable::LogicalVariable`: The logical variable object.
 - `name::String`: The name of the variable.
 """
-mutable struct LogicalVariableData{V}
-    variable::V
+mutable struct LogicalVariableData
+    variable::LogicalVariable
     name::String
 end
 

src/hull.jl

@@ -68,7 +68,7 @@ function _disaggregate_variable(
     dvref = make_disaggregated_variable(model, vref, "$(vref)_$(lvref)", lb, ub)
     push!(_reformulation_variables(model), dvref)
     #get binary indicator variable
-    bvref = _indicator_to_binary(model)[lvref]
+    bvref = binary_variable(lvref)
     #temp storage
     push!(method.disjunction_variables[vref], dvref)
     method.disjunct_variables[vref, bvref] = dvref

src/logic.jl

@@ -223,8 +223,7 @@ function _reformulate_selector(
     func::Vector{AbstractJuMPScalar}, 
     set::AbstractCardinalitySet
     )
-    dict = _indicator_to_binary(model)
-    bvrefs = [dict[lvref] for lvref in func[2:end]]
+    bvrefs = [binary_variable(lvref) for lvref in func[2:end]]
     c = JuMP.constant(func[1])
     new_set = _vec_to_scalar_set(set)(c)
     cref = @constraint(model, sum(bvrefs) in new_set)
@@ -235,8 +234,7 @@ function _reformulate_selector(
     func::Vector{<:LogicalVariableRef}, 
     set::AbstractCardinalitySet
     )
-    dict = _indicator_to_binary(model)
-    bvref, bvrefs... = [dict[lvref] for lvref in func]
+    bvref, bvrefs... = [binary_variable(lvref) for lvref in func]
     new_set = _vec_to_scalar_set(set)(0)
     cref = @constraint(model, sum(bvrefs) - bvref in new_set)
     push!(_reformulation_constraints(model), cref)
@@ -276,7 +274,7 @@ function _add_reformulated_proposition(
 end
 
 function _reformulate_clause(model::JuMP.AbstractModel, lvref::LogicalVariableRef)
-    func = 1 * _indicator_to_binary(model)[lvref]
+    func = 1 * binary_variable(lvref)
     return func
 end
 

src/reformulate.jl

@@ -11,7 +11,6 @@ function reformulate_model(model::JuMP.AbstractModel, method::AbstractSolutionMe
     #clear all previous reformulations
     _clear_reformulations(model)
     #reformulate
-    _reformulate_logical_variables(model)
     _reformulate_disjunctions(model, method)
     _reformulate_logical_constraints(model)
     #set solution method
@@ -29,48 +28,6 @@ function _clear_reformulations(model::JuMP.AbstractModel)
     return
 end
 
-################################################################################
-#                              LOGICAL VARIABLES
-################################################################################
-# Helper function to add start value and fix value
-function _add_logical_info(bvref, var::LogicalVariable)
-    if !isnothing(var.fix_value)
-        JuMP.fix(bvref, var.fix_value)
-    end
-    if !isnothing(var.start_value)
-        JuMP.set_start_value(bvref, var.start_value)
-    end
-    return
-end
-function _add_logical_info(bvref, var::_TaggedLogicalVariable)
-    return _add_logical_info(bvref, var.variable)
-end
-
-# Dispatch on logical variable type to create a binary variable
-function _make_binary_variable(model, ::LogicalVariable, name)
-    return JuMP.@variable(model, base_name = name, binary = true)
-end
-function _make_binary_variable(model, var::_TaggedLogicalVariable, name)
-    return JuMP.@variable(
-        model, 
-        base_name = name, 
-        binary = true, 
-        variable_type = var.tag_data
-        )
-end
-
-# create binary (indicator) variables for logic variables.
-function _reformulate_logical_variables(model::JuMP.AbstractModel)
-    for (lv_idx, lv_data) in _logical_variables(model)
-        var = lv_data.variable
-        lvref = LogicalVariableRef(model, lv_idx)
-        bvref = _make_binary_variable(model, var, lv_data.name)
-        _add_logical_info(bvref, var)
-        push!(_reformulation_variables(model), bvref)
-        _indicator_to_binary(model)[lvref] = bvref
-    end
-end
-
 ################################################################################
 #                              DISJUNCTIONS
 ################################################################################
@@ -167,7 +124,7 @@ function _reformulate_disjunct(
     method::AbstractReformulationMethod
     )
     #reformulate each constraint and add to the model
-    bvref = _indicator_to_binary(model)[lvref]
+    bvref = binary_variable(lvref)
     !haskey(_indicator_to_constraints(model), lvref) && return #skip if disjunct is empty
     for cref in _indicator_to_constraints(model)[lvref]
         con = constraint_object(cref)

src/variables.jl

@@ -46,6 +46,37 @@ function JuMP.build_variable(
     return _TaggedLogicalVariable(lvar, tag.tag_data) 
 end
 
+# Helper functions to extract the core variable object
+_get_variable(v::_TaggedLogicalVariable) = v.variable
+_get_variable(v) = v
+
+# Helper function to add start value and fix value
+function _add_logical_info(bvref, var::LogicalVariable)
+    if !isnothing(var.fix_value)
+        JuMP.fix(bvref, var.fix_value)
+    end
+    if !isnothing(var.start_value)
+        JuMP.set_start_value(bvref, var.start_value)
+    end
+    return
+end
+function _add_logical_info(bvref, var::_TaggedLogicalVariable)
+    return _add_logical_info(bvref, var.variable)
+end
+
+# Dispatch on logical variable type to create a binary variable
+function _make_binary_variable(model, ::LogicalVariable, name)
+    return JuMP.@variable(model, base_name = name, binary = true)
+end
+function _make_binary_variable(model, var::_TaggedLogicalVariable, name)
+    return JuMP.@variable(
+        model, 
+        base_name = name, 
+        binary = true, 
+        variable_type = var.tag_data
+        )
+end
+
 """
     JuMP.add_variable(model::Model, v::LogicalVariable, 
                       name::String = "")::LogicalVariableRef
@@ -59,10 +90,16 @@ function JuMP.add_variable(
     name::String = ""
     )
     is_gdp_model(model) || error("Can only add logical variables to `GDPModel`s.")
-    data = LogicalVariableData(v, name)
+    # add the logical variable
+    data = LogicalVariableData(_get_variable(v), name)
     idx = _MOIUC.add_item(_logical_variables(model), data)
+    lvref = LogicalVariableRef(model, idx)
     _set_ready_to_optimize(model, false)
-    return LogicalVariableRef(model, idx)
+    # add the assocviated binary variables
+    bvref = _make_binary_variable(model, v, name)
+    _add_logical_info(bvref, v)
+    _indicator_to_binary(model)[lvref] = bvref
+    return lvref
 end
 
 # Base extensions
@@ -77,31 +114,15 @@ end
 # end
 
 # Define helpful getting functions
-function _variable_object(data::LogicalVariableData{<:_TaggedLogicalVariable})
-    return data.variable.variable
-end
-function _variable_object(data::LogicalVariableData)
-    return data.variable
-end
 function _variable_object(lvref::LogicalVariableRef)
     dict = _logical_variables(JuMP.owner_model(lvref))
-    return _variable_object(dict[JuMP.index(lvref)])
+    return dict[JuMP.index(lvref)].variable
 end
 
 # Define helpful setting functions
-function _set_variable_object(data::LogicalVariableData{<:_TaggedLogicalVariable}, var)
-    tag = data.variable.tag_data
-    data.variable = _TaggedLogicalVariable(var, tag)
-    return
-end
-function _set_variable_object(data::LogicalVariableData, var)
-    data.variable = var
-    return
-end
 function _set_variable_object(lvref::LogicalVariableRef, var::LogicalVariable)
     model = JuMP.owner_model(lvref)
-    dict = _logical_variables(model)
-    _set_variable_object(dict[JuMP.index(lvref)], var)
+    _logical_variables(model)[JuMP.index(lvref)].variable = var
     _set_ready_to_optimize(model, false)
     return
 end
@@ -158,6 +179,7 @@ function JuMP.set_name(vref::LogicalVariableRef, name::String)
     data = gdp_data(model)
     data.logical_variables[index(vref)].name = name
     _set_ready_to_optimize(model, false)
+    JuMP.set_name(binary_variable(vref), name)
     return
 end
 
@@ -183,6 +205,7 @@ function JuMP.set_start_value(
     )
     new_var = LogicalVariable(JuMP.fix_value(vref), value)
     _set_variable_object(vref, new_var)
+    JuMP.set_start_value(binary_variable(vref), value)
     return
 end
 """
@@ -215,6 +238,7 @@ new one.
 function JuMP.fix(vref::LogicalVariableRef, value::Bool)
     new_var = LogicalVariable(value, JuMP.start_value(vref))
     _set_variable_object(vref, new_var)
+    JuMP.fix(binary_variable(vref), value)
     return
 end
 
@@ -226,9 +250,22 @@ Delete the fixed value of a logical variable.
 function JuMP.unfix(vref::LogicalVariableRef)
     new_var = LogicalVariable(nothing, JuMP.start_value(vref))
     _set_variable_object(vref, new_var)
+    JuMP.unfix(binary_variable(vref))
     return
 end
 
+"""
+    binary_variable(vref::LogicalVariableRef)::JuMP.AbstractVariableRef
+
+Returns the underlying binary variable for the logical variable `vref` which 
+is used in the reformulated model. This is helpful to embed logical variables 
+in algebraic constraints.
+"""
+function binary_variable(vref::LogicalVariableRef)
+    model = JuMP.owner_model(vref)
+    return _indicator_to_binary(model)[vref]
+end
+
 """
     JuMP.delete(model::JuMP.AbstractModel, vref::LogicalVariableRef)::Nothing
 
@@ -241,24 +278,25 @@ function JuMP.delete(model::JuMP.AbstractModel, vref::LogicalVariableRef)
     #delete any disjunct constraints associated with the logical variables in the disjunction
     if haskey(_indicator_to_constraints(model), vref)
         crefs = _indicator_to_constraints(model)[vref]
-        delete.(model, crefs)
+        JuMP.delete.(model, crefs)
         delete!(_indicator_to_constraints(model), vref)
     end
     #delete any disjunctions that have the logical variable
     for (didx, ddata) in _disjunctions(model)
         if vref in ddata.constraint.indicators
-            delete(model, DisjunctionRef(model, didx))
+            JuMP.delete(model, DisjunctionRef(model, didx))
         end
     end
     #delete any logical constraints involving the logical variables
     for (cidx, cdata) in _logical_constraints(model)
         lvars = _get_logical_constraint_variables(model, cdata.constraint)
         if vref in lvars
-            delete(model, LogicalConstraintRef(model, cidx))
+            JuMP.delete(model, LogicalConstraintRef(model, cidx))
         end
     end
     #delete the logical variable
     delete!(dict, vidx)
+    JuMP.delete(model, binary_variable(vref))
     delete!(_indicator_to_binary(model), vref)
     #not ready to optimize
     _set_ready_to_optimize(model, false)

test/constraints/bigm.jl

@@ -166,8 +166,7 @@ function test_lessthan_bigm()
     @variable(model, y, Logical)
     @constraint(model, con, x <= 5, Disjunct(y))
 
-    DP._reformulate_logical_variables(model)
-    bvref = DP._indicator_to_binary(model)[y]
+    bvref = binary_variable(y)
     ref = reformulate_disjunct_constraint(model, constraint_object(con), bvref, BigM(100, false))
     @test length(ref) == 1
     @test ref[1].func == x - 100*(-bvref)
@@ -180,8 +179,7 @@ function test_nonpositives_bigm()
     @variable(model, y, Logical)
     @constraint(model, con, [x; x] <= [5; 5], Disjunct(y))
 
-    DP._reformulate_logical_variables(model)
-    bvref = DP._indicator_to_binary(model)[y]
+    bvref = binary_variable(y)
     ref = reformulate_disjunct_constraint(model, constraint_object(con), bvref, BigM(100, false))
     @test length(ref) == 1
     @test ref[1].func[1] == x - 5 - 100*(1-bvref)
@@ -195,8 +193,7 @@ function test_greaterthan_bigm()
     @variable(model, y, Logical)
     @constraint(model, con, x >= 5, Disjunct(y))
 
-    DP._reformulate_logical_variables(model)
-    bvref = DP._indicator_to_binary(model)[y]
+    bvref = binary_variable(y)
     ref = reformulate_disjunct_constraint(model, constraint_object(con), bvref, BigM(100, false))
     @test length(ref) == 1
     @test ref[1].func == x + 100*(-bvref)
@@ -209,8 +206,7 @@ function test_nonnegatives_bigm()
     @variable(model, y, Logical)
     @constraint(model, con, [x; x] >= [5; 5], Disjunct(y))
 
-    DP._reformulate_logical_variables(model)
-    bvref = DP._indicator_to_binary(model)[y]
+    bvref = binary_variable(y)
     ref = reformulate_disjunct_constraint(model, constraint_object(con), bvref, BigM(100, false))
     @test length(ref) == 1
     @test ref[1].func[1] == x - 5 + 100*(1-bvref)
@@ -224,8 +220,7 @@ function test_equalto_bigm()
     @variable(model, y, Logical)
     @constraint(model, con, x == 5, Disjunct(y))
 
-    DP._reformulate_logical_variables(model)
-    bvref = DP._indicator_to_binary(model)[y]
+    bvref = binary_variable(y)
     ref = reformulate_disjunct_constraint(model, constraint_object(con), bvref, BigM(100, false))
     @test length(ref) == 2
     @test ref[1].func == x + 100*(-bvref)
@@ -240,8 +235,7 @@ function test_interval_bigm()
     @variable(model, y, Logical)
     @constraint(model, con, 5 <= x <= 5, Disjunct(y))
 
-    DP._reformulate_logical_variables(model)
-    bvref = DP._indicator_to_binary(model)[y]
+    bvref = binary_variable(y)
     ref = reformulate_disjunct_constraint(model, constraint_object(con), bvref, BigM(100, false))
     @test length(ref) == 2
     @test ref[1].func == x + 100*(-bvref)
@@ -256,8 +250,7 @@ function test_zeros_bigm()
     @variable(model, y, Logical)
     @constraint(model, con, [x; x] == [5; 5], Disjunct(y))
 
-    DP._reformulate_logical_variables(model)
-    bvref = DP._indicator_to_binary(model)[y]
+    bvref = binary_variable(y)
     ref = reformulate_disjunct_constraint(model, constraint_object(con), bvref, BigM(100, false))
     @test length(ref) == 2
     @test ref[1].func[1] == x - 5 + 100*(1-bvref)