API

DisjunctiveProgramming.@disjunction — Macro

@disjunction(model, expr, kw_args...)

Add a disjunction described by the expression expr, which must be a Vector of LogicalVariableRefs.

@disjunction(model, ref[i=..., j=..., ...], expr, kw_args...)

Add a group of disjunction described by the expression expr parameterized by i, j, ..., which must be a Vector of LogicalVariableRefs.

In both of the above calls, a Disjunct tag can be added to create nested disjunctions.

The recognized keyword arguments in kw_args are the following:

base_name: Sets the name prefix used to generate constraint names. It corresponds to the constraint name for scalar constraints, otherwise, the constraint names are set to base_name[...] for each index ... of the axes axes.
container: Specify the container type.
exactly1: Specify a Bool whether a constraint should be added to only allow selecting one disjunct in the disjunction.

To create disjunctions without macros, see disjunction.

source

DisjunctiveProgramming.@disjunctions — Macro

@disjunctions(model, args...)

Adds groups of disjunctions at once, in the same fashion as the @disjunction macro.

The model must be the first argument, and multiple disjunctions can be added on multiple lines wrapped in a begin ... end block.

The macro returns a tuple containing the disjunctions that were defined.

Example

julia model = GDPModel(); @variable(model, w); @variable(model, x); @variable(model, Y[1:4], LogicalVariable); @constraint(model, [i=1:2], w == i, Disjunct(Y[i])); @constraint(model, [i=3:4], x == i, Disjunct(Y[i])); @disjunctions(model, begin [Y[1], Y[2]] [Y[3], Y[4]] end);`

source

DisjunctiveProgramming._make_variable_object — Method

_make_variable_object(props::VariableProperties)::Any

Constructs a JuMP variable object from the given VariableProperties. If the variable_type field is nothing, dispatches to JuMP.build_variable with only the variable info; otherwise, passes variable_type as a tag/type.

Returns a JuMP variable object that can be added to a model.

source

DisjunctiveProgramming.binary_variable — Method

binary_variable(
    vref::LogicalVariableRef
    )::Union{JuMP.AbstractVariableRef, JuMP.GenericAffExpr}

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. If vref has a logical complement then an expression of the form 1 - bvref is returned where bvref is the binary variable of the logical complement variable.

source

DisjunctiveProgramming.copy_gdp_data — Method

copy_gdp_data(
    model::JuMP.AbstractModel,
    new_model::JuMP.AbstractModel,
    ref_map::JuMP.GenericReferenceMap
)::Dict{LogicalVariableRef, LogicalVariableRef}

Copy all GDP-specific data from model to new_model, including logical variables, logical constraints, disjunct constraints, and disjunctions. This function is called automatically by copy_gdp_model after JuMP.copy_model has copied the base model structure.

Arguments

model::JuMP.AbstractModel: The source model containing GDP data to copy.
new_model::JuMP.AbstractModel: The destination model that will receive the copied GDP data.
ref_map::JuMP.GenericReferenceMap: The reference map from JuMP.copy_model that maps old variable references to new ones.

Returns

Dict{LogicalVariableRef, LogicalVariableRef}: A mapping from old logical variable references to new logical variable references.

source

DisjunctiveProgramming.copy_gdp_model — Method

copy_gdp_model(model::JuMP.AbstractModel)

Create a copy of a GDPModel, including all variables, constraints, and GDP-specific data (logical variables, disjunctions, etc.).

Arguments

model::JuMP.AbstractModel: The GDP model to copy.

Returns A tuple (new_model, ref_map, lv_map) where:

new_model: The copied model.
ref_map::JuMP.GenericReferenceMap: Maps old variable and constraint references to new ones.
lv_map::Dict{LogicalVariableRef, LogicalVariableRef}: Maps old logical variable references to new ones.

Example

using DisjunctiveProgramming, HiGHS
model = GDPModel(HiGHS.Optimizer)
@variable(model, x)
@variable(model, Y[1:2], LogicalVariable)
@constraint(model, x <= 10, Disjunct(Y[1]))
@constraint(model, x >= 20, Disjunct(Y[2]))
@disjunction(model, Y)

new_model, ref_map, lv_map = copy_gdp_model(model)

source

DisjunctiveProgramming.create_variable — Method

create_variable(model::JuMP.AbstractModel, props::VariableProperties)::JuMP.AbstractVariableRef

Creates and adds a JuMP variable to model using the properties specified in props. This function applies all variable attributes from the VariableProperties object including binary/integer constraints, bounds, fixed values, start values, and constraint sets.

The function first creates a variable object using _make_variable_object, optionally applies any constraint sets if props.set is not nothing, and then adds the variable to the model with the specified name.

source

DisjunctiveProgramming.disjunction — Function

disjunction(
    model::JuMP.AbstractModel,
    disjunct_indicators::Vector{LogicalVariableRef},
    [nested_tag::Disjunct],
    [name::String = ""];
    [exactly1::Bool = true]
)

Create a disjunction comprised of disjuncts with indicator variables disjunct_indicators and add it to model. For nested disjunctions, the nested_tag is required to indicate which disjunct it will be part of in the parent disjunction. By default, exactly1 adds a constraint of the form @constraint(model, disjunct_indicators in Exactly(1)) only allowing one of the disjuncts to be selected; this is required for certain reformulations like Hull. For nested disjunctions, exactly1 creates a constraint of the form @constraint(model, disjunct_indicators in Exactly(nested_tag.indicator)). To conveniently generate many disjunctions at once, see @disjunction and @disjunctions.

source

DisjunctiveProgramming.gdp_data — Method

gdp_data(model::JuMP.AbstractModel)::GDPData

Extract the GDPData from a GDPModel.

source

DisjunctiveProgramming.has_logical_complement — Method

has_logical_complement(vref::LogicalVariableRef)::Bool

Return a Bool whether a vref is a logical complement of another logical variable.

source

DisjunctiveProgramming.is_gdp_model — Method

is_gdp_model(model::JuMP.AbstractModel)::Bool

Return if model was created via the GDPModel constructor.

source

DisjunctiveProgramming.reformulate_disjunct_constraint — Method

reformulate_disjunct_constraint(
    model::JuMP.AbstractModel,  
    con::JuMP.AbstractConstraint, 
    bvref::Union{JuMP.AbstractVariableRef, JuMP.GenericAffExpr},
    method::AbstractReformulationMethod
)

Extension point for reformulation method method to reformulate disjunction constraint con over each constraint. If method needs to specify how to reformulate the entire disjunction, see reformulate_disjunction.

source

DisjunctiveProgramming.reformulate_disjunction — Method

reformulate_disjunction(
    model::JuMP.AbstractModel, 
    disj::Disjunction,
    method::AbstractReformulationMethod
) where {T<:Disjunction}

Reformulate a disjunction using the specified method. Current reformulation methods include BigM, Hull, and Indicator. This method can be extended for other reformulation techniques.

The disj field is the ConstraintData object for the disjunction, stored in the disjunctions field of the GDPData object.

source

DisjunctiveProgramming.reformulate_model — Function

reformulate_model(model::JuMP.AbstractModel, method::AbstractSolutionMethod = BigM())

Reformulate a GDPModel using the specified method. Prior to reformulation, all previous reformulation variables and constraints are deleted.

source

DisjunctiveProgramming.requires_exactly1 — Method

requires_exactly1(method::AbstractReformulationMethod)

Return a Bool whether method requires that Exactly 1 disjunct be selected as true for each disjunction. For new reformulation method types, this should be extended to return true if such a constraint is required (defaults to false otherwise).

source

DisjunctiveProgramming.requires_variable_bound_info — Method

requires_variable_bound_info(method::AbstractReformulationMethod)::Bool

Return a Bool whether method requires variable bound information accessed via variable_bound_info. This should be extended for new AbstractReformulationMethod methods if needed (defaults to false). If a new method does require variable bound information, then set_variable_bound_info should also be extended.

source

DisjunctiveProgramming.set_variable_bound_info — Function

set_variable_bound_info(vref, method::AbstractReformulationMethod)::Tuple{<:Number, <:Number}

Returns a tuple of the form (lower_bound, upper_bound) which are the bound information needed by method to reformulate disjunctions. This only needs to be implemented for methods where requires_variable_bound_info(method) = true. These bounds can later be accessed via variable_bound_info.

source

DisjunctiveProgramming.variable_bound_info — Method

variable_bound_info(vref::JuMP.AbstractVariableRef)::Tuple{<:Number, <:Number}

Returns a tuple of the form (lower_bound, upper_bound) needed to implement reformulation methods. Only works if requires_variable_bound_info is implemented.

source

DisjunctiveProgramming.variable_copy — Method

variable_copy(model::JuMP.AbstractModel, vref::JuMP.AbstractVariableRef)::JuMP.AbstractVariableRef

Creates a copy of the variable vref in the given model. The new variable will have the same properties (bounds, fixed value, start value, name, and type) as vref but will be added to model as a distinct variable. This is useful for transferring variables between models or duplicating variable definitions in reformulations.

source

JuMP.add_constraint — Function

JuMP.add_constraint(
    model::JuMP.AbstractModel,
    con::_DisjunctConstraint,
    name::String = ""
)::DisjunctConstraintRef

Extend JuMP.add_constraint to add a Disjunct to a GDPModel. The constraint is added to the GDPData in the .ext dictionary of the GDPModel.

source

JuMP.add_constraint — Method

function JuMP.add_constraint(
    model::JuMP.GenericModel,
    c::JuMP.ScalarConstraint{_LogicalExpr, MOI.EqualTo{Bool}},
    name::String = ""
)

Extend JuMP.add_constraint to allow creating logical proposition constraints for a GDPModel with the @constraint macro. Users should define logical constraints via the syntax @constraint(model, logical_expr := true).

source

JuMP.add_constraint — Method

function JuMP.add_constraint(
    model::JuMP.GenericModel,
    c::VectorConstraint{<:F, S},
    name::String = ""
) where {F <: Vector{<:LogicalVariableRef}, S <: AbstractCardinalitySet}

Extend JuMP.add_constraint to allow creating logical cardinality constraints for a GDPModel with the @constraint macro.

source

JuMP.add_variable — Function

JuMP.add_variable(
    model::JuMP.Model,
    v::LogicalVariable, 
    name::String = ""
    )::LogicalVariableRef

Extend JuMP.add_variable for LogicalVariables. This helps enable @variable(model, [var_expr], Logical).

source

JuMP.build_constraint — Method

JuMP.build_constraint(
    _error::Function,
    func,
    set::_MOI.AbstractScalarSet,
    tag::Disjunct
)::_DisjunctConstraint

Extend JuMP.build_constraint to add constraints to disjuncts. This in combination with JuMP.add_constraint enables the use of @constraint(model, [name], constr_expr, tag), where tag is a Disjunct(::Type{LogicalVariableRef}). The user must specify the LogicalVariable to use as the indicator for the _DisjunctConstraint being created.

source

JuMP.build_constraint — Method

JuMP.build_constraint(
    _error::Function,
    func,
    set::MathOptInterface.Nonnegatives,
    tag::Disjunct
)::_DisjunctConstraint