BoundDecomposition(model::JuMP.Model)

Create a decomposition using z for bound constraints and y for all other constraints.

ConvexQP(model::JuMP.Model)

Create a decomposition using z for the quadratic slacks and y for all constraints.

GenericDecomposition(model::JuMP.Model, y_ref::Vector{JuMP.ConstraintRef})

Create a decomposition using z for all constraints except y_ref.

build_cache(model::JuMP.Model, decomposition::AbstractDecomposition;
    optimizer=nothing, proj_fn=nothing, dll_layer_builder=nothing
)

Build the DLLCache for the given model and decomposition. In this lower-level function (compared to decompose!), users can set custom projection functions via proj_fn and custom DLL layer builders via dll_layer_builder.

decompose!(model::JuMP.Model, decomposition::AbstractDecomposition)

Build the DLL functions using the given decomposition.

decompose!(model::JuMP.Model)

Detect the best decomposition and build the DLL functions.

dual_objective(model::JuMP.Model, y_predicted, param_value)

Evaluate the dual objective function (projection and completion).

dual_objective_gradient(model::JuMP.Model, y_predicted, param_value; ad_type::ADTypes.AbstractADType=DI.AutoForwardDiff())

Evaluate the gradient of the dual objective function with respect to the predicted dual variables. This includes both the projection and the completion steps.

flatten_y(y)

Flatten a vector of y variables into a single vector, i.e. Vector{Vector{Float64}} -> Vector{Float64}.

get_cache(model::JuMP.Model)

Get the DLLCache for the model. Must have called decompose! first.

get_y(model::JuMP.Model)

Get the primal constraints corresponding to the y variables in the decomposition.

get_y_dual(model::JuMP.Model)

Get the dual variables corresponding to the y variables in the decomposition. These are VariableRefs belonging to the dual model, not the passed-in model.

jump_builder(decomposition::AbstractDecomposition, proj_fn::Function, dual_model::JuMP.Model, optimizer; silent=true)

Build the completion function using JuMP to solve the model.

make_completion_model(cache::DLLCache)

Create a JuMP model for the dual completion step.

make_proj_fn(decomposition::AbstractDecomposition, dual_model::JuMP.Model)

Create a function that projects the raw dual variable predictions onto their dual cone constraints.

unflatten_y(y::Vector{T}, y_shape::Vector{Int}) where T

Unflatten a vector of flattened y variables into a vector of vectors, i.e. Vector{Float64} -> Vector{Vector{Float64}}.

y_shape(model::JuMP.Model)

Get the shape of the y variables in the decomposition. This is a Vector{Int} where each entry is the number of dual variables for that constraint.