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.

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);`

DisjunctiveProgramming.binary_variable — Method

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.

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.

DisjunctiveProgramming.gdp_data — Method

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

Extract the GDPData from a GDPModel.

DisjunctiveProgramming.is_gdp_model — Method

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

Return if model was created via the GDPModel constructor.

DisjunctiveProgramming.make_disaggregated_variable — Method

make_disaggregated_variable(
    model::JuMP.AbstractModel, 
    vref::JuMP.AbstractVariableRef, 
    name::String, 
    lower_bound::Number, 
    upper_bound::Number
    )::JuMP.AbstractVariableRef

Creates and adds a variable to model with name name and bounds lower_bound and upper_bound based on the original variable vref. This is used to create dissagregated variables needed for the Hull reformulation. This is implemented for model::JuMP.GenericModel and vref::JuMP.GenericVariableRef, but it serves as an extension point for interfaces with other model/variable reference types. This also requires the implementation of requires_disaggregation.

DisjunctiveProgramming.reformulate_disjunct_constraint — Method

reformulate_disjunct_constraint(
    model::JuMP.AbstractModel,  
    con::JuMP.AbstractConstraint, 
    bvref::JuMP.AbstractVariableRef,
    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.

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.

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.

DisjunctiveProgramming.requires_disaggregation — Method

requires_disaggregation(vref::JuMP.AbstractVariableRef)::Bool

Return a Bool whether vref requires disaggregation for the Hull reformulation. This is intended as an extension point for interfaces with DisjunctiveProgramming that use variable reference types that are not JuMP.GenericVariableRefs. Errors if vref is not a JuMP.GenericVariableRef. See also make_disaggregated_variable.

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).

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.

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.

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.

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.

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).

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.

JuMP.add_variable — Function

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

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

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.

JuMP.build_constraint — Method

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