licenses
sequencelengths 1
3
| version
stringclasses 677
values | tree_hash
stringlengths 40
40
| path
stringclasses 1
value | type
stringclasses 2
values | size
stringlengths 2
8
| text
stringlengths 25
67.1M
| package_name
stringlengths 2
41
| repo
stringlengths 33
86
|
|---|---|---|---|---|---|---|---|---|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 5336 | ############################################################################################
# SingleVarBranchingCandidate
############################################################################################
"""
SingleVarBranchingCandidate
It is an implementation of AbstractBranchingCandidate.
This is the type of branching candidates produced by the branching rule
`SingleVarBranchingRule`.
"""
mutable struct SingleVarBranchingCandidate <: Branching.AbstractBranchingCandidate
varname::String
varid::VarId
local_id::Int64
lhs::Float64
function SingleVarBranchingCandidate(
varname::String, varid::VarId, local_id::Int64, lhs::Float64
)
return new(varname, varid, local_id, lhs)
end
end
Branching.getdescription(candidate::SingleVarBranchingCandidate) = candidate.varname
Branching.get_lhs(candidate::SingleVarBranchingCandidate) = candidate.lhs
Branching.get_local_id(candidate::SingleVarBranchingCandidate) = candidate.local_id
function get_branching_candidate_units_usage(::SingleVarBranchingCandidate, reform)
units_to_restore = UnitsUsage()
master = getmaster(reform)
push!(units_to_restore.units_used, (master, MasterBranchConstrsUnit))
return units_to_restore
end
function Branching.generate_children!(
ctx, candidate::SingleVarBranchingCandidate, env::Env, reform::Reformulation, input
)
master = getmaster(reform)
lhs = Branching.get_lhs(candidate)
@logmsg LogLevel(-1) string(
"Chosen branching variable : ",
getname(master, candidate.varid), " with value ", lhs, "."
)
units_to_restore = get_branching_candidate_units_usage(candidate, reform)
d = Branching.get_parent_depth(input)
parent_ip_dual_bound = get_ip_dual_bound(Branching.get_conquer_opt_state(input))
# adding the first branching constraints
restore_from_records!(units_to_restore, Branching.parent_records(input))
setconstr!(
master,
string("branch_geq_", d, "_", getname(master,candidate.varid)),
MasterBranchOnOrigVarConstr;
sense = Greater,
rhs = ceil(lhs),
loc_art_var_abs_cost = env.params.local_art_var_cost,
members = Dict{VarId,Float64}(candidate.varid => 1.0)
)
child1description = candidate.varname * ">=" * string(ceil(lhs))
child1 = SbNode(d+1, child1description, parent_ip_dual_bound, create_records(reform))
# adding the second branching constraints
restore_from_records!(units_to_restore, Branching.parent_records(input))
setconstr!(
master,
string("branch_leq_", d, "_", getname(master,candidate.varid)),
MasterBranchOnOrigVarConstr;
sense = Less,
rhs = floor(lhs),
loc_art_var_abs_cost = env.params.local_art_var_cost,
members = Dict{VarId,Float64}(candidate.varid => 1.0)
)
child2description = candidate.varname * "<=" * string(floor(lhs))
child2 = SbNode(d+1, child2description, parent_ip_dual_bound, create_records(reform))
return [child1, child2]
end
############################################################################################
# SingleVarBranchingRule
############################################################################################
"""
SingleVarBranchingRule
This branching rule allows the divide algorithm to branch on single integer variables.
For instance, `SingleVarBranchingRule` can produce the branching `x <= 2` and `x >= 3`
where `x` is a scalar integer variable.
"""
struct SingleVarBranchingRule <: Branching.AbstractBranchingRule end
# SingleVarBranchingRule does not have child algorithms
function get_units_usage(::SingleVarBranchingRule, reform::Reformulation)
return [(getmaster(reform), MasterBranchConstrsUnit, READ_AND_WRITE)]
end
# TODO : unit tests (especially branching priority).
function Branching.apply_branching_rule(::SingleVarBranchingRule, env::Env, reform::Reformulation, input::Branching.BranchingRuleInput)
# Single variable branching works only for the original solution.
if !input.isoriginalsol
return SingleVarBranchingCandidate[]
end
master = getmaster(reform)
@assert !isnothing(input.solution)
# We do not consider continuous variables and variables with integer value in the
# current solution as branching candidates.
candidate_vars = Iterators.filter(
((var_id, val),) -> !is_cont_var(master, var_id) && !is_int_val(val, input.int_tol),
input.solution
)
max_priority = mapreduce(
((var_id, _),) -> getbranchingpriority(master, var_id),
max,
candidate_vars;
init = -Inf
)
if max_priority == -Inf
return SingleVarBranchingCandidate[]
end
# We select all the variables that have the maximum branching prority.
candidates = reduce(
candidate_vars; init = SingleVarBranchingCandidate[]
) do collection, (var_id, val)
br_priority = getbranchingpriority(master, var_id)
if br_priority == max_priority
name = getname(master, var_id)
local_id = input.local_id + length(collection) + 1
candidate = SingleVarBranchingCandidate(name, var_id, local_id, val)
push!(collection, candidate)
end
return collection
end
return candidates
end | Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 38735 | """
ColGenContext(reformulation, algo_params) -> ColGenContext
Creates a context to run the default implementation of the column generation algorithm.
"""
mutable struct ColGenContext <: ColGen.AbstractColGenContext
reform::Reformulation
optim_sense # TODO: type
current_ip_primal_bound # TODO: type
restr_master_solve_alg # TODO: type
restr_master_optimizer_id::Int
stages_pricing_solver_ids::Vector{Int}
strict_integrality_check::Bool
reduced_cost_helper::ReducedCostsCalculationHelper
subgradient_helper::SubgradientCalculationHelper
sp_var_redcosts::Union{Nothing,Any} # TODO: type
show_column_already_inserted_warning::Bool
throw_column_already_inserted_warning::Bool
nb_colgen_iteration_limit::Int
opt_rtol::Float64
opt_atol::Float64
incumbent_primal_solution::Union{Nothing,PrimalSolution}
# stabilization
stabilization::Bool
self_adjusting_α::Bool
init_α::Float64
function ColGenContext(reform, alg)
rch = ReducedCostsCalculationHelper(getmaster(reform))
sh = SubgradientCalculationHelper(getmaster(reform))
stabilization, self_adjusting_α, init_α = _stabilization_info(alg)
return new(
reform,
getobjsense(reform),
0.0,
alg.restr_master_solve_alg,
alg.restr_master_optimizer_id,
alg.stages_pricing_solver_ids,
alg.strict_integrality_check,
rch,
sh,
nothing,
alg.show_column_already_inserted_warning,
alg.throw_column_already_inserted_warning,
alg.max_nb_iterations,
alg.opt_rtol,
alg.opt_atol,
nothing,
stabilization,
self_adjusting_α,
init_α
)
end
end
function _stabilization_info(alg)
s = alg.smoothing_stabilization
if s > 0.0
automatic = s == 1
return true, automatic, automatic ? 0.5 : s
end
return false, false, 0.0
end
subgradient_helper(ctx::ColGenContext) = ctx.subgradient_helper
ColGen.get_reform(ctx::ColGenContext) = ctx.reform
ColGen.get_master(ctx::ColGenContext) = getmaster(ctx.reform)
ColGen.is_minimization(ctx::ColGenContext) = getobjsense(ctx.reform) == MinSense
ColGen.get_pricing_subprobs(ctx::ColGenContext) = get_dw_pricing_sps(ctx.reform)
# ColGen.setup_stabilization!(ctx, master) = ColGenStab(master)
function ColGen.setup_stabilization!(ctx::ColGenContext, master)
if ctx.stabilization
return ColGenStab(master, ctx.self_adjusting_α, ctx.init_α)
end
return NoColGenStab()
end
"Output of the default implementation of a phase of the column generation algorithm."
struct ColGenPhaseOutput <: ColGen.AbstractColGenPhaseOutput
master_lp_primal_sol::Union{Nothing,PrimalSolution}
master_ip_primal_sol::Union{Nothing,PrimalSolution}
master_lp_dual_sol::Union{Nothing,DualSolution}
ipb::Union{Nothing,Float64}
mlp::Union{Nothing,Float64}
db::Union{Nothing,Float64}
new_cut_in_master::Bool
no_more_columns::Bool
infeasible::Bool
exact_stage::Bool
time_limit_reached::Bool
nb_iterations::Int
min_sense::Bool
end
"Output of the default implementation of the column generation algorithm."
struct ColGenOutput <: ColGen.AbstractColGenOutput
master_lp_primal_sol::Union{Nothing,PrimalSolution}
master_ip_primal_sol::Union{Nothing,PrimalSolution}
master_lp_dual_sol::Union{Nothing,DualSolution}
ipb::Union{Nothing,Float64}
mlp::Union{Nothing,Float64}
db::Union{Nothing,Float64}
infeasible::Bool
end
function ColGen.new_output(::Type{<:ColGenOutput}, output::ColGenPhaseOutput)
return ColGenOutput(
output.master_lp_primal_sol,
output.master_ip_primal_sol,
output.master_lp_dual_sol,
output.ipb,
output.mlp,
output.db,
output.infeasible
)
end
ColGen.colgen_output_type(::ColGenContext) = ColGenOutput
ColGen.stop_colgen(::ColGenContext, ::Nothing) = false
function ColGen.stop_colgen(ctx::ColGenContext, output::ColGenPhaseOutput)
return output.infeasible ||
output.time_limit_reached ||
output.nb_iterations >= ctx.nb_colgen_iteration_limit
end
ColGen.is_infeasible(output::ColGenOutput) = output.infeasible
ColGen.get_master_ip_primal_sol(output::ColGenOutput) = output.master_ip_primal_sol
ColGen.get_master_lp_primal_sol(output::ColGenOutput) = output.master_lp_primal_sol
ColGen.get_master_dual_sol(output::ColGenOutput) = output.master_lp_dual_sol
ColGen.get_dual_bound(output::ColGenOutput) = output.db
ColGen.get_master_lp_primal_bound(output::ColGenOutput) = output.mlp
function ColGen.is_better_dual_bound(ctx::ColGenContext, new_dual_bound, dual_bound)
sc = ColGen.is_minimization(ctx) ? 1 : -1
return sc * new_dual_bound > sc * dual_bound
end
###############################################################################
# Sequence of phases
###############################################################################
"""
Type for the default implementation of the sequence of phases.
"""
struct ColunaColGenPhaseIterator <: ColGen.AbstractColGenPhaseIterator end
ColGen.new_phase_iterator(::ColGenContext) = ColunaColGenPhaseIterator()
"""
Phase 1 sets the cost of variables to 0 except for artifical variables.
The goal is to find a solution to the master LP problem that has no artificial variables.
"""
struct ColGenPhase1 <: ColGen.AbstractColGenPhase end
"""
Phase 2 solves the master LP without artificial variables.
To start, it requires a set of columns that forms a feasible solution to the LP master.
This set is found with phase 1.
"""
struct ColGenPhase2 <: ColGen.AbstractColGenPhase end
"""
Phase 0 is a mix of phase 1 and phase 2.
It sets a very large cost to artifical variables to force them to be removed from the master
LP solution.
If the final master LP solution contains artifical variables either the master is infeasible
or the cost of artificial variables is not large enough. Phase 1 must be run.
"""
struct ColGenPhase0 <: ColGen.AbstractColGenPhase end
"""
Thrown when the phase ended with an unexpected output.
The algorithm cannot continue because theory is not verified.
"""
struct UnexpectedEndOfColGenPhase end
# Implementation of ColGenPhase interface
## Implementation of `initial_phase`.
ColGen.initial_phase(::ColunaColGenPhaseIterator) = ColGenPhase0()
function colgen_mast_lp_sol_has_art_vars(output::ColGenPhaseOutput)
master_lp_primal_sol = output.master_lp_primal_sol
if isnothing(master_lp_primal_sol)
return false
end
return contains(master_lp_primal_sol, varid -> isanArtificialDuty(getduty(varid)))
end
colgen_master_has_new_cuts(output::ColGenPhaseOutput) = output.new_cut_in_master
colgen_uses_exact_stage(output::ColGenPhaseOutput) = output.exact_stage
function colgen_has_converged(output::ColGenPhaseOutput)
# Check if master LP and dual bound converged.
db_mlp = !isnothing(output.mlp) && !isnothing(output.db) && (
abs(output.mlp - output.db) < 1e-5 ||
(output.min_sense && output.db >= output.mlp) ||
(!output.min_sense && output.db <= output.mlp)
)
# Check is global IP bound and dual bound converged.
db_ipb = !isnothing(output.ipb) && !isnothing(output.db) && (
abs(output.ipb - output.db) < 1e-5 ||
(output.min_sense && output.db >= output.ipb) ||
(!output.min_sense && output.db <= output.ipb)
)
return db_mlp || db_ipb
end
colgen_has_no_new_cols(output::ColGenPhaseOutput) = output.no_more_columns
## Implementation of `next_phase`.
function ColGen.next_phase(::ColunaColGenPhaseIterator, ::ColGenPhase1, output::ColGen.AbstractColGenPhaseOutput)
if colgen_mast_lp_sol_has_art_vars(output) && colgen_has_converged(output) && colgen_uses_exact_stage(output)
return nothing # infeasible
end
# If the master lp solution still has artificial variables, we restart the phase.
# If there is a new essential cut in the master, we restart the phase.
if colgen_mast_lp_sol_has_art_vars(output) || colgen_master_has_new_cuts(output)
return ColGenPhase1()
end
return ColGenPhase2()
end
function ColGen.next_phase(::ColunaColGenPhaseIterator, ::ColGenPhase2, output::ColGen.AbstractColGenPhaseOutput)
if colgen_mast_lp_sol_has_art_vars(output)
# No artificial variables in formulation for phase 2, so this case is impossible.
throw(UnexpectedEndOfColGenPhase())
end
# If we converged using exact stage and there is no new cut in the master, column generation is done.
if !colgen_master_has_new_cuts(output) && colgen_has_converged(output) && colgen_uses_exact_stage(output)
return nothing
end
# If there is a new essential cut in the master, we go the phase 1 to prevent infeasibility.
if colgen_master_has_new_cuts(output)
return ColGenPhase1()
end
return ColGenPhase2()
end
function ColGen.next_phase(::ColunaColGenPhaseIterator, ::ColGenPhase0, output::ColGen.AbstractColGenPhaseOutput)
# Column generation converged.
if !colgen_mast_lp_sol_has_art_vars(output) &&
!colgen_master_has_new_cuts(output) &&
colgen_has_converged(output) &&
colgen_uses_exact_stage(output)
return nothing
end
# If the master lp solution still has artificial variables, we start pahse 1.
if colgen_mast_lp_sol_has_art_vars(output) &&
!colgen_master_has_new_cuts(output) &&
colgen_uses_exact_stage(output)
return ColGenPhase1()
end
return ColGenPhase0()
end
# Implementatation of `setup_reformulation!`
## Phase 1 => non-artifical variables have cost equal to 0
function ColGen.setup_reformulation!(reform, ::ColGenPhase1)
master = getmaster(reform)
for (varid, _) in getvars(master)
if !isanArtificialDuty(getduty(varid))
setcurcost!(master, varid, 0.0)
end
end
return
end
## Phase 2 => deactivate artifical variables and make sure that the cost of non-artifical
## variables is correct.
function ColGen.setup_reformulation!(reform, ::ColGenPhase2)
master = getmaster(reform)
for (varid, var) in getvars(master)
if isanArtificialDuty(getduty(varid))
deactivate!(master, varid)
else
setcurcost!(master, varid, getperencost(master, var))
end
end
return
end
## Phase 0 => make sure artifical variables are active and cost is correct.
function ColGen.setup_reformulation!(reform, ::ColGenPhase0)
master = getmaster(reform)
for (varid, var) in getvars(master)
if isanArtificialDuty(getduty(varid))
activate!(master, varid)
end
setcurcost!(master, varid, getperencost(master, var))
end
return
end
function ColGen.setup_context!(ctx::ColGenContext, phase::ColGen.AbstractColGenPhase)
ctx.reduced_cost_helper = ReducedCostsCalculationHelper(ColGen.get_master(ctx))
return
end
###############################################################################
# Column generation stages
###############################################################################
"""
Default implementation of the column generation stages works as follows.
Consider a set {A,B,C} of subproblems each of them associated to the following
sets of pricing solvers: {a1, a2, a3}, {b1, b2}, {c1, c2, c3, c4}.
Pricing solvers a1, b1, c1 are exact solvers; others are heuristic.
The column generation algorithm will run the following stages:
- stage 4 with pricing solvers {a3, b2, c4}
- stage 3 with pricing solvers {a2, b1, c3}
- stage 2 with pricing solvers {a1, b1, c2}
- stage 1 with pricing solvers {a1, b1, c1} (exact stage)
Column generation moves from one stage to another when all solvers find no column.
"""
struct ColGenStageIterator <: ColGen.AbstractColGenStageIterator
nb_stages::Int
optimizers_per_pricing_prob::Dict{FormId, Vector{Int}}
end
struct ColGenStage <: ColGen.AbstractColGenStage
current_stage::Int
cur_optimizers_id_per_pricing_prob::Dict{FormId, Int}
end
ColGen.stage_id(stage::ColGenStage) = stage.current_stage
ColGen.is_exact_stage(stage::ColGenStage) = ColGen.stage_id(stage) == 1
ColGen.get_pricing_subprob_optimizer(stage::ColGenStage, form) = stage.cur_optimizers_id_per_pricing_prob[getuid(form)]
function ColGen.new_stage_iterator(ctx::ColGenContext)
# TODO: At the moment, the optimizer id defined at each stage stage applies to all
# pricing subproblems. In the future, we would like to have a different optimizer id
# for each pricing subproblem but we need to change the user interface. A solution would
# be to allow the user to retrieve the "future id" of the subproblem from BlockDecomposition.
# Another solution would be to allow the user to mark the solvers in `specify`.
optimizers = Dict(
form_id => ctx.stages_pricing_solver_ids ∩ collect(1:length(getoptimizers(form)))
for (form_id, form) in ColGen.get_pricing_subprobs(ctx)
)
nb_stages = maximum(length.(values(optimizers)))
return ColGenStageIterator(nb_stages, optimizers)
end
function ColGen.initial_stage(it::ColGenStageIterator)
first_stage = maximum(length.(values(it.optimizers_per_pricing_prob)))
optimizers_id_per_pricing_prob = Dict{FormId, Int}(
form_id => last(optimizer_ids)
for (form_id, optimizer_ids) in it.optimizers_per_pricing_prob
)
return ColGenStage(first_stage, optimizers_id_per_pricing_prob)
end
function ColGen.decrease_stage(it::ColGenStageIterator, cur_stage::ColGenStage)
if ColGen.is_exact_stage(cur_stage)
return nothing
end
new_stage_id = ColGen.stage_id(cur_stage) - 1
optimizers_id_per_pricing_prob = Dict(
form_id => pricing_solver_ids[max(1, (new_stage_id - it.nb_stages + length(pricing_solver_ids)))]
for (form_id, pricing_solver_ids) in it.optimizers_per_pricing_prob
)
return ColGenStage(new_stage_id, optimizers_id_per_pricing_prob)
end
function ColGen.next_stage(it::ColGenStageIterator, cur_stage::ColGenStage, output)
if colgen_master_has_new_cuts(output)
return ColGen.initial_stage(it)
end
if colgen_has_no_new_cols(output) && !colgen_has_converged(output)
return ColGen.decrease_stage(it, cur_stage)
end
return cur_stage
end
###############################################################################
# Master resolution
###############################################################################
"""
Output of the `ColGen.optimize_master_lp_problem!` method.
Contains `result`, an `OptimizationState` object that is the output of the `SolveLpForm` algorithm
called to optimize the master LP problem.
"""
struct ColGenMasterResult{F}
result::OptimizationState{F}
end
# TODO: not type stable !!
function ColGen.optimize_master_lp_problem!(master, ctx::ColGenContext, env)
rm_input = OptimizationState(master, ip_primal_bound=ctx.current_ip_primal_bound)
opt_state = run!(ctx.restr_master_solve_alg, env, master, rm_input, ctx.restr_master_optimizer_id)
return ColGenMasterResult(opt_state)
end
function ColGen.is_infeasible(master_res::ColGenMasterResult)
status = getterminationstatus(master_res.result)
return status == ClB.INFEASIBLE
end
function ColGen.is_unbounded(master_res::ColGenMasterResult)
status = getterminationstatus(master_res.result)
return status == ClB.UNBOUNDED
end
ColGen.get_primal_sol(master_res::ColGenMasterResult) = get_best_lp_primal_sol(master_res.result)
ColGen.get_dual_sol(master_res::ColGenMasterResult) = get_best_lp_dual_sol(master_res.result)
ColGen.get_obj_val(master_res::ColGenMasterResult) = get_lp_primal_bound(master_res.result)
function ColGen.update_master_constrs_dual_vals!(ctx::ColGenContext, master_lp_dual_sol)
master = ColGen.get_master(ctx)
# Set all dual value of all constraints to 0.
for constr in Iterators.values(getconstrs(master))
setcurincval!(master, constr, 0.0)
end
# Update constraints that have non-zero dual values.
for (constr_id, val) in master_lp_dual_sol
setcurincval!(master, constr_id, val)
end
return
end
function ColGen.update_reduced_costs!(ctx::ColGenContext, phase, red_costs)
ctx.sp_var_redcosts = red_costs
return
end
function _violates_essential_cuts!(master, master_lp_primal_sol, env)
cutcb_input = CutCallbacksInput(master_lp_primal_sol)
cutcb_output = run!(
CutCallbacks(call_robust_facultative=false),
env, master, cutcb_input
)
return cutcb_output.nb_cuts_added > 0
end
ColGen.check_primal_ip_feasibility!(_, ctx::ColGenContext, ::ColGenPhase1, _) = nothing, false
function ColGen.check_primal_ip_feasibility!(master_lp_primal_sol, ctx::ColGenContext, phase, env)
# Check if feasible.
if contains(master_lp_primal_sol, varid -> isanArtificialDuty(getduty(varid)))
return nothing, false
end
# Check if integral.
primal_sol_is_integer = ctx.strict_integrality_check ? isinteger(master_lp_primal_sol) :
MathProg.proj_cols_is_integer(master_lp_primal_sol)
if !primal_sol_is_integer
return nothing, false
end
# Check if violated essential cuts
new_cut_in_master = _violates_essential_cuts!(ColGen.get_master(ctx), master_lp_primal_sol, env)
# Returns disaggregated solution if feasible and integral.
return master_lp_primal_sol, new_cut_in_master
end
# In our column generation default implementation, when we found a new IP primal solution,
# we push it in the GlobalPrimalBoundHandler object that stores the incumbent IP primal solution
# of the B&B algorithm. It is possible to redefine this function to use another type of primal
# solution manager.
function ColGen.is_better_primal_sol(new_ip_primal_sol::PrimalSolution, ip_primal_sol::GlobalPrimalBoundHandler)
new_val = ColunaBase.getvalue(new_ip_primal_sol)
cur_val = ColunaBase.getvalue(get_global_primal_bound(ip_primal_sol))
sc = MathProg.getobjsense(ColunaBase.getmodel(new_ip_primal_sol)) == MinSense ? 1 : -1
return sc * new_val < sc * cur_val && abs(new_val - cur_val) > 1e-6
end
function ColGen.update_inc_primal_sol!(::ColGenContext, ip_primal_sol, new_ip_primal_sol)
store_ip_primal_sol!(ip_primal_sol, new_ip_primal_sol)
return
end
# Reduced costs calculation
ColGen.get_subprob_var_orig_costs(ctx::ColGenContext) = ctx.reduced_cost_helper.dw_subprob_c
ColGen.get_subprob_var_coef_matrix(ctx::ColGenContext) = ctx.reduced_cost_helper.dw_subprob_A
function ColGen.update_sp_vars_red_costs!(ctx::ColGenContext, sp::Formulation{DwSp}, red_costs)
for (var_id, _) in getvars(sp)
setcurcost!(sp, var_id, red_costs[var_id])
end
return
end
# Columns insertion
_set_column_cost!(master, col_id, phase) = nothing
_set_column_cost!(master, col_id, ::ColGenPhase1) = setcurcost!(master, col_id, 0.0)
function ColGen.insert_columns!(ctx::ColGenContext, phase, columns)
reform = ColGen.get_reform(ctx)
primal_sols_to_insert = PrimalSolution{Formulation{DwSp}}[]
col_ids_to_activate = Set{VarId}()
master = ColGen.get_master(ctx)
for column in columns
col_id = get_column_from_pool(column.column)
if !isnothing(col_id)
if haskey(master, col_id) && !iscuractive(master, col_id)
push!(col_ids_to_activate, col_id)
else
in_master = haskey(master, col_id)
is_active = iscuractive(master, col_id)
warning = ColumnAlreadyInsertedColGenWarning(
in_master, is_active, column.red_cost, col_id, master, column.column.solution.model
)
if ctx.show_column_already_inserted_warning
@warn warning
end
if ctx.throw_column_already_inserted_warning
throw(warning)
end
end
else
push!(primal_sols_to_insert, column.column)
end
end
nb_added_cols = 0
nb_reactivated_cols = 0
# Then, we add the new columns (i.e. not in the pool).
col_ids = VarId[]
for sol in primal_sols_to_insert
col_id = insert_column!(master, sol, "MC")
_set_column_cost!(master, col_id, phase)
push!(col_ids, col_id)
nb_added_cols += 1
end
# And we reactivate the deactivated columns already generated.
for col_id in col_ids_to_activate
activate!(master, col_id)
_set_column_cost!(master, col_id, phase)
push!(col_ids, col_id)
nb_reactivated_cols += 1
end
return col_ids
end
#############################################################################
# Pricing strategy
#############################################################################
struct ClassicColGenPricingStrategy <: ColGen.AbstractPricingStrategy
subprobs::Dict{FormId, Formulation{DwSp}}
end
ColGen.get_pricing_strategy(ctx::ColGen.AbstractColGenContext, _) = ClassicColGenPricingStrategy(ColGen.get_pricing_subprobs(ctx))
ColGen.pricing_strategy_iterate(ps::ClassicColGenPricingStrategy) = iterate(ps.subprobs)
ColGen.pricing_strategy_iterate(ps::ClassicColGenPricingStrategy, state) = iterate(ps.subprobs, state)
#############################################################################
# Column generation
#############################################################################
function ColGen.compute_sp_init_db(ctx::ColGenContext, sp::Formulation{DwSp})
return ctx.optim_sense == MinSense ? -Inf : Inf
end
function ColGen.compute_sp_init_pb(ctx::ColGenContext, sp::Formulation{DwSp})
return ctx.optim_sense == MinSense ? Inf : -Inf
end
"""
Solution to a pricing subproblem after a given optimization.
It contains:
- `column`: the solution stored as a `PrimalSolution` object
- `red_cost`: the reduced cost of the column
- `min_obj`: a boolean indicating if the objective is to minimize or maximize
"""
struct GeneratedColumn
column::PrimalSolution{Formulation{DwSp}}
red_cost::Float64
min_obj::Bool # TODO remove when formulation will be parametrized by the sense.
function GeneratedColumn(column, red_cost)
min_obj = getobjsense(column.solution.model) == MinSense
return new(column, red_cost, min_obj)
end
end
"""
Columns generated at the current iteration that forms the "current primal solution".
This is used to compute the Lagragian dual bound.
It contains:
- `primal_sols` a dictionary that maps a formulation id to the best primal solution found by the pricing subproblem associated to this formulation
- `improve_master` a dictionary that maps a formulation id to a boolean indicating if the best primal solution found by the pricing subproblem associated to this formulation has negative reduced cost
This structure also helps to compute the subgradient of the Lagrangian function.
"""
struct SubprobPrimalSolsSet
primal_sols::Dict{MathProg.FormId, MathProg.PrimalSolution{MathProg.Formulation{MathProg.DwSp}}}
improve_master::Dict{MathProg.FormId, Bool}
function SubprobPrimalSolsSet()
return new(Dict{FormId, PrimalSolution{Formulation{DwSp}}}(), Dict{FormId, Bool}())
end
end
function add_primal_sol!(sps::SubprobPrimalSolsSet, primal_sol::PrimalSolution{Formulation{DwSp}}, improves::Bool)
form_id = getuid(primal_sol.solution.model)
cur_primal_sol = get(sps.primal_sols, form_id, nothing)
sc = getobjsense(primal_sol.solution.model) == MinSense ? 1 : -1
if isnothing(cur_primal_sol) || sc * getvalue(primal_sol) < sc * getvalue(cur_primal_sol)
sps.primal_sols[form_id] = primal_sol
sps.improve_master[form_id] = improves
return true
end
return false
end
"""
Stores a collection of columns.
It contains:
- `columns`: a vector of `GeneratedColumn` objects by all pricing subproblems that will be inserted into the master
- `subprob_primal_solutions`: an object that stores the best columns generated by each pricing subproblem at this iteration.
"""
struct ColumnsSet
# Columns that will be added to the master.
columns::Vector{GeneratedColumn}
# Columns generated at the current iterations that forms the "current primal solution".
# This is used to compute the subgradient for "Smoothing with a self adjusting
# parameter" stabilization.
subprob_primal_sols::SubprobPrimalSolsSet
ColumnsSet() = new(GeneratedColumn[], SubprobPrimalSolsSet())
end
Base.iterate(set::ColumnsSet) = iterate(set.columns)
Base.iterate(set::ColumnsSet, state) = iterate(set.columns, state)
ColGen.set_of_columns(::ColGenContext) = ColumnsSet()
"""
Output of the default implementation of `ColGen.optimize_pricing_problem!`.
It contains:
- `result`: the output of the `SolveIpForm` algorithm called to optimize the pricing subproblem
- `columns`: a vector of `GeneratedColumn` objects obtained by processing of the output of pricing subproblem optimization, it stores the reduced cost of each column
- `best_red_cost`: the best reduced cost of the columns
"""
struct ColGenPricingResult{F}
result::OptimizationState{F}
columns::Vector{GeneratedColumn}
best_red_cost::Float64
end
function ColGen.is_infeasible(pricing_res::ColGenPricingResult)
status = getterminationstatus(pricing_res.result)
return status == ClB.INFEASIBLE
end
function ColGen.is_unbounded(pricing_res::ColGenPricingResult)
status = getterminationstatus(pricing_res.result)
return status == ClB.UNBOUNDED
end
ColGen.get_primal_sols(pricing_res::ColGenPricingResult) = pricing_res.columns
ColGen.get_dual_bound(pricing_res::ColGenPricingResult) = get_ip_dual_bound(pricing_res.result)
ColGen.get_primal_bound(pricing_res::ColGenPricingResult) = get_ip_primal_bound(pricing_res.result)
is_improving_red_cost(ctx::ColGenContext, red_cost) = red_cost > 0 + ctx.opt_atol
is_improving_red_cost_min_sense(ctx::ColGenContext, red_cost) = red_cost < 0 - ctx.opt_atol
function has_improving_red_cost(ctx, column::GeneratedColumn)
if column.min_obj
return is_improving_red_cost_min_sense(ctx, column.red_cost)
end
return is_improving_red_cost(ctx, column.red_cost)
end
# In our implementation of `push_in_set!`, we keep only columns that have improving reduced
# cost.
function ColGen.push_in_set!(ctx::ColGenContext, pool::ColumnsSet, column::GeneratedColumn)
# We keep only columns that improve reduced cost
improving = has_improving_red_cost(ctx, column)
add_primal_sol!(pool.subprob_primal_sols, column.column, improving)
if improving
push!(pool.columns, column)
return true
end
return false
end
function _nonrobust_cuts_contrib(master, col, master_dual_sol)
contrib = 0.0
for (constrid, dual_val) in master_dual_sol
if constrid.custom_family_id != -1
constr = getconstr(master, constrid)
if !isnothing(col.custom_data)
coeff = MathProg.computecoeff(col.custom_data, constr.custom_data)
contrib -= coeff * dual_val
end
end
end
return contrib
end
"""
When we use a smoothed dual solution, we need to recompute the reduced cost of the
subproblem variables using the non-smoothed dual solution (out point).
This reduced cost is stored in the context (field `sp_var_redcosts`) and we use it to compute
the contribution of the subproblem variables.
"""
function _subprob_var_contrib(ctx::ColGenContext, col, stab_changes_mast_dual_sol, master_dual_sol)
if stab_changes_mast_dual_sol
cost = 0.0
for (var_id, val) in col
cost += ctx.sp_var_redcosts[var_id] * val
end
# When using the smoothed dual solution, we also need to recompute the contribution
# of the non-robust cuts.
return cost + _nonrobust_cuts_contrib(ColGen.get_master(ctx), col, master_dual_sol)
end
# When not using stabilization, the value of the column returned by the pricing subproblem
# must take into account the contributions of the subproblem variables and the non-robust cuts.
return getvalue(col)
end
function ColGen.optimize_pricing_problem!(ctx::ColGenContext, sp::Formulation{DwSp}, env, optimizer, master_dual_sol, stab_changes_mast_dual_sol)
input = OptimizationState(sp)
alg = SolveIpForm(
optimizer_id = optimizer,
moi_params = MoiOptimize(
deactivate_artificial_vars = false,
enforce_integrality = false
)
)
opt_state = run!(alg, env, sp, input) # master & master dual sol for non robust cuts
# Reduced cost of a column is composed of
# (A) the cost of the subproblem variables
# (B) the contribution of the master convexity constraints.
# Master convexity constraints contribution is the same for all columns generated by a
# given subproblem.
lb_dual = master_dual_sol[sp.duty_data.lower_multiplicity_constr_id]
ub_dual = master_dual_sol[sp.duty_data.upper_multiplicity_constr_id]
# Compute the reduced cost of each column and keep the best reduced cost value.
is_min = ColGen.is_minimization(ctx)
sc = is_min ? 1 : -1
best_red_cost = is_min ? Inf : -Inf
generated_columns = GeneratedColumn[]
for col in get_ip_primal_sols(opt_state)
# `subprob_var_contrib` includes contribution of non-robust cuts.
subprob_var_contrib = _subprob_var_contrib(ctx, col, stab_changes_mast_dual_sol, master_dual_sol)
red_cost = subprob_var_contrib - lb_dual - ub_dual
push!(generated_columns, GeneratedColumn(col, red_cost))
if sc * best_red_cost > sc * red_cost
best_red_cost = red_cost
end
end
return ColGenPricingResult(opt_state, generated_columns, best_red_cost)
end
function _convexity_contrib(ctx, master_dual_sol)
master = ColGen.get_master(ctx)
contrib = mapreduce(+, ColGen.get_pricing_subprobs(ctx)) do it
_, sp = it
lb_dual = master_dual_sol[sp.duty_data.lower_multiplicity_constr_id]
ub_dual = master_dual_sol[sp.duty_data.upper_multiplicity_constr_id]
lb = getcurrhs(master, sp.duty_data.lower_multiplicity_constr_id)
ub = getcurrhs(master, sp.duty_data.upper_multiplicity_constr_id)
return lb_dual * lb + ub_dual * ub
end
return contrib
end
function _subprob_contrib(ctx, sp_dbs, generated_columns)
master = ColGen.get_master(ctx)
min_sense = ColGen.is_minimization(ctx)
contrib = mapreduce(+, ColGen.get_pricing_subprobs(ctx)) do it
id, sp = it
lb = getcurrhs(master, sp.duty_data.lower_multiplicity_constr_id)
ub = getcurrhs(master, sp.duty_data.upper_multiplicity_constr_id)
db = sp_dbs[id]
improving = min_sense ? is_improving_red_cost_min_sense(ctx, db) : is_improving_red_cost(ctx, db)
mult = improving ? ub : lb
return mult * db
end
return contrib
end
function ColGen.compute_dual_bound(ctx::ColGenContext, phase, sp_dbs, generated_columns, master_dual_sol)
sc = ColGen.is_minimization(ctx) ? 1 : -1
master_lp_obj_val = if ctx.stabilization
partial_sol_val = MathProg.getpartialsolvalue(ColGen.get_master(ctx))
partial_sol_val + (transpose(master_dual_sol) * ctx.subgradient_helper.a_for_dual)
else
getvalue(master_dual_sol) - _convexity_contrib(ctx, master_dual_sol)
end
sp_contrib = _subprob_contrib(ctx, sp_dbs, generated_columns)
# Pure master variables contribution.
# TODO (only when stabilization is used otherwise already taken into account by master obj val
puremastvars_contrib = 0.0
if ctx.stabilization
master = ColGen.get_master(ctx)
master_coef_matrix = getcoefmatrix(master)
for (varid, var) in getvars(master)
if getduty(varid) <= MasterPureVar && iscuractive(master, var) && isexplicit(master, var)
redcost = getcurcost(master, varid)
for (constrid, var_coeff) in @view master_coef_matrix[:,varid]
redcost -= var_coeff * master_dual_sol[constrid]
end
min_sense = ColGen.is_minimization(ctx)
improves = min_sense ? is_improving_red_cost_min_sense(ctx, redcost) : is_improving_red_cost(ctx, redcost)
mult = improves ? getcurub(master, varid) : getcurlb(master, varid)
puremastvars_contrib += redcost * mult
end
end
end
return master_lp_obj_val + sp_contrib + puremastvars_contrib
end
# Iteration output
"Object for the output of an iteration of the column generation default implementation."
struct ColGenIterationOutput <: ColGen.AbstractColGenIterationOutput
min_sense::Bool
ipb::Union{Nothing,Float64}
mlp::Union{Nothing,Float64}
db::Union{Nothing,Float64}
nb_new_cols::Int
new_cut_in_master::Bool
# Equals `true` if the master subsolver returns infeasible.
infeasible_master::Bool
unbounded_master::Bool
# Equals `true` if one of the pricing subsolver returns infeasible.
infeasible_subproblem::Bool
unbounded_subproblem::Bool
time_limit_reached::Bool
master_lp_primal_sol::Union{Nothing, PrimalSolution}
master_ip_primal_sol::Union{Nothing, PrimalSolution}
master_lp_dual_sol::Union{Nothing, DualSolution}
end
ColGen.colgen_iteration_output_type(::ColGenContext) = ColGenIterationOutput
function ColGen.new_iteration_output(::Type{<:ColGenIterationOutput},
min_sense,
mlp,
db,
nb_new_cols,
new_cut_in_master,
infeasible_master,
unbounded_master,
infeasible_subproblem,
unbounded_subproblem,
time_limit_reached,
master_lp_primal_sol,
master_ip_primal_sol,
master_lp_dual_sol,
)
return ColGenIterationOutput(
min_sense,
get_global_primal_bound(master_ip_primal_sol),
mlp,
db,
nb_new_cols,
new_cut_in_master,
infeasible_master,
unbounded_master,
infeasible_subproblem,
unbounded_subproblem,
time_limit_reached,
master_lp_primal_sol,
get_global_primal_sol(master_ip_primal_sol),
master_lp_dual_sol,
)
end
ColGen.get_nb_new_cols(output::ColGenIterationOutput) = output.nb_new_cols
ColGen.get_master_ip_primal_sol(output::ColGenIterationOutput) = output.master_ip_primal_sol
ColGen.get_dual_bound(output::ColGenIterationOutput) = output.db
#############################################################################
# Column generation loop
#############################################################################
# Works only for minimization.
_gap(mlp, db) = (mlp - db) / abs(db)
_colgen_gap_closed(mlp, db, atol, rtol) = _gap(mlp, db) < 0 || isapprox(mlp, db, atol = atol, rtol = rtol)
ColGen.stop_colgen_phase(ctx::ColGenContext, phase, env, ::Nothing, inc_dual_bound, ip_primal_sol, colgen_iteration) = false
function ColGen.stop_colgen_phase(ctx::ColGenContext, phase, env, colgen_iter_output::ColGenIterationOutput, inc_dual_bound, ip_primal_sol, colgen_iteration)
mlp = colgen_iter_output.mlp
pb = getvalue(get_global_primal_bound(ip_primal_sol))
db = inc_dual_bound
sc = colgen_iter_output.min_sense ? 1 : -1
return colgen_iteration >= ctx.nb_colgen_iteration_limit ||
colgen_iter_output.time_limit_reached ||
colgen_iter_output.infeasible_master ||
colgen_iter_output.unbounded_master ||
colgen_iter_output.infeasible_subproblem ||
colgen_iter_output.unbounded_subproblem ||
colgen_iter_output.nb_new_cols <= 0 ||
colgen_iter_output.new_cut_in_master ||
_colgen_gap_closed(sc * mlp, sc * db, 1e-8, 1e-5) ||
_colgen_gap_closed(sc * pb, sc * db, 1e-8, 1e-5)
end
ColGen.before_colgen_iteration(ctx::ColGenContext, phase) = nothing
ColGen.after_colgen_iteration(ctx::ColGenContext, phase, stage, env, colgen_iteration, stab, ip_primal_sol, colgen_iter_output) = nothing
ColGen.colgen_phase_output_type(::ColGenContext) = ColGenPhaseOutput
function ColGen.new_phase_output(::Type{<:ColGenPhaseOutput}, min_sense, phase, stage, colgen_iter_output::ColGenIterationOutput, iteration, inc_dual_bound)
return ColGenPhaseOutput(
colgen_iter_output.master_lp_primal_sol,
colgen_iter_output.master_ip_primal_sol,
colgen_iter_output.master_lp_dual_sol,
colgen_iter_output.ipb,
colgen_iter_output.mlp,
inc_dual_bound,
colgen_iter_output.new_cut_in_master,
colgen_iter_output.nb_new_cols <= 0,
colgen_iter_output.infeasible_master || colgen_iter_output.infeasible_subproblem,
ColGen.is_exact_stage(stage),
colgen_iter_output.time_limit_reached,
iteration,
min_sense
)
end
function ColGen.new_phase_output(::Type{<:ColGenPhaseOutput}, min_sense, phase::ColGenPhase1, stage, colgen_iter_output::ColGenIterationOutput, iteration, inc_dual_bound)
return ColGenPhaseOutput(
colgen_iter_output.master_lp_primal_sol,
colgen_iter_output.master_ip_primal_sol,
colgen_iter_output.master_lp_dual_sol,
colgen_iter_output.ipb,
colgen_iter_output.mlp,
inc_dual_bound,
colgen_iter_output.new_cut_in_master,
colgen_iter_output.nb_new_cols <= 0,
colgen_iter_output.infeasible_master || colgen_iter_output.infeasible_subproblem || abs(colgen_iter_output.mlp) > 1e-5,
ColGen.is_exact_stage(stage),
colgen_iter_output.time_limit_reached,
iteration,
min_sense
)
end
ColGen.get_master_ip_primal_sol(output::ColGenPhaseOutput) = output.master_ip_primal_sol
ColGen.update_stabilization_after_pricing_optim!(::NoColGenStab, ctx::ColGenContext, generated_columns, master, pseudo_db, smooth_dual_sol) = nothing
function ColGen.update_stabilization_after_pricing_optim!(stab::ColGenStab, ctx::ColGenContext, generated_columns, master, pseudo_db, smooth_dual_sol)
# At each iteration, we always update α after the first pricing optimization.
# We don't update α if we are in a misprice sequence.
if stab.automatic && stab.nb_misprices == 0
is_min = ColGen.is_minimization(ctx)
primal_sol = _primal_solution(master, generated_columns, is_min)
α = _dynamic_alpha_schedule(stab.base_α, smooth_dual_sol, stab.cur_stab_center, subgradient_helper(ctx), primal_sol, is_min)
stab.base_α = α
end
if isbetter(DualBound(master, pseudo_db), stab.pseudo_dual_bound)
stab.stab_center_for_next_iteration = smooth_dual_sol
stab.pseudo_dual_bound = DualBound(master, pseudo_db)
end
return
end | Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 8871 | """
ColGenPrinterContext(reformulation, algo_params) -> ColGenPrinterContext
Creates a context to run the default implementation of the column generation algorithm
together with a printer that prints information about the algorithm execution.
"""
mutable struct ColGenPrinterContext <: ColGen.AbstractColGenContext
inner::ColGenContext
phase::Int
mst_elapsed_time::Float64
sp_elapsed_time::Float64
print_column_reduced_cost::Bool
function ColGenPrinterContext(
reform, alg;
print_column_reduced_cost = false
)
inner = ColGenContext(reform, alg)
new(inner, 3, 0.0, 0.0, print_column_reduced_cost)
end
end
subgradient_helper(ctx::ColGenPrinterContext) = subgradient_helper(ctx.inner)
ColGen.get_reform(ctx::ColGenPrinterContext) = ColGen.get_reform(ctx.inner)
ColGen.get_master(ctx::ColGenPrinterContext) = ColGen.get_master(ctx.inner)
ColGen.is_minimization(ctx::ColGenPrinterContext) = ColGen.is_minimization(ctx.inner)
ColGen.get_pricing_subprobs(ctx::ColGenPrinterContext) = ColGen.get_pricing_subprobs(ctx.inner)
ColGen.setup_stabilization!(ctx::ColGenPrinterContext, master) = ColGen.setup_stabilization!(ctx.inner, master)
function ColGen.update_stabilization_after_pricing_optim!(stab, ctx::ColGenPrinterContext, generated_columns, master, pseudo_db, smooth_dual_sol)
return ColGen.update_stabilization_after_pricing_optim!(stab, ctx.inner, generated_columns, master, pseudo_db, smooth_dual_sol)
end
ColGen.new_phase_iterator(ctx::ColGenPrinterContext) = ColGen.new_phase_iterator(ctx.inner)
ColGen.new_stage_iterator(ctx::ColGenPrinterContext) = ColGen.new_stage_iterator(ctx.inner)
_phase_type_to_number(::ColGenPhase1) = 1
_phase_type_to_number(::ColGenPhase2) = 2
_phase_type_to_number(::ColGenPhase0) = 0
function ColGen.setup_context!(ctx::ColGenPrinterContext, phase::ColGen.AbstractColGenPhase)
ctx.phase = _phase_type_to_number(phase)
return ColGen.setup_context!(ctx.inner, phase)
end
function ColGen.optimize_master_lp_problem!(master, ctx::ColGenPrinterContext, env)
ctx.mst_elapsed_time = @elapsed begin
output = ColGen.optimize_master_lp_problem!(master, ctx.inner, env)
end
return output
end
function ColGen.update_master_constrs_dual_vals!(ctx::ColGenPrinterContext, master_lp_dual_sol)
return ColGen.update_master_constrs_dual_vals!(ctx.inner, master_lp_dual_sol)
end
ColGen.check_primal_ip_feasibility!(mast_primal_sol, ctx::ColGenPrinterContext, phase, env) = ColGen.check_primal_ip_feasibility!(mast_primal_sol, ctx.inner, phase, env)
function ColGen.update_inc_primal_sol!(ctx::ColGenPrinterContext, ip_primal_sol, new_ip_primal_sol)
@info "Improving primal solution with value $(ColunaBase.getvalue(new_ip_primal_sol)) is found during column generation"
ColGen.update_inc_primal_sol!(ctx.inner, ip_primal_sol, new_ip_primal_sol)
end
ColGen.get_subprob_var_orig_costs(ctx::ColGenPrinterContext) = ColGen.get_subprob_var_orig_costs(ctx.inner)
ColGen.get_subprob_var_coef_matrix(ctx::ColGenPrinterContext) = ColGen.get_subprob_var_coef_matrix(ctx.inner)
function ColGen.update_sp_vars_red_costs!(ctx::ColGenPrinterContext, sp::Formulation{DwSp}, red_costs)
return ColGen.update_sp_vars_red_costs!(ctx.inner, sp, red_costs)
end
ColGen.update_reduced_costs!(ctx::ColGenPrinterContext, phase, red_costs) = ColGen.update_reduced_costs!(ctx.inner, phase, red_costs)
function ColGen.insert_columns!(ctx::ColGenPrinterContext, phase, columns)
col_ids = ColGen.insert_columns!(ctx.inner, phase, columns)
if ctx.print_column_reduced_cost
_print_column_reduced_costs(ColGen.get_reform(ctx), col_ids)
end
return col_ids
end
ColGen.compute_sp_init_db(ctx::ColGenPrinterContext, sp::Formulation{DwSp}) = ColGen.compute_sp_init_db(ctx.inner, sp)
ColGen.compute_sp_init_pb(ctx::ColGenPrinterContext, sp::Formulation{DwSp}) = ColGen.compute_sp_init_pb(ctx.inner, sp)
ColGen.set_of_columns(ctx::ColGenPrinterContext) = ColGen.set_of_columns(ctx.inner)
function _calculate_column_reduced_cost(reform, col_id)
master = getmaster(reform)
matrix = getcoefmatrix(master)
c = getcurcost(master, col_id)
convex_constr_redcost = 0
remainder = 0
for (constrid, coef) in @view matrix[:, col_id] #retrieve the original cost
if getduty(constrid) <= MasterConvexityConstr
convex_constr_redcost += coef * getcurincval(master, constrid)
else
remainder += coef * getcurincval(master, constrid)
end
end
convex_constr_redcost = c - convex_constr_redcost
remainder = c - remainder
return (convex_constr_redcost, remainder)
end
function _print_column_reduced_costs(reform, col_ids)
for col_id in col_ids
(convex_constr_redcost, remainder) = _calculate_column_reduced_cost(reform, col_id)
println("********** column $(col_id) with convex constraints reduced cost = $(convex_constr_redcost) and reduced cost remainder = $(remainder) (total reduced cost =$(convex_constr_redcost + remainder)) **********")
end
end
function ColGen.push_in_set!(ctx::ColGenPrinterContext, set, col)
return ColGen.push_in_set!(ctx.inner, set, col)
end
function ColGen.optimize_pricing_problem!(ctx::ColGenPrinterContext, sp::Formulation{DwSp}, env, optimizer, master_dual_sol, stab_changes_mast_dual_sol)
ctx.sp_elapsed_time = @elapsed begin
output = ColGen.optimize_pricing_problem!(ctx.inner, sp, env, optimizer, master_dual_sol, stab_changes_mast_dual_sol)
end
return output
end
function ColGen.compute_dual_bound(ctx::ColGenPrinterContext, phase, sp_dbs, generated_columns, master_dual_sol)
return ColGen.compute_dual_bound(ctx.inner, phase, sp_dbs, generated_columns, master_dual_sol)
end
function ColGen.colgen_iteration_output_type(ctx::ColGenPrinterContext)
return ColGen.colgen_iteration_output_type(ctx.inner)
end
function ColGen.stop_colgen_phase(ctx::ColGenPrinterContext, phase, env, colgen_iter_output, inc_dual_bound, ip_primal_sol, colgen_iteration)
return ColGen.stop_colgen_phase(ctx.inner, phase, env, colgen_iter_output, inc_dual_bound, ip_primal_sol, colgen_iteration)
end
ColGen.before_colgen_iteration(ctx::ColGenPrinterContext, phase) = nothing
function _colgen_iter_str(
colgen_iteration, colgen_iter_output::ColGenIterationOutput, phase::Int, stage::Int, sp_time::Float64, mst_time::Float64, optim_time::Float64, alpha
)
phase_string = " "
if phase == 1
phase_string = "# "
elseif phase == 2
phase_string = "##"
end
iteration::Int = colgen_iteration
if colgen_iter_output.new_cut_in_master
return @sprintf(
"%s<st=%2i> <it=%3i> <et=%5.2f> - new essential cut in master",
phase_string, stage, iteration, optim_time
)
end
if colgen_iter_output.infeasible_master
return @sprintf(
"%s<st=%2i> <it=%3i> <et=%5.2f> - infeasible master",
phase_string, stage, iteration, optim_time
)
end
if colgen_iter_output.unbounded_master
return @sprintf(
"%s<st=%2i> <it=%3i> <et=%5.2f> - unbounded master",
phase_string, stage, iteration, optim_time
)
end
if colgen_iter_output.infeasible_subproblem
return @sprintf(
"%s<st=%2i> <it=%3i> <et=%5.2f> - infeasible subproblem",
phase_string, stage, iteration, optim_time
)
end
if colgen_iter_output.unbounded_subproblem
return @sprintf(
"%s<st=%2i> <it=%3i> <et=%5.2f> - unbounded subproblem",
phase_string, stage, iteration, optim_time
)
end
mlp::Float64 = colgen_iter_output.mlp
db::Float64 = colgen_iter_output.db
pb::Float64 = colgen_iter_output.ipb
nb_new_col::Int = ColGen.get_nb_new_cols(colgen_iter_output)
return @sprintf(
"%s<st=%2i> <it=%3i> <et=%5.2f> <mst=%5.2f> <sp=%5.2f> <cols=%2i> <al=%5.2f> <DB=%10.4f> <mlp=%10.4f> <PB=%.4f>",
phase_string, stage, iteration, optim_time, mst_time, sp_time, nb_new_col, alpha, db, mlp, pb
)
end
function ColGen.after_colgen_iteration(ctx::ColGenPrinterContext, phase, stage, env, colgen_iteration, stab, ip_primal_sol, colgen_iter_output)
println(_colgen_iter_str(colgen_iteration, colgen_iter_output, ctx.phase, ColGen.stage_id(stage), ctx.sp_elapsed_time, ctx.mst_elapsed_time, elapsed_optim_time(env), ColGen.get_output_str(stab)))
return
end
ColGen.stop_colgen(ctx::ColGenPrinterContext, phase_output) = ColGen.stop_colgen(ctx.inner, phase_output)
ColGen.is_better_dual_bound(ctx::ColGenPrinterContext, new_dual_bound, dual_bound) =
ColGen.is_better_dual_bound(ctx.inner, new_dual_bound, dual_bound)
ColGen.colgen_output_type(::ColGenPrinterContext) = ColGenOutput
ColGen.colgen_phase_output_type(::ColGenPrinterContext) = ColGenPhaseOutput | Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 6031 | struct NoColGenStab end
#ColGen.setup_stabilization(ctx, master) = NoColGenStab()
ColGen.update_stabilization_after_master_optim!(::NoColGenStab, phase, mast_dual_sol) = false
ColGen.get_stab_dual_sol(::NoColGenStab, phase, mast_dual_sol) = mast_dual_sol
ColGen.check_misprice(::NoColGenStab, generated_cols, mast_dual_sol) = false
ColGen.update_stabilization_after_misprice!(::NoColGenStab, mast_dual_sol) = nothing
ColGen.update_stabilization_after_iter!(::NoColGenStab, mast_dual_sol) = nothing
ColGen.get_output_str(::NoColGenStab) = 0.0
"""
Implementation of the "Smoothing with a self adjusting parameter" described in the paper of
Pessoa et al.
TODO: docstring
- in: stability center
- dual solution of the previous iteration under Neame rule,
- incumbent dual solution under Wentges rule.
- out: current dual solution
- sep: smoothed dual solution
π^sep <- α * π^in + (1 - α) * π^out
"""
mutable struct ColGenStab{F}
automatic::Bool
base_α::Float64 # "global" α parameter
cur_α::Float64 # α parameter during the current misprice sequence
nb_misprices::Int # number of misprices during the current misprice sequence
pseudo_dual_bound::ColunaBase.Bound # pseudo dual bound, may be non-valid, f.e. when the pricing problem solved heuristically
valid_dual_bound::ColunaBase.Bound # valid dual bound
stab_center::Union{Nothing,MathProg.DualSolution{F}} # stability center, corresponding to valid_dual_bound (in point)
cur_stab_center::Union{Nothing,MathProg.DualSolution{F}} # current stability center, correspond to cur_dual_bound
stab_center_for_next_iteration::Union{Nothing,MathProg.DualSolution{F}} # to keep temporarily stab. center after update
ColGenStab(master::F, automatic, init_α) where {F} = new{F}(
automatic, init_α, 0.0, 0, MathProg.DualBound(master), MathProg.DualBound(master), nothing, nothing, nothing
)
end
ColGen.get_output_str(stab::ColGenStab) = stab.base_α
function ColGen.update_stabilization_after_master_optim!(stab::ColGenStab, phase, mast_dual_sol)
stab.nb_misprices = 0
stab.cur_α = 0.0
if isnothing(stab.cur_stab_center)
stab.cur_stab_center = mast_dual_sol
return false
end
stab.cur_α = stab.base_α
return stab.cur_α > 0
end
function ColGen.get_stab_dual_sol(stab::ColGenStab, phase, mast_dual_sol)
return stab.cur_α * stab.cur_stab_center + (1 - stab.cur_α) * mast_dual_sol
end
ColGen.check_misprice(stab::ColGenStab, generated_cols, mast_dual_sol) = length(generated_cols.columns) == 0 && stab.cur_α > 0.0
function _misprice_schedule(automatic, nb_misprices, base_α)
# Rule from the paper Pessoa et al. (α-schedule in a mis-pricing sequence, Step 1)
α = 1.0 - (nb_misprices + 1) * (1 - base_α)
if nb_misprices > 10 || α <= 1e-3
# After 10 mis-priced iterations, we deactivate stabilization to use the "real"
# dual solution.
α = 0.0
end
return α
end
function ColGen.update_stabilization_after_misprice!(stab::ColGenStab, mast_dual_sol)
stab.nb_misprices += 1
α = _misprice_schedule(stab.automatic, stab.nb_misprices, stab.base_α)
stab.cur_α = α
return
end
f_decr(α) = max(0.0, α - 0.1)
f_incr(α) = min(α + (1.0 - α) * 0.1, 0.9999)
function _pure_master_vars(master)
puremastervars = Vector{Pair{VarId,Float64}}()
for (varid, var) in getvars(master)
if isanOriginalRepresentatives(getduty(varid)) &&
iscuractive(master, var) && isexplicit(master, var)
push!(puremastervars, varid => 0.0)
end
end
return puremastervars
end
function _primal_solution(master::Formulation, generated_columns, is_minimization)
sense = MathProg.getobjsense(master)
var_ids = MathProg.VarId[]
var_vals = Float64[]
puremastervars = _pure_master_vars(master)
for (var_id, mult) in puremastervars
push!(var_ids, var_id)
push!(var_vals, mult) # always 0 in the previous implementation ?
end
for (sp_id, sp_primal_sol) in generated_columns.subprob_primal_sols.primal_sols
sp = getmodel(sp_primal_sol)
lb = getcurrhs(master, sp.duty_data.lower_multiplicity_constr_id)
ub = getcurrhs(master, sp.duty_data.upper_multiplicity_constr_id)
iszero(ub) && continue
mult = get(generated_columns.subprob_primal_sols.improve_master, sp_id, false) ? ub : lb
for (sp_var_id, sp_var_val) in sp_primal_sol
push!(var_ids, sp_var_id)
push!(var_vals, sp_var_val * mult)
end
end
return sparsevec(var_ids, var_vals)
end
function _increase(smooth_dual_sol, cur_stab_center, h, primal_solution, is_minimization)
# Calculate the in-sep direction.
in_sep_direction = smooth_dual_sol - cur_stab_center
in_sep_dir_norm = norm(in_sep_direction)
# if in & sep are the same point, we need to decrease α becase it is the weight of the
# stability center (in) in the formula to compute the sep point.
if iszero(in_sep_dir_norm)
return false
end
# Calculate the subgradient
subgradient = h.a - h.A * primal_solution
subgradient_norm = norm(subgradient)
# we now calculate the angle between the in-sep direction and the subgradient
cos_angle = (transpose(in_sep_direction) * subgradient) / (in_sep_dir_norm * subgradient_norm)
if !is_minimization
cos_angle *= -1
end
return cos_angle < 1e-12
end
function _dynamic_alpha_schedule(
α, smooth_dual_sol, cur_stab_center, h, primal_solution, is_minimization
)
increase = _increase(smooth_dual_sol, cur_stab_center, h, primal_solution, is_minimization)
# we modify the alpha parameter based on the calculated angle
return increase ? f_incr(α) : f_decr(α)
end
function ColGen.update_stabilization_after_iter!(stab::ColGenStab, mast_dual_sol)
if !isnothing(stab.stab_center_for_next_iteration)
stab.cur_stab_center = stab.stab_center_for_next_iteration
stab.stab_center_for_next_iteration = nothing
end
return
end | Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 8551 | ############################################################################################
# Errors and warnings
############################################################################################
"""
Error thrown when when a subproblem generates a column with negative (resp. positive)
reduced cost in min (resp. max) problem that already exists in the master
and that is already active.
An active master column cannot have a negative reduced cost.
"""
struct ColumnAlreadyInsertedColGenWarning
column_in_master::Bool
column_is_active::Bool
column_reduced_cost::Float64
column_id::VarId
master::Formulation{DwMaster}
subproblem::Formulation{DwSp}
end
function Base.show(io::IO, err::ColumnAlreadyInsertedColGenWarning)
msg = """
Unexpected variable state during column insertion.
======
Column id: $(err.column_id).
Reduced cost of the column: $(err.column_reduced_cost).
The column is in the master ? $(err.column_in_master).
The column is active ? $(err.column_is_active).
======
If the column is in the master and active, it means a subproblem found a solution with
negative (minimization) / positive (maximization) reduced cost that is already active in
the master. This should not happen.
======
If you are using a pricing callback, make sure there is no bug in your code.
If you are using a solver (e.g. GLPK, Gurobi...), check the reduced cost tolerance
`redcost_tol` parameter of `ColumnGeneration`.
If you find a bug in Coluna, please open an issue at https://github.com/atoptima/Coluna.jl/issues with an example
that reproduces the bug.
======
"""
println(io, msg)
end
############################################################################################
# Information extracted to speed-up some computations.
############################################################################################
function _submatrix_nz_elems(
form::Formulation,
keep_constr::Function,
keep_var::Function,
m::Function = (form, is_min, constr_id, var_id) -> 1.0
)
is_min = getobjsense(form) == MinSense
matrix = getcoefmatrix(form)
constr_ids = ConstrId[]
var_ids = VarId[]
nz = Float64[]
for (constr_id, constr) in getconstrs(form)
if keep_constr(form, constr_id, constr)
for (var_id, coeff) in @view matrix[constr_id, :]
var = getvar(form, var_id)
@assert !isnothing(var)
if keep_var(form, var_id, var)
c = m(form, is_min, constr_id, var_id)
push!(constr_ids, constr_id)
push!(var_ids, var_id)
push!(nz, c * coeff)
end
end
end
end
return constr_ids, var_ids, nz
end
function _submatrix(
form::Formulation,
keep_constr::Function,
keep_var::Function,
m::Function = (form, is_min, constr_id, var_id) -> 1.0
)
constr_ids, var_ids, nz = _submatrix_nz_elems(form, keep_constr, keep_var, m)
return dynamicsparse(
constr_ids, var_ids, nz, ConstrId(Coluna.MAX_NB_ELEMS), VarId(Coluna.MAX_NB_ELEMS)
)
end
"""
Extracted information to speed-up calculation of reduced costs of subproblem representatives
and pure master variables.
We extract from the master the information we need to compute the reduced cost of DW
subproblem variables:
- `dw_subprob_c` contains the perenial cost of DW subproblem representative variables
- `dw_subprob_A` is a submatrix of the master coefficient matrix that involves only DW subproblem
representative variables.
We also extract from the master the information we need to compute the reduced cost of pure
master variables:
- `pure_master_c` contains the perenial cost of pure master variables
- `pure_master_A` is a submatrix of the master coefficient matrix that involves only pure master
variables.
Calculation is `c - transpose(A) * master_lp_dual_solution`.
This information is given to the generic implementation of the column generation algorithm
through methods:
- ColGen.get_subprob_var_orig_costs
- ColGen.get_orig_coefmatrix
"""
struct ReducedCostsCalculationHelper
dw_subprob_c::SparseVector{Float64,VarId}
dw_subprob_A::DynamicSparseMatrix{ConstrId,VarId,Float64}
master_c::SparseVector{Float64,VarId}
master_A::DynamicSparseMatrix{ConstrId,VarId,Float64}
end
"""
Function `var_duty_func(form, var_id, var)` returns `true` if we want to keep the variable `var_id`; `false` otherwise.
Same for `constr_duty_func(form, constr_id, constr)`.
"""
function _get_costs_and_coeffs(master, var_duty_func, constr_duty_func)
var_ids = VarId[]
peren_costs = Float64[]
for (var_id, var) in getvars(master)
if var_duty_func(master, var_id, var)
push!(var_ids, var_id)
push!(peren_costs, getcurcost(master, var_id))
end
end
costs = sparsevec(var_ids, peren_costs, Coluna.MAX_NB_ELEMS)
coef_matrix = _submatrix(master, constr_duty_func, var_duty_func)
return costs, coef_matrix
end
function ReducedCostsCalculationHelper(master)
dw_subprob_c, dw_subprob_A = _get_costs_and_coeffs(
master,
(form, var_id, var) -> getduty(var_id) <= AbstractMasterRepDwSpVar && iscuractive(form, var),
(form, constr_id, constr) -> !(getduty(constr_id) <= MasterConvexityConstr) && iscuractive(form, constr)
)
master_c, master_A = _get_costs_and_coeffs(
master,
(form, var_id, var) -> getduty(var_id) <= AbstractOriginMasterVar && iscuractive(form, var),
(form, constr_id, constr) -> !(getduty(constr_id) <= MasterConvexityConstr)
)
return ReducedCostsCalculationHelper(dw_subprob_c, dw_subprob_A, master_c, master_A)
end
"""
Precompute information to speed-up calculation of subgradient of master variables.
We extract from the master follwowing information:
- `a` contains the perenial rhs of all master constraints except convexity constraints;
- `A` is a submatrix of the master coefficient matrix that involves only representative of
original variables (pure master vars + DW subproblem represtative vars)
Calculation is `a - A * (m .* z)`
where :
- `m` contains a multiplicity factor for each variable involved in the calculation
(lower or upper sp multiplicity depending on variable reduced cost);
- `z` is the concatenation of the solution to the master (for pure master vars) and pricing
subproblems (for DW subproblem represtative vars).
Operation `m .* z` "mimics" a solution in the original space.
"""
struct SubgradientCalculationHelper
# Changes the sense of the constraint to put the LP in canonical form.
# (expect == constraints -> needs discussion on how to do that.)
a::SparseVector{Float64,ConstrId}
# Used to compute master contribution in the lagrangian bound.
# Keeps the original sense of the constraint because the sign of the dual is the one
# in the canonical form.
a_for_dual::SparseVector{Float64,ConstrId}
A::DynamicSparseMatrix{ConstrId,VarId,Float64}
end
function SubgradientCalculationHelper(master)
m_rhs = (master, is_min, constr_id) -> begin
constr_sense = getcursense(master, constr_id)
if is_min
return constr_sense == Less ? -1.0 : 1.0
else
return constr_sense == Greater ? -1.0 : 1.0
end
end
m_submatrix = (master, is_min, constr_id, var_id) -> begin
m_rhs(master, is_min, constr_id)
end
constr_ids = ConstrId[]
constr_rhs = Float64[]
constr_rhs_dual = Float64[]
is_min = getobjsense(master) == MinSense
for (constr_id, constr) in getconstrs(master)
if !(getduty(constr_id) <= MasterConvexityConstr) &&
iscuractive(master, constr) && isexplicit(master, constr)
push!(constr_ids, constr_id)
push!(constr_rhs, m_rhs(master, is_min, constr_id) * getcurrhs(master, constr_id))
push!(constr_rhs_dual, getcurrhs(master, constr_id))
end
end
a = sparsevec(constr_ids, constr_rhs, Coluna.MAX_NB_ELEMS)
a_dual = sparsevec(constr_ids, constr_rhs_dual, Coluna.MAX_NB_ELEMS)
A = _submatrix(
master,
(form, constr_id, constr) -> !(getduty(constr_id) <= MasterConvexityConstr) && iscuractive(form, constr),
(form, var_id, var) -> getduty(var_id) <= MasterPureVar || getduty(var_id) <= MasterRepPricingVar,
m_submatrix
)
return SubgradientCalculationHelper(a, a_dual, A)
end | Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 1731 | """
The restricted master heuristic enforces integrality of the master column variables and
optimizes the master problem restricted to active master column variables using a MIP solver.
If the heuristic finds a solution, it checks that this solution does not violate any essential
cut.
"""
struct RestrictedMasterHeuristic <: AbstractOptimizationAlgorithm
solve_ip_form_alg::SolveIpForm
RestrictedMasterHeuristic(;
solve_ip_form_alg = SolveIpForm(moi_params = MoiOptimize(get_dual_bound = false))
) = new(solve_ip_form_alg)
end
ismanager(::RestrictedMasterHeuristic) = false
function get_child_algorithms(algo::RestrictedMasterHeuristic, reform::Reformulation)
child_algs = Dict{String, Tuple{AlgoAPI.AbstractAlgorithm, MathProg.Formulation}}(
"solve_ip_form_alg" => (algo.solve_ip_form_alg, getmaster(reform))
)
return child_algs
end
function run!(algo::RestrictedMasterHeuristic, env, reform, input::OptimizationState)
master = getmaster(reform)
ip_form_output = run!(algo.solve_ip_form_alg, env, master, input)
ip_primal_sols = get_ip_primal_sols(ip_form_output)
output = OptimizationState(master)
# We need to make sure that the solution is feasible by separating essential cuts and then
# project the solution on master.
if length(ip_primal_sols) > 0
for sol in sort(ip_primal_sols) # we start with worst solution to add all improving solutions
cutgen = CutCallbacks(call_robust_facultative = false)
cutcb_output = run!(cutgen, env, master, CutCallbacksInput(sol))
if cutcb_output.nb_cuts_added == 0
add_ip_primal_sol!(output, sol)
end
end
end
return output
end
| Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 9070 | const PRECISION_DIGITS = 6 # floating point numbers have between 6 and 9 significant digits
"""
Temporary data structure where we store a representation of the formulation that we presolve.
"""
mutable struct PresolveFormRepr
nb_vars::Int
nb_constrs::Int
col_major_coef_matrix::SparseMatrixCSC{Float64,Int64} # col major
row_major_coef_matrix::SparseMatrixCSC{Float64,Int64} # row major
rhs::Vector{Float64} # on constraints
sense::Vector{ConstrSense} # on constraints
lbs::Vector{Float64} # on variables
ubs::Vector{Float64} # on variables
partial_solution::Vector{Float64} # on variables
lower_multiplicity::Float64
upper_multiplicity::Float64
end
function PresolveFormRepr(
coef_matrix, rhs, sense, lbs, ubs, partial_solution, lm, um
)
length(lbs) == length(ubs) || throw(ArgumentError("Inconsistent sizes of bounds and coef_matrix."))
length(rhs) == length(sense) || throw(ArgumentError("Inconsistent sizes of rhs and coef_matrix."))
nb_vars = length(lbs)
nb_constrs = length(rhs)
@assert reduce(&, map(lb -> !isnan(lb), lbs))
@assert reduce(&, map(ub -> !isnan(ub), ubs))
return PresolveFormRepr(
nb_vars,
nb_constrs,
coef_matrix,
transpose(coef_matrix),
rhs,
sense,
lbs,
ubs,
partial_solution,
lm,
um
)
end
_lb_prec(lb) = floor(round(lb, sigdigits = PRECISION_DIGITS + 1), sigdigits = PRECISION_DIGITS)
_ub_prec(ub) = ceil(round(ub, sigdigits = PRECISION_DIGITS + 1), sigdigits = PRECISION_DIGITS)
function _act_contrib(a, l, u)
if a > 0
return l*a
elseif a < 0
return u*a
end
return 0.0
end
function row_min_activity(form::PresolveFormRepr, row::Int, except_col::Function = _ -> false)
activity = 0.0
A = form.row_major_coef_matrix
cols = rowvals(A)
vals = nonzeros(A)
for i in nzrange(A, row)
col = cols[i]
val = vals[i]
l = form.lbs[col]
u = form.ubs[col]
if !except_col(col)
activity += _act_contrib(val, l, u)
end
end
return activity
end
function row_max_activity(form::PresolveFormRepr, row::Int, except_col::Function = _ -> false)
activity = 0.0
A = form.row_major_coef_matrix
cols = rowvals(A)
vals = nonzeros(A)
for i in nzrange(A, row)
col = cols[i]
val = vals[i]
l = form.lbs[col]
u = form.ubs[col]
if !except_col(col)
activity += _act_contrib(val, u, l)
end
end
return activity
end
function row_max_slack(form::PresolveFormRepr, row::Int, except_col::Function = _ -> false)
act = row_min_activity(form, row, except_col)
return form.rhs[row] - act
end
function row_min_slack(form::PresolveFormRepr, row::Int, except_col::Function = _ -> false)
act = row_max_activity(form, row, except_col)
return form.rhs[row] - act
end
function _unbounded_row(sense::ConstrSense, rhs::Real)
return rhs > 0 && isinf(rhs) && sense == Less || rhs < 0 && isinf(rhs) && sense == Greater
end
function _row_bounded_by_var_bounds(sense::ConstrSense, min_slack::Real, max_slack::Real, ϵ::Real)
return sense == Less && min_slack >= -ϵ ||
sense == Greater && max_slack <= ϵ ||
sense == Equal && max_slack <= ϵ && min_slack >= -ϵ
end
function _infeasible_row(sense::ConstrSense, min_slack::Real, max_slack::Real, ϵ::Real)
return (sense == Greater || sense == Equal) && min_slack > ϵ ||
(sense == Less || sense == Equal) && max_slack < -ϵ
end
function _var_lb_from_row(sense::ConstrSense, min_slack::Real, max_slack::Real, var_coef_in_row::Real)
if (sense == Equal || sense == Greater) && var_coef_in_row > 0
return min_slack / var_coef_in_row
elseif (sense == Less || sense == Equal) && var_coef_in_row < 0
return max_slack / var_coef_in_row
end
return -Inf
end
function _var_ub_from_row(sense::ConstrSense, min_slack::Real, max_slack::Real, var_coef_in_row::Real)
if (sense == Greater || sense == Equal) && var_coef_in_row < 0
return min_slack / var_coef_in_row
elseif (sense == Equal || sense == Less) && var_coef_in_row > 0
return max_slack / var_coef_in_row
end
return Inf
end
# Is not used for the moment, but we keep it as it might be needed
# function rows_to_deactivate(form::PresolveFormRepr)
# # Compute slacks of each constraints
# rows_to_deactivate = Int[]
# min_slacks = Float64[row_min_slack(form, row) for row in 1:form.nb_constrs]
# max_slacks = Float64[row_max_slack(form, row) for row in 1:form.nb_constrs]
# for row in 1:form.nb_constrs
# sense = form.sense[row]
# rhs = form.rhs[row]
# if _infeasible_row(sense, min_slacks[row], max_slacks[row], 1e-6)
# error("Infeasible row $row.")
# end
# if _unbounded_row(sense, rhs) || _row_bounded_by_var_bounds(sense, min_slacks[row], max_slacks[row], 1e-6)
# push!(rows_to_deactivate, row)
# end
# end
# return rows_to_deactivate
# end
function bounds_tightening(form::PresolveFormRepr)
#length(ignore_rows) == form.nb_constrs || throw(ArgumentError("Inconsistent sizes of ignore_rows and nb of constraints."))
tightened_bounds = Dict{Int, Tuple{Float64, Bool, Float64, Bool}}()
for col in 1:form.nb_vars
var_lb = form.lbs[col]
var_ub = form.ubs[col]
tighter_lb = false
tighter_ub = false
for row in 1:form.nb_constrs
min_slack = row_min_slack(form, row, i -> i == col)
max_slack = row_max_slack(form, row, i -> i == col)
var_coef_in_row = form.col_major_coef_matrix[row, col]
sense = form.sense[row]
var_lb_from_row = _var_lb_from_row(sense, min_slack, max_slack, var_coef_in_row)
@assert !isnan(var_lb)
@assert !isnan(var_lb_from_row)
if var_lb_from_row > var_lb
var_lb = var_lb_from_row
tighter_lb = true
end
var_ub_from_row = _var_ub_from_row(sense, min_slack, max_slack, var_coef_in_row)
@assert !isnan(var_ub)
@assert !isnan(var_ub_from_row)
if var_ub_from_row < var_ub
var_ub = var_ub_from_row
tighter_ub = true
end
end
if tighter_lb || tighter_ub
push!(tightened_bounds, col => (_lb_prec(var_lb), tighter_lb, _ub_prec(var_ub), tighter_ub))
end
end
return tightened_bounds
end
function find_uninvolved_vars(col_major_coef_matrix)
uninvolved_vars = Int[]
vals = nonzeros(col_major_coef_matrix)
for j in 1:size(col_major_coef_matrix, 2)
uninvolved = true
for i in nzrange(col_major_coef_matrix, j)
if abs(vals[i]) > 1e-6
uninvolved = false
break
end
end
if uninvolved
push!(uninvolved_vars, j)
end
end
return uninvolved_vars
end
function tighten_bounds_presolve_form_repr(form::PresolveFormRepr, tightened_bounds::Dict{Int, Tuple{Float64, Bool, Float64, Bool}}, lm, um)
coef_matrix = form.col_major_coef_matrix
rhs = form.rhs
sense = form.sense
lbs = form.lbs
ubs = form.ubs
partial_sol = form.partial_solution
# Tighten bounds
for (col, (lb, tighter_lb, ub, tighter_ub)) in tightened_bounds
@assert !isnan(lb)
@assert !isnan(ub)
if tighter_lb
lbs[col] = lb
end
if tighter_ub
ubs[col] = ub
end
end
row_mask = ones(Bool, form.nb_constrs)
col_mask = ones(Bool, form.nb_vars)
return PresolveFormRepr(coef_matrix, rhs, sense, lbs, ubs, partial_sol, lm, um),
row_mask,
col_mask
end
function shrink_row_presolve_form_repr(form::PresolveFormRepr, rows_to_deactivate::Vector{Int}, lm, um)
nb_rows = form.nb_constrs
coef_matrix = form.col_major_coef_matrix
rhs = form.rhs
sense = form.sense
lbs = form.lbs
ubs = form.ubs
partial_sol = form.partial_solution
row_mask = ones(Bool, nb_rows)
row_mask[rows_to_deactivate] .= false
return PresolveFormRepr(
coef_matrix[row_mask, :],
rhs[row_mask],
sense[row_mask],
lbs,
ubs,
partial_sol,
lm,
um
), row_mask
end
function PresolveFormRepr(
presolve_form_repr::PresolveFormRepr,
rows_to_deactivate::Vector{Int},
tightened_bounds::Dict{Int, Tuple{Float64, Bool, Float64, Bool}},
lm,
um
)
row_mask = ones(Bool, presolve_form_repr.nb_constrs)
col_mask = ones(Bool, presolve_form_repr.nb_vars)
presolve_form_repr, row_mask, col_mask = tighten_bounds_presolve_form_repr(
presolve_form_repr, tightened_bounds, lm, um
)
presolve_form_repr, row_mask = shrink_row_presolve_form_repr(
presolve_form_repr, rows_to_deactivate, lm, um
)
return presolve_form_repr, row_mask, col_mask
end
| Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 18979 | """
Stores a matrix-representation of the formulation and the mapping between the variables &
constraints of the formulation to the row and column of the matrix and components of the
vector that represents the formulation.
"""
struct PresolveFormulation
col_to_var::Vector{Variable}
row_to_constr::Vector{Constraint}
var_to_col::Dict{VarId,Int64}
constr_to_row::Dict{ConstrId,Int64}
form::PresolveFormRepr
deactivated_constrs::Vector{ConstrId}
fixed_variables::Dict{VarId,Float64}
end
"""
Stores the presolve-representation of the formulations of the Dantzig-Wolfe reformulation.
This datastructure contains:
- `representative_master` that contains the master formulation expressed with representative
variables and pure master variables
- `restricted_master` that contains the master formulation expressed with pure master variables,
master columns, and artificial variables
- `dw_sps` a dictionary that contains the subproblem formulations.
"""
mutable struct DwPresolveReform
representative_master::PresolveFormulation
restricted_master::PresolveFormulation
dw_sps::Dict{FormId,PresolveFormulation}
end
function create_presolve_form(
form::Formulation,
keep_var::Function,
keep_constr::Function;
lower_multiplicity=1,
upper_multiplicity=1
)
sm_constr_ids, sm_var_ids, nz = _submatrix_nz_elems(form, keep_constr, keep_var)
constr_ids = Set{ConstrId}()
for (constr_id, constr) in getconstrs(form)
if keep_constr(form, constr_id, constr)
push!(constr_ids, constr_id)
end
end
var_ids = Set{VarId}()
for (var_id, var) in getvars(form)
if keep_var(form, var_id, var)
push!(var_ids, var_id)
end
end
var_to_col = Dict{VarId,Int64}()
col_to_var = Variable[]
for (k, varid) in enumerate(unique(var_ids))
var = getvar(form, varid)
@assert !isnothing(var)
push!(col_to_var, var)
var_to_col[varid] = k
end
constr_to_row = Dict{ConstrId,Int64}()
row_to_constr = Constraint[]
for (k, constrid) in enumerate(unique(constr_ids))
constr = getconstr(form, constrid)
@assert !isnothing(constr)
push!(row_to_constr, constr)
constr_to_row[constrid] = k
end
coef_submatrix = sparse(
map(constr_id -> constr_to_row[constr_id], sm_constr_ids),
map(var_id -> var_to_col[var_id], sm_var_ids),
nz,
length(row_to_constr),
length(col_to_var),
)
lbs_vals = Float64[]
ubs_vals = Float64[]
partial_sol = Float64[]
for var in col_to_var
push!(lbs_vals, getcurlb(form, var))
push!(ubs_vals, getcurub(form, var))
@assert !isnan(getcurlb(form, var))
@assert !isnan(getcurub(form, var))
#push!(partial_sol, MathProg.get_value_in_partial_sol(form, var))
push!(partial_sol, 0.0)
end
rhs_vals = Float64[]
sense_vals = Coluna.ConstrSense[]
for constr in row_to_constr
push!(rhs_vals, getcurrhs(form, constr))
push!(sense_vals, getcursense(form, constr))
end
form = PresolveFormRepr(
coef_submatrix,
rhs_vals,
sense_vals,
lbs_vals,
ubs_vals,
partial_sol,
lower_multiplicity,
upper_multiplicity
)
deactivated_constrs = ConstrId[]
return PresolveFormulation(
col_to_var,
row_to_constr,
var_to_col,
constr_to_row,
form,
deactivated_constrs,
Dict{VarId,Float64}()
)
end
function create_presolve_reform(reform::Reformulation{DwMaster}; verbose::Bool=false)
master = getmaster(reform)
# Create the presolve formulations
# Master 1:
# Variables: subproblem representatives & master pure
# Constraints: master pure & master mixed & branching constraints & cuts
original_master_vars = (form, varid, var) -> (
(getduty(varid) <= MasterPureVar && iscuractive(form, var)) ||
getduty(varid) <= MasterRepPricingVar
)
original_master_constrs = (form, constrid, constr) -> (
iscuractive(form, constr) && (
getduty(constrid) <= MasterPureConstr ||
getduty(constrid) <= MasterMixedConstr ||
getduty(constrid) <= MasterBranchOnOrigVarConstr ||
getduty(constrid) <= MasterUserCutConstr ||
getduty(constrid) <= MasterConvexityConstr
)
)
original_master = create_presolve_form(master, original_master_vars, original_master_constrs)
if verbose
print("Initial original and global bounds:")
for (col, var) in enumerate(original_master.col_to_var)
print(
" ",
getname(master, var),
":[",
original_master.form.lbs[col],
",",
original_master.form.ubs[col],
"]"
)
end
println()
end
# Master 2:
# Variables: columns & master pure & artifical variables
# Constraints: master pure & master mixed & convexity constraints & branching constraints & cuts
restricted_master_vars = (form, varid, var) -> (
iscuractive(form, var) && (
getduty(varid) <= MasterPureVar ||
getduty(varid) <= MasterCol ||
getduty(varid) <= MasterArtVar
)
)
restricted_master_constrs = (form, constrid, constr) -> (
iscuractive(form, constr) && (
getduty(constrid) <= MasterPureConstr ||
getduty(constrid) <= MasterMixedConstr ||
getduty(constrid) <= MasterBranchOnOrigVarConstr ||
getduty(constrid) <= MasterUserCutConstr ||
getduty(constrid) <= MasterConvexityConstr
)
)
restricted_master = create_presolve_form(
master, restricted_master_vars, restricted_master_constrs
)
# Subproblems:
# Variables: pricing variables
# Constraints: DwSpPureConstr
sp_vars = (form, varid, var) -> iscuractive(form, var) && getduty(varid) <= DwSpPricingVar
sp_constrs = (form, constrid, constr) -> iscuractive(form, constr) &&
getduty(constrid) <= DwSpPureConstr
dw_sps = Dict{FormId,PresolveFormulation}()
for (spid, sp) in get_dw_pricing_sps(reform)
lm = getcurrhs(master, sp.duty_data.lower_multiplicity_constr_id)
um = getcurrhs(master, sp.duty_data.upper_multiplicity_constr_id)
dw_sps[spid] = create_presolve_form(
sp, sp_vars, sp_constrs, lower_multiplicity=lm, upper_multiplicity=um
)
end
return DwPresolveReform(original_master, restricted_master, dw_sps)
end
function update_partial_sol!(
form::Formulation{DwMaster}, presolve_form::PresolveFormulation, partial_solution
)
# Update partial solution
for (col, val) in enumerate(partial_solution)
var = presolve_form.col_to_var[col]
duty = getduty(getid(var))
if duty <= MasterArtVar && !iszero(val)
error(""" Infeasible because artificial variable $(getname(form, var)) is not zero.
Fixed to $(val) in partial solution.
""")
end
if !iszero(val) && (duty <= MasterCol || duty <= MasterPureVar)
MathProg.add_to_partial_solution!(form, var, val)
end
end
return
end
function _update_bounds!(form::Formulation, presolve_form::PresolveFormulation)
# Update bounds
for (col, (lb, ub)) in enumerate(Iterators.zip(
presolve_form.form.lbs,
presolve_form.form.ubs
))
@assert !isnan(lb)
@assert !isnan(ub)
var = presolve_form.col_to_var[col]
if getduty(getid(var)) <= MasterCol
@assert iszero(lb)
setcurlb!(form, var, 0.0)
# ignore the upper bound (we keep Inf)
else
setcurlb!(form, var, lb)
setcurub!(form, var, ub)
end
end
return
end
function _update_rhs!(form::Formulation, presolve_form::PresolveFormulation)
for (row, rhs) in enumerate(presolve_form.form.rhs)
constr = presolve_form.row_to_constr[row]
setcurrhs!(form, constr, rhs)
end
return
end
function update_form_from_presolve!(form::Formulation, presolve_form::PresolveFormulation)
# Deactivate Constraints
for constr_id in presolve_form.deactivated_constrs
if iscuractive(form, getconstr(form, constr_id))
deactivate!(form, getconstr(form, constr_id))
end
end
_update_rhs!(form, presolve_form)
_update_bounds!(form, presolve_form)
return
end
function update_reform_from_presolve!(
reform::Reformulation,
presolve_reform::DwPresolveReform
)
master = getmaster(reform)
presolve_repr_master = presolve_reform.representative_master
# Update subproblems
for (spid, sp) in get_dw_pricing_sps(reform)
sp_presolve_form = presolve_reform.dw_sps[spid]
update_form_from_presolve!(sp, sp_presolve_form)
lm_row = presolve_repr_master.constr_to_row[sp.duty_data.lower_multiplicity_constr_id]
presolve_repr_master.form.rhs[lm_row] = sp_presolve_form.form.lower_multiplicity
um_row = presolve_repr_master.constr_to_row[sp.duty_data.upper_multiplicity_constr_id]
presolve_repr_master.form.rhs[um_row] = sp_presolve_form.form.upper_multiplicity
end
update_form_from_presolve!(master, presolve_repr_master)
return
end
"""
Presolve algorithm
"""
struct PresolveAlgorithm <: AlgoAPI.AbstractAlgorithm
ϵ::Float64
verbose::Bool
PresolveAlgorithm(; ϵ=Coluna.TOL, verbose=false) = new(ϵ, verbose)
end
# PresolveAlgorithm does not have child algorithms, therefore get_child_algorithms() is not defined
function get_units_usage(algo::PresolveAlgorithm, reform::Reformulation)
units_usage = Tuple{AbstractModel,UnitType,UnitPermission}[]
master = getmaster(reform)
push!(units_usage, (master, StaticVarConstrUnit, READ_AND_WRITE))
push!(units_usage, (master, PartialSolutionUnit, READ_AND_WRITE))
push!(units_usage, (master, MasterBranchConstrsUnit, READ_AND_WRITE))
push!(units_usage, (master, MasterCutsUnit, READ_AND_WRITE))
push!(units_usage, (master, MasterColumnsUnit, READ_AND_WRITE))
for (_, dw_sp) in get_dw_pricing_sps(reform)
push!(units_usage, (dw_sp, StaticVarConstrUnit, READ_AND_WRITE))
end
return units_usage
end
struct PresolveInput
partial_sol_to_fix::Dict{VarId,Float64}
end
PresolveInput() = PresolveInput(Dict{VarId,Float64}())
struct PresolveOutput
feasible::Bool
end
isfeasible(output::PresolveOutput) = output.feasible
function presolve_formulation!(presolve_form::PresolveFormulation)
tightened_bounds = bounds_tightening(presolve_form.form)
presolve_form = propagate_in_presolve_form(presolve_form, Int[], tightened_bounds)
end
function check_feasibility!(form::Formulation, presolve_form::PresolveFormulation, verbose::Bool)
form_repr = presolve_form.form
if verbose
for col in 1:form_repr.nb_vars
if !(form_repr.lbs[col] <= form_repr.ubs[col])
println(
"Infeasible due to variable ",
getname(form, presolve_form.col_to_var[col]),
" lb = ",
form_repr.lbs[col],
" ub = ",
form_repr.ubs[col],
" of form. ",
getuid(form)
)
break
end
end
end
feasible = all(col -> form_repr.lbs[col] <= form_repr.ubs[col], 1:form_repr.nb_vars)
if verbose && !feasible
println("Formulation ", getuid(form), " is infeasible!")
end
return feasible
end
function update_multiplicities!(presolve_repr_master, presolve_sp, feasible::Bool)
l_mult, u_mult = if feasible
lm = presolve_sp.form.lower_multiplicity
um = presolve_sp.form.upper_multiplicity
for (var, local_lb, local_ub) in zip(
presolve_sp.col_to_var, presolve_sp.form.lbs, presolve_sp.form.ubs
)
varid = getid(var)
master_col = presolve_repr_master.var_to_col[varid]
global_lb = presolve_repr_master.form.lbs[master_col]
global_ub = presolve_repr_master.form.ubs[master_col]
# update of lower multiplicity
if global_lb > 0 && local_ub > 0
# no need to check !isinf(global_lb)
new_lm = ceil(global_lb / local_ub)
lm = max(new_lm, lm)
elseif global_ub < 0 && local_lb < 0
# no need to check !isinf(global_ub)
new_lm = ceil(global_ub / local_lb)
lm = max(new_lm, lm)
end
# update of upper multiplicity
if local_lb > 0 && global_ub > 0
# no need to check !isinf(local_lb)
new_um = floor(global_ub / local_lb)
um = min(um, new_um)
elseif local_ub < 0 && global_lb < 0
# no need to check !isinf(local_ub)
new_um = floor(global_lb / local_ub)
um = min(um, new_um)
end
end
lm, um
else
0, 0
end
presolve_sp.form.lower_multiplicity = l_mult
presolve_sp.form.upper_multiplicity = u_mult
end
function presolve_iteration!(
reform::Reformulation, presolve_reform::DwPresolveReform, verbose::Bool
)
master = getmaster(reform)
# Presolve the respresentative master.
presolve_formulation!(presolve_reform.representative_master)
if verbose
print("Global bounds after presolve:")
for (col, var) in enumerate(presolve_reform.representative_master.col_to_var)
print(
" ",
getname(master, var),
":[",
presolve_reform.representative_master.form.lbs[col],
",",
presolve_reform.representative_master.form.ubs[col],
"]"
)
end
println()
end
# Presolve subproblems
for (sp_id, presolve_sp) in presolve_reform.dw_sps
iszero(presolve_sp.form.upper_multiplicity) && continue
# Propagate and strengthen local bounds.
propagate_local_bounds!(presolve_reform.representative_master, presolve_sp)
if verbose
println(
"Multiplicities of $sp_id:[",
presolve_sp.form.lower_multiplicity,
",",
presolve_sp.form.upper_multiplicity,
"]"
)
print("Local bounds of sp $sp_id after propagation from global bounds:")
for (col, var) in enumerate(presolve_sp.col_to_var)
print(
" ",
getname(get_dw_pricing_sps(reform)[sp_id], var),
":[",
presolve_sp.form.lbs[col],
",",
presolve_sp.form.ubs[col],
"]"
)
end
println()
end
presolve_formulation!(presolve_sp)
if verbose
print("Local bounds of sp $sp_id after presolve:")
for (col, var) in enumerate(presolve_sp.col_to_var)
print(
" ",
getname(get_dw_pricing_sps(reform)[sp_id], var),
":[",
presolve_sp.form.lbs[col],
",",
presolve_sp.form.ubs[col],
"]"
)
end
println()
end
feasible = check_feasibility!(get_dw_pricing_sps(reform)[sp_id], presolve_sp, verbose)
update_multiplicities!(presolve_reform.representative_master, presolve_sp, feasible)
# Propagate and strengthen global bounds.
propagate_global_bounds!(presolve_reform.representative_master, presolve_sp)
end
if verbose
print("Global bounds after propagation from local bounds:")
for (col, var) in enumerate(presolve_reform.representative_master.col_to_var)
print(
" ",
getname(master, var),
":[",
presolve_reform.representative_master.form.lbs[col],
",",
presolve_reform.representative_master.form.ubs[col],
"]"
)
end
println()
end
return check_feasibility!(master, presolve_reform.representative_master, verbose)
end
function deactivate_non_proper_columns!(reform::Reformulation)
master = getmaster(reform)
dw_sps = get_dw_pricing_sps(reform)
for (varid, _) in getvars(master)
if getduty(varid) <= MasterCol
spid = getoriginformuid(varid)
if !_column_is_proper(varid, dw_sps[spid])
deactivate!(master, varid)
end
end
end
return
end
function run!(
algo::PresolveAlgorithm, ::Env, reform::Reformulation, input::PresolveInput
)::PresolveOutput
algo.verbose && println("**** Start of presolve algorithm ****")
presolve_reform = create_presolve_reform(reform; verbose = algo.verbose)
# Identify the partial solution in the restricted master, compute the new rhs
# of all master constraints and new global and local bounds of the representative and
# subproblem variables.
local_restr_partial_sol = propagate_partial_sol_into_master!(
reform, presolve_reform, input.partial_sol_to_fix, algo.verbose
)
isnothing(local_restr_partial_sol) && return PresolveOutput(false)
# Perform several rounds of presolve.
for i in 1:3
algo.verbose && println("**** Presolve step $i ****")
if presolve_iteration!(reform, presolve_reform, algo.verbose) == false
algo.verbose && println("**** End of presolve algorithm ****")
return PresolveOutput(false)
end
end
update_partial_sol!(
getmaster(reform), presolve_reform.restricted_master, local_restr_partial_sol
)
update_reform_from_presolve!(reform, presolve_reform)
deactivate_non_proper_columns!(reform)
algo.verbose && println("**** End of presolve algorithm ****")
return PresolveOutput(true)
end
function _column_is_proper(col_id, sp_form)
# Retrieve the column in the pool.
pool = get_primal_sol_pool(sp_form)
solution = @view pool.solutions[col_id, :]
for (var_id, value) in solution
if value < getcurlb(sp_form, var_id) - Coluna.TOL || value > getcurub(sp_form, var_id) + Coluna.TOL
return false
end
end
return true
end
function column_is_proper(col_id, reform)
sp_id = getoriginformuid(col_id)
sp_form = get_dw_pricing_sps(reform)[sp_id]
return _column_is_proper(col_id, sp_form)
end
| Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 12364 | function propagate_global_bounds!(
presolve_repr_master::PresolveFormulation, presolve_sp::PresolveFormulation
)
# TODO: does not work with representatives of multiple subproblems.
lm = presolve_sp.form.lower_multiplicity
um = presolve_sp.form.upper_multiplicity
for (i, var) in enumerate(presolve_sp.col_to_var)
repr_col = get(presolve_repr_master.var_to_col, getid(var), nothing)
if !isnothing(repr_col)
local_lb = presolve_sp.form.lbs[i]
local_ub = presolve_sp.form.ubs[i]
global_lb = presolve_repr_master.form.lbs[repr_col]
global_ub = presolve_repr_master.form.ubs[repr_col]
new_global_lb = local_lb * (local_lb < 0 ? um : lm)
new_global_ub = local_ub * (local_ub < 0 ? lm : um)
isnan(new_global_lb) && (new_global_lb = 0)
isnan(new_global_ub) && (new_global_ub = 0)
presolve_repr_master.form.lbs[repr_col] = max(global_lb, new_global_lb)
presolve_repr_master.form.ubs[repr_col] = min(global_ub, new_global_ub)
end
end
return
end
function propagate_local_bounds!(
presolve_repr_master::PresolveFormulation, presolve_sp::PresolveFormulation
)
# TODO: does not work with representatives of multiple subproblems.
lm = presolve_sp.form.lower_multiplicity
um = presolve_sp.form.upper_multiplicity
for (i, var) in enumerate(presolve_sp.col_to_var)
repr_col = get(presolve_repr_master.var_to_col, getid(var), nothing)
if !isnothing(repr_col)
global_lb = presolve_repr_master.form.lbs[repr_col]
global_ub = presolve_repr_master.form.ubs[repr_col]
local_lb = presolve_sp.form.lbs[i]
local_ub = presolve_sp.form.ubs[i]
if !isinf(global_lb) && !isinf(local_ub) && !isinf(um)
new_local_lb = global_lb - (um - 1) * local_ub
presolve_sp.form.lbs[i] = max(new_local_lb, local_lb)
end
if !isinf(global_ub) && !isinf(local_lb)
new_local_ub = global_ub - max(0, lm - 1) * local_lb
presolve_sp.form.ubs[i] = min(new_local_ub, local_ub)
end
end
end
return
end
function get_partial_sol(
presolve_form::PresolveFormulation, partial_sol_to_fix::Dict{VarId,Float64}
)
new_partial_sol = zeros(Float64, length(presolve_form.col_to_var))
for (var_id, value) in partial_sol_to_fix
if !haskey(presolve_form.var_to_col, var_id)
if iszero(value)
continue
else
return nothing
end
end
new_partial_sol[presolve_form.var_to_col[var_id]] += value
end
return new_partial_sol
end
function compute_rhs(presolve_form, restr_partial_sol)
rhs = presolve_form.form.rhs
coef_matrix = presolve_form.form.col_major_coef_matrix
return rhs - coef_matrix * restr_partial_sol
end
function partial_sol_on_repr(
dw_sps,
presolve_master_repr::PresolveFormulation,
presolve_master_restr::PresolveFormulation,
restr_partial_sol
)
partial_solution = zeros(Float64, presolve_master_repr.form.nb_vars)
nb_fixed_columns = Dict(spid => 0 for (spid, _) in dw_sps)
new_column_explored = false
for (col, partial_sol_value) in enumerate(restr_partial_sol)
if abs(partial_sol_value) > Coluna.TOL
var = presolve_master_restr.col_to_var[col]
varid = getid(var)
if getduty(varid) <= MasterCol
spid = getoriginformuid(varid)
spform = get(dw_sps, spid, nothing)
@assert !isnothing(spform)
column = @view get_primal_sol_pool(spform).solutions[varid,:]
for (varid, val) in column
getduty(varid) <= DwSpPricingVar || continue
master_repr_var_col = get(presolve_master_repr.var_to_col, varid, nothing)
if !isnothing(master_repr_var_col)
partial_solution[master_repr_var_col] += val * partial_sol_value
end
if !new_column_explored
nb_fixed_columns[spid] += partial_sol_value
new_column_explored = true
end
end
new_column_explored = false
elseif getduty(varid) <= MasterPureVar
master_repr_var_col = get(presolve_master_repr.var_to_col, varid, nothing)
if !isnothing(master_repr_var_col)
partial_solution[master_repr_var_col] += partial_sol_value
end
end
end
end
return partial_solution, nb_fixed_columns
end
# For each master variable (master representative or master pure),
# this function calculates the domain, i.e. intevals in which their new (global) bounds should lie
function compute_repr_master_var_domains(
dw_pricing_sps,
presolve_reform::DwPresolveReform,
local_repr_partial_sol
)
sp_domains = Dict{VarId,Tuple{Float64,Float64}}()
for (sp_id, sp_presolve_form) in presolve_reform.dw_sps
lm = sp_presolve_form.form.lower_multiplicity
um = sp_presolve_form.form.upper_multiplicity
# Update domains for master representative variables using multiplicity.
sp_form = dw_pricing_sps[sp_id]
for (varid, var) in getvars(sp_form)
if getduty(varid) <= DwSpPricingVar
lb = getcurlb(sp_form, var)
ub = getcurub(sp_form, var)
(global_lb, global_ub) = get(sp_domains, varid, (0.0, 0.0))
global_lb += isinf(lb) ? lb : (lb > 0 ? lm : um) * lb
global_ub += isinf(ub) ? ub : (ub > 0 ? um : lm) * ub
sp_domains[varid] = (global_lb, global_ub)
end
end
end
presolve_repr_master = presolve_reform.representative_master
domains = Vector{Tuple{Float64, Float64}}()
sizehint!(domains, presolve_repr_master.form.nb_vars)
for col in 1:presolve_repr_master.form.nb_vars
varid = getid(presolve_repr_master.col_to_var[col])
domain = if haskey(sp_domains, varid)
sp_domains[varid]
elseif iszero(local_repr_partial_sol[col])
(-Inf, Inf)
elseif local_repr_partial_sol[col] > 0
(0, Inf)
else # local_repr_partial_sol[col] < 0
(-Inf, 0)
end
push!(domains, domain)
end
return domains
end
function propagate_partial_sol_to_global_bounds!(
presolve_repr_master, local_repr_partial_sol, master_var_domains
)
new_lbs = zeros(Float64, presolve_repr_master.form.nb_vars)
new_ubs = zeros(Float64, presolve_repr_master.form.nb_vars)
for (col, (val, lb, ub, (min_value, max_value))) in enumerate(
Iterators.zip(
local_repr_partial_sol,
presolve_repr_master.form.lbs,
presolve_repr_master.form.ubs,
master_var_domains
)
)
new_lbs[col] = max(lb - val, min_value)
new_ubs[col] = min(ub - val, max_value)
end
presolve_repr_master.form.lbs = new_lbs
presolve_repr_master.form.ubs = new_ubs
return
end
function propagate_in_presolve_form(
form::PresolveFormulation,
rows_to_deactivate::Vector{Int},
tightened_bounds::Dict{Int,Tuple{Float64,Bool,Float64,Bool}}
)
form_repr, row_mask, col_mask = PresolveFormRepr(
form.form,
rows_to_deactivate,
tightened_bounds,
form.form.lower_multiplicity,
form.form.upper_multiplicity
)
col_to_var = form.col_to_var[col_mask]
row_to_constr = form.row_to_constr[row_mask]
deactivated_constrs = form.deactivated_constrs
fixed_vars_dict = form.fixed_variables
var_to_col = Dict(getid(var) => k for (k, var) in enumerate(col_to_var))
constr_to_row = Dict(getid(constr) => k for (k, constr) in enumerate(row_to_constr))
for constr in form.row_to_constr[.!row_mask]
push!(deactivated_constrs, getid(constr))
end
@assert length(col_to_var) == length(form_repr.lbs)
@assert length(col_to_var) == length(form_repr.ubs)
@assert length(row_to_constr) == length(form_repr.rhs)
return PresolveFormulation(
col_to_var,
row_to_constr,
var_to_col,
constr_to_row,
form_repr,
deactivated_constrs,
fixed_vars_dict
)
end
function update_subproblem_multiplicities!(dw_sps, nb_fixed_columns_per_sp)
for (spid, presolve_sp) in dw_sps
lm = presolve_sp.form.lower_multiplicity
um = presolve_sp.form.upper_multiplicity
presolve_sp.form.lower_multiplicity = max(
0, lm - nb_fixed_columns_per_sp[spid]
)
presolve_sp.form.upper_multiplicity = max(
0, um - nb_fixed_columns_per_sp[spid]
) # TODO if < 0 -> error
end
return
end
"""
Returns the local restricted partial solution.
"""
function propagate_partial_sol_into_master!(
reform::Reformulation,
presolve_reform::DwPresolveReform,
partial_sol_to_fix::Dict{VarId,Float64},
verbose::Bool
)
presolve_representative_master = presolve_reform.representative_master
presolve_restricted_master = presolve_reform.restricted_master
# Create the local partial solution from the restricted master presolve representation.
# This local partial solution must then be "fixed" & propagated.
local_restr_partial_sol = get_partial_sol(presolve_restricted_master, partial_sol_to_fix)
isnothing(local_restr_partial_sol) && return nothing
# Compute the rhs of all constraints.
# Non-robust and convexity constraints rhs can only be computed using this representation.
new_rhs = compute_rhs(presolve_restricted_master, local_restr_partial_sol)
# Project local partial solution on the representative master.
local_repr_partial_sol, nb_fixed_columns_per_sp = partial_sol_on_repr(
get_dw_pricing_sps(reform),
presolve_representative_master,
presolve_restricted_master,
local_restr_partial_sol
)
if verbose
print("Partial solution in the representative formulation:")
master = getmaster(reform)
for (var, value) in zip(presolve_representative_master.col_to_var, local_repr_partial_sol)
if !iszero(value)
print(" ", getname(master, var), "=>", value)
end
end
println()
end
# Update the multiplicity of each subproblem.
update_subproblem_multiplicities!(presolve_reform.dw_sps, nb_fixed_columns_per_sp)
if verbose
print("New subproblem multiplicities:")
for (form_id, presolve_sp) in presolve_reform.dw_sps
print(
" sp.",
form_id,
":[",
presolve_sp.form.lower_multiplicity,
",",
presolve_sp.form.upper_multiplicity,
"]"
)
end
println()
end
# Compute master variables domains (in which variable bounds should lie)
master_var_domains = compute_repr_master_var_domains(
get_dw_pricing_sps(reform), presolve_reform, local_repr_partial_sol
)
# Propagate local partial solution from the representative master representation
# into the global bounds.
propagate_partial_sol_to_global_bounds!(
presolve_representative_master,
local_repr_partial_sol,
master_var_domains
)
if verbose
print("Global bounds after fixing partial solution:")
for (col, var) in enumerate(presolve_representative_master.col_to_var)
print(
" ",
getname(master, var),
":[",
presolve_representative_master.form.lbs[col],
",",
presolve_representative_master.form.ubs[col],
"]"
)
end
println()
end
# Update the rhs of the representative master.
@assert length(new_rhs) == length(presolve_restricted_master.form.rhs) ==
length(presolve_representative_master.form.rhs)
for (row, rhs) in enumerate(new_rhs)
presolve_representative_master.form.rhs[row] = rhs
end
return local_restr_partial_sol
end
| Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 15799 | ############################################################################################
# Node.
############################################################################################
"""
Branch-and-bound node. It stores only local information about the node.
Global information about the branch-and-bound belong to the search space object.
"""
mutable struct Node <: TreeSearch.AbstractNode
depth::Int
branchdescription::String
# The Node instance may have been created after its partial evaluation
# (e.g. strong branching). In this case, we store an OptimizationState in the node
# with the result of its partial evaluation.
# We then retrieve from this OptimizationState a possible new incumbent primal
# solution and communicate the latter to the branch-and-bound algorithm.
# We also store the final result of the conquer algorithm here so we can print these
# informations.
conquer_output::Union{Nothing, OptimizationState}
# Current local dual bound at the node:
# - dual bound of the parent node if the node has not been evaluated yet.
# - dual bound of the conquer if the node has been evaluated.
ip_dual_bound::Bound
# Information to restore the reformulation after the creation of the node (e.g. creation
# of the branching constraint) or its partial evaluation (e.g. strong branching).
records::Records
end
getdepth(n::Node) = n.depth
TreeSearch.isroot(n::Node) = n.depth == 0
Branching.isroot(n::Node) = TreeSearch.isroot(n)
TreeSearch.set_records!(n::Node, records) = n.records = records
TreeSearch.get_conquer_output(n::Node) = n.conquer_output
TreeSearch.get_branch_description(n::Node) = n.branchdescription # printer
# Priority of nodes depends on the explore strategy.
TreeSearch.get_priority(::TreeSearch.AbstractExploreStrategy, ::Node) = error("todo")
TreeSearch.get_priority(::TreeSearch.DepthFirstStrategy, n::Node) = -n.depth
TreeSearch.get_priority(::TreeSearch.BestDualBoundStrategy, n::Node) = n.ip_dual_bound
# TODO move
function Node(node::SbNode)
return Node(
node.depth, node.branchdescription, node.conquer_output, node.ip_dual_bound,
node.records
)
end
############################################################################################
# AbstractConquerInput implementation for the branch & bound.
############################################################################################
"Conquer input object created by the branch-and-bound tree search algorithm."
struct ConquerInputFromBaB <: AbstractConquerInput
units_to_restore::UnitsUsage
node_state::OptimizationState # Node state after its creation or its partial evaluation.
node_depth::Int
# Broadcast a new IP primal bound if found during evaluation of the node.
global_primal_handler::GlobalPrimalBoundHandler
end
get_global_primal_handler(i::ConquerInputFromBaB) = i.global_primal_handler
get_conquer_input_ip_dual_bound(i::ConquerInputFromBaB) = get_ip_dual_bound(i.node_state)
get_node_depth(i::ConquerInputFromBaB) = i.node_depth
get_units_to_restore(i::ConquerInputFromBaB) = i.units_to_restore
############################################################################################
# AbstractDivideInput implementation for the branch & bound.
############################################################################################
"Divide input object created by the branch-and-bound tree search algorithm."
struct DivideInputFromBaB <: Branching.AbstractDivideInput
parent_depth::Int
# The conquer output of the parent is very useful to compute scores when trying several
# branching candidates. Usually scores measure a progression between the parent full_evaluation
# and the children full evaluations. To allow developers to implement several kind of
# scores, we give the full output of the conquer algorithm.
parent_conquer_output::OptimizationState
# Records allow to restore the reformulation in the state it was at the end of the evaluation
# of the parent node. This operation happens in strong branching when evaluating several
# branching candidates.
parent_records::Records
# Broadcast a new IP primal bound if found during evaluation of the candidates in the
# strong branching.
global_primal_handler::GlobalPrimalBoundHandler
end
Branching.get_parent_depth(i::DivideInputFromBaB) = i.parent_depth
Branching.get_conquer_opt_state(i::DivideInputFromBaB) = i.parent_conquer_output
Branching.get_global_primal_handler(i::DivideInputFromBaB) = i.global_primal_handler
Branching.parent_is_root(i::DivideInputFromBaB) = i.parent_depth == 0
Branching.parent_records(i::DivideInputFromBaB) = i.parent_records
############################################################################################
# Leaves status
############################################################################################
"Leaves status"
mutable struct LeavesStatus
infeasible::Bool # true if all leaves are infeasible
worst_dual_bound::Union{Nothing,Bound} # worst dual bound of the leaves
end
LeavesStatus(reform) = LeavesStatus(true, nothing)
############################################################################################
# SearchSpace
############################################################################################
"Branch-and-bound search space."
mutable struct BaBSearchSpace <: AbstractColunaSearchSpace
# Reformulation that the branch-and-bound algorithm will optimize.
reformulation::Reformulation
# Algorithm that evaluates a node of the branch-and-bound tree.
conquer::AbstractConquerAlgorithm
# Algorithm that generated the children of a branch-and-bound node.
divide::AlgoAPI.AbstractDivideAlgorithm
# Limits
max_num_nodes::Int64
open_nodes_limit::Int64
time_limit::Int64
# Tolerances
opt_atol::Float64
opt_rtol::Float64
# Units to restore when B&B bound explores another node.
conquer_units_to_restore::UnitsUsage
# Global information about the branch-and-bound execution.
previous::Union{Nothing,TreeSearch.AbstractNode}
optstate::OptimizationState # from TreeSearchRuntimeData
nb_nodes_treated::Int
nb_untreated_nodes::Int
leaves_status::LeavesStatus
inc_primal_manager::GlobalPrimalBoundHandler # stores the global primal bound (shared with all child algorithms).
end
get_reformulation(sp::BaBSearchSpace) = sp.reformulation
get_conquer(sp::BaBSearchSpace) = sp.conquer
get_divide(sp::BaBSearchSpace) = sp.divide
get_previous(sp::BaBSearchSpace) = sp.previous
set_previous!(sp::BaBSearchSpace, previous::TreeSearch.AbstractNode) = sp.previous = previous
############################################################################################
# Tree search implementation
############################################################################################
function TreeSearch.stop(space::BaBSearchSpace, untreated_nodes)
_update_global_dual_bound!(space, space.reformulation, untreated_nodes) # this method needs to be reimplemented.
space.nb_untreated_nodes = length(untreated_nodes)
return space.nb_nodes_treated >= space.max_num_nodes || space.nb_untreated_nodes > space.open_nodes_limit
end
function TreeSearch.search_space_type(alg::TreeSearchAlgorithm)
# Only one file printer at the time. JSON file printer has priority.
active_file_printer = !iszero(length(alg.branchingtreefile)) || !iszero(length(alg.jsonfile))
file_printer_type = if !iszero(length(alg.jsonfile))
JSONFilePrinter
elseif !iszero(length(alg.branchingtreefile))
DotFilePrinter
else
DevNullFilePrinter
end
return if alg.print_node_info
PrinterSearchSpace{BaBSearchSpace,DefaultLogPrinter,file_printer_type}
elseif active_file_printer
PrinterSearchSpace{BaBSearchSpace,DevNullLogPrinter,file_printer_type}
else
BaBSearchSpace
end
end
function TreeSearch.new_space(
::Type{BaBSearchSpace}, algo::TreeSearchAlgorithm, reform::Reformulation, input
)
optstate = OptimizationState(getmaster(reform))
conquer_units_to_restore = collect_units_to_restore!(algo.conqueralg, reform)
return BaBSearchSpace(
reform,
algo.conqueralg,
algo.dividealg,
algo.maxnumnodes,
algo.opennodeslimit,
algo.timelimit,
algo.opt_atol,
algo.opt_rtol,
conquer_units_to_restore,
nothing,
optstate,
0,
0,
LeavesStatus(reform),
GlobalPrimalBoundHandler(reform; ip_primal_bound = get_ip_primal_bound(input))
)
end
function TreeSearch.new_root(sp::BaBSearchSpace, input)
nodestate = OptimizationState(getmaster(sp.reformulation), input, false, false)
return Node(
0, "", nothing, get_ip_dual_bound(nodestate), create_records(sp.reformulation)
)
end
# Send output information of the conquer algorithm to the branch-and-bound.
function after_conquer!(space::BaBSearchSpace, current, conquer_output)
@assert !isnothing(conquer_output)
treestate = space.optstate
for sol in get_ip_primal_sols(conquer_output)
store_ip_primal_sol!(space.inc_primal_manager, sol)
end
current.records = create_records(space.reformulation)
space.nb_nodes_treated += 1
# Branch & Bound returns the primal LP & the dual solution found at the root node.
best_lp_primal_sol = get_best_lp_primal_sol(conquer_output)
if TreeSearch.isroot(current) && !isnothing(best_lp_primal_sol)
set_lp_primal_sol!(treestate, best_lp_primal_sol)
end
best_lp_dual_sol = get_best_lp_dual_sol(conquer_output)
if TreeSearch.isroot(current) && !isnothing(best_lp_dual_sol)
set_lp_dual_sol!(treestate, best_lp_dual_sol)
end
# TODO: remove later but we currently need it to print information in the json file.
current.conquer_output = conquer_output
current.ip_dual_bound = get_lp_dual_bound(conquer_output)
return
end
# Conquer
function is_pruned(space::BaBSearchSpace, current::Node)
return MathProg.gap_closed(
get_global_primal_bound(space.inc_primal_manager),
current.ip_dual_bound,
atol = space.opt_atol,
rtol = space.opt_rtol
)
end
function node_is_pruned(space::BaBSearchSpace, current::Node)
leaves_status = space.leaves_status
leaves_status.infeasible = false # We have a primal bound, so a primal solution, and we closed the gap, so the original problem is feasible.
if isnothing(leaves_status.worst_dual_bound)
leaves_status.worst_dual_bound = current.ip_dual_bound
else
leaves_status.worst_dual_bound = worst(leaves_status.worst_dual_bound, current.ip_dual_bound)
end
return
end
function get_input(::AbstractConquerAlgorithm, space::BaBSearchSpace, current::Node)
space_state = space.optstate
node_state = OptimizationState(
getmaster(space.reformulation);
ip_dual_bound = current.ip_dual_bound
)
best_ip_primal_sol = get_best_ip_primal_sol(space_state)
if !isnothing(best_ip_primal_sol)
update_ip_primal_sol!(node_state, best_ip_primal_sol)
end
space_primal_bound = get_ip_primal_bound(space.optstate)
if !isnothing(space_primal_bound)
update_ip_primal_bound!(node_state, space_primal_bound)
end
return ConquerInputFromBaB(
space.conquer_units_to_restore,
node_state,
current.depth,
space.inc_primal_manager
)
end
# routine to check if divide should be call or not after a node conquer
# If the gap is closed between the prima bound and the LOCAL dual bound, then the exploration of the current branch should stop
function run_divide(sp::BaBSearchSpace, divide_input)
conquer_opt_state = Branching.get_conquer_opt_state(divide_input)
nodestatus = getterminationstatus(conquer_opt_state)
return !(
nodestatus == INFEASIBLE ||
MathProg.gap_closed(
get_global_primal_bound(sp.inc_primal_manager),
get_lp_dual_bound(conquer_opt_state)
)
)
end
function get_input(::AlgoAPI.AbstractDivideAlgorithm, space::BaBSearchSpace, node::Node, conquer_output)
return DivideInputFromBaB(node.depth, conquer_output, node.records, space.inc_primal_manager)
end
number_of_children(divide_output::DivideOutput) = length(divide_output.children)
function node_is_leaf(space::BaBSearchSpace, current::Node, conquer_output::OptimizationState)
leaves_status = space.leaves_status
if getterminationstatus(conquer_output) != INFEASIBLE
leaves_status.infeasible = false
# We only store the dual bound of the leaves that are not infeasible.
# Dual bound of an infeasible node means nothing.
if isnothing(leaves_status.worst_dual_bound)
leaves_status.worst_dual_bound = get_lp_dual_bound(conquer_output)
else
leaves_status.worst_dual_bound = worst(leaves_status.worst_dual_bound, get_lp_dual_bound(conquer_output))
end
end
return
end
function new_children(space::AbstractColunaSearchSpace, branches, node::Node)
children = map(Branching.get_children(branches)) do child
return Node(child)
end
return children
end
# Retrieves the current dual bound of unevaluated or partially evaluated nodes
# and keeps the worst one.
function _update_global_dual_bound!(space, reform::Reformulation, untreated_nodes)
treestate = space.optstate
leaves_worst_dual_bound = space.leaves_status.worst_dual_bound
init_db = if isnothing(leaves_worst_dual_bound)
# if we didn't reach any leaf in the branch-and-bound tree, it may exist
# some untreated nodes. We use the current ip dual bound of one untreated nodes to
# initialize the calculation of the global dual bound.
if length(untreated_nodes) > 0
first(untreated_nodes).ip_dual_bound
else # or all the leaves are infeasible and there is no untreated node => no dual bound.
@assert space.leaves_status.infeasible
DualBound(getmaster(reform))
end
else
# Otherwise, we use the worst dual bound at the leaves.
leaves_worst_dual_bound
end
worst_bound = mapreduce(
node -> node.ip_dual_bound,
worst,
untreated_nodes;
init = init_db
)
# The global dual bound of the branch-and-bound is a dual bound of the original problem (MIP).
set_ip_dual_bound!(treestate, worst_bound)
return
end
function node_change!(previous::Node, current::Node, space::BaBSearchSpace)
# We restore the reformulation in the state it was after the creation of the current node (e.g. creation
# of the branching constraint) or its partial evaluation (e.g. strong branching).
# TODO: We don't need to restore if the formulation has been fully evaluated.
restore_from_records!(space.conquer_units_to_restore, current.records)
end
function TreeSearch.tree_search_output(space::BaBSearchSpace)
all_leaves_infeasible = space.leaves_status.infeasible
if !isnothing(get_global_primal_sol(space.inc_primal_manager))
add_ip_primal_sol!(space.optstate, get_global_primal_sol(space.inc_primal_manager))
end
if all_leaves_infeasible && space.nb_untreated_nodes == 0
setterminationstatus!(space.optstate, INFEASIBLE)
elseif ip_gap_closed(space.optstate, rtol = space.opt_rtol, atol = space.opt_atol)
setterminationstatus!(space.optstate, OPTIMAL)
else
setterminationstatus!(space.optstate, OTHER_LIMIT)
end
#env.kpis.node_count = 0 #get_tree_order(tsdata) - 1 # TODO : check why we need to remove 1
return space.optstate
end | Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 11994 | ############################################################################################
# File printer API
############################################################################################
"Super type to dispatch on file printer methods."
abstract type AbstractFilePrinter end
@mustimplement "FilePrinter" new_file_printer(::Type{<:AbstractFilePrinter}, alg) = nothing
@mustimplement "FilePrinter" filename(::AbstractFilePrinter) = nothing
@mustimplement "FilePrinter" init_tree_search_file!(::AbstractFilePrinter) = nothing
@mustimplement "FilePrinter" print_node_in_tree_search_file!(::AbstractFilePrinter, node, space, env) = nothing
@mustimplement "FilePrinter" close_tree_search_file!(::AbstractFilePrinter) = nothing
############################################################################################
# Log printer API (on stdin)
############################################################################################
"Super type to dispatch on log printer method."
abstract type AbstractLogPrinter end
@mustimplement "LogPrinter" new_log_printer(::Type{<:AbstractLogPrinter}) = nothing
@mustimplement "LogPrinter" print_log(::AbstractLogPrinter, space, node, env, nb_untreated_nodes) = nothing
############################################################################################
# File & log printer search space.
# This is just a composite pattern on the tree search API.
############################################################################################
"""
Search space that contains the search space of the Coluna's tree search algorithm for which
we want to print execution logs.
"""
mutable struct PrinterSearchSpace{
ColunaSearchSpace<:AbstractColunaSearchSpace,
LogPrinter<:AbstractLogPrinter,
FilePrinter<:AbstractFilePrinter
} <: TreeSearch.AbstractSearchSpace
current_tree_order_id::Int
log_printer::LogPrinter
file_printer::FilePrinter
inner::ColunaSearchSpace
end
"""
Node that contains the node of the Coluna's tree search algorithm for which we want to
print execution logs.
"""
struct PrintedNode{Node<:TreeSearch.AbstractNode} <: TreeSearch.AbstractNode
tree_order_id::Int
parent_tree_order_id::Union{Int, Nothing}
inner::Node
end
TreeSearch.get_priority(explore::TreeSearch.AbstractExploreStrategy, n::PrintedNode) = TreeSearch.get_priority(explore, n.inner)
function TreeSearch.tree_search_output(sp::PrinterSearchSpace)
close_tree_search_file!(sp.file_printer)
return TreeSearch.tree_search_output(sp.inner)
end
function TreeSearch.new_space(
::Type{PrinterSearchSpace{ColunaSearchSpace,LogPrinter,FilePrinter}}, alg, model, input
) where {
ColunaSearchSpace<:AbstractColunaSearchSpace,
LogPrinter<:AbstractLogPrinter,
FilePrinter<:AbstractFilePrinter
}
inner_space = TreeSearch.new_space(ColunaSearchSpace, alg, model, input)
return PrinterSearchSpace(
0,
new_log_printer(LogPrinter),
new_file_printer(FilePrinter, alg),
inner_space
)
end
function TreeSearch.new_root(sp::PrinterSearchSpace, input)
inner_root = TreeSearch.new_root(sp.inner, input)
init_tree_search_file!(sp.file_printer)
return PrintedNode(sp.current_tree_order_id+=1, nothing, inner_root)
end
_inner_node(n::PrintedNode) = n.inner # `untreated_node` is a stack.
_inner_node(n::Pair{<:PrintedNode, Float64}) = first(n).inner # `untreated_node` is a priority queue.
function TreeSearch.children(sp::PrinterSearchSpace, current, env)
print_log(sp.log_printer, sp, current, env, sp.inner.nb_untreated_nodes)
children = TreeSearch.children(sp.inner, current.inner, env)
# We print node information in the file after the node has been evaluated.
print_node_in_tree_search_file!(sp.file_printer, current, sp, env)
return map(children) do child
return PrintedNode(sp.current_tree_order_id += 1, current.tree_order_id, child)
end
end
function TreeSearch.stop(sp::PrinterSearchSpace, untreated_nodes)
return TreeSearch.stop(sp.inner, Iterators.map(_inner_node, untreated_nodes))
end
############################################################################################
# Default file printers.
############################################################################################
"""
Does not print the branch and bound tree.
"""
struct DevNullFilePrinter <: AbstractFilePrinter end
new_file_printer(::Type{DevNullFilePrinter}, _) = DevNullFilePrinter()
filename(::DevNullFilePrinter) = nothing
init_tree_search_file!(::DevNullFilePrinter) = nothing
print_node_in_tree_search_file!(::DevNullFilePrinter, _, _, _) = nothing
close_tree_search_file!(::DevNullFilePrinter) = nothing
############################################################################################
# JSON file printer
############################################################################################
"""
File printer to create a JSON file of the branch and bound tree.
"""
struct JSONFilePrinter <: AbstractFilePrinter
filename::String
end
new_file_printer(::Type{JSONFilePrinter}, alg::TreeSearchAlgorithm) = JSONFilePrinter(alg.jsonfile)
filename(f::JSONFilePrinter) = f.filename
function init_tree_search_file!(f::JSONFilePrinter)
open(filename(f), "w") do file
println(file, "[")
end
return
end
# To get rid of "Inf".
function _printed_num(num)
if isinf(num)
if num < 0
return -99999999999
else
return +99999999999
end
end
return num
end
function print_node_in_tree_search_file!(f::JSONFilePrinter, node::PrintedNode, sp::PrinterSearchSpace, env)
is_root_node = iszero(getdepth(node.inner))
current_node_id = node.tree_order_id
current_node_depth = getdepth(node.inner)
current_parent_id = node.parent_tree_order_id
local_db = getvalue(node.inner.ip_dual_bound)
global_db = getvalue(get_ip_dual_bound(sp.inner.optstate))
global_pb = getvalue(get_global_primal_bound(sp.inner.inc_primal_manager))
time = elapsed_optim_time(env)
br_constr_description = TreeSearch.get_branch_description(node.inner)
gap_closed = ip_gap_closed(node.inner.conquer_output)
infeasible = getterminationstatus(node.inner.conquer_output) == INFEASIBLE
open(filename(f), "r+") do file
seekend(file)
@printf file "\n\t\t{ \"node_id\": %i, " current_node_id
@printf file "\"depth\": %i, " current_node_depth
@printf file "\"parent_id\": %s, " is_root_node ? "null" : string(current_parent_id)
@printf file "\"time\": %.2f, " time
@printf file "\"primal_bound\": %.4f, " _printed_num(global_pb)
@printf file "\"local_dual_bound\": %.4f, " _printed_num(local_db)
@printf file "\"global_dual_bound\": %.4f, " _printed_num(global_db)
@printf file "\"pruned\": %s, " gap_closed ? "true" : "false"
@printf file "\"infeasible\": %s, " infeasible ? "true" : "false"
@printf file "\"branch\": %s },\n" is_root_node ? "null" : string("\"", br_constr_description, "\"")
end
return
end
function close_tree_search_file!(f::JSONFilePrinter)
open(filename(f), "r+") do file
# rewind the closing brace character
seekend(file)
pos = position(file)
seek(file, pos - 2)
# just move the closing brace to the next line
println(file, "\n\t]")
end
return
end
############################################################################################
"""
File printer to create a dot file of the branch and bound tree.
"""
struct DotFilePrinter <: AbstractFilePrinter
filename::String
end
new_file_printer(::Type{DotFilePrinter}, alg::TreeSearchAlgorithm) = DotFilePrinter(alg.branchingtreefile)
filename(f::DotFilePrinter) = f.filename
function init_tree_search_file!(f::DotFilePrinter)
open(filename(f), "w") do file
println(file, "## dot -Tpdf thisfile > thisfile.pdf \n")
println(file, "digraph Branching_Tree {")
print(file, "\tedge[fontname = \"Courier\", fontsize = 10];}")
end
return
end
# TODO: fix
function print_node_in_tree_search_file!(f::DotFilePrinter, node::PrintedNode, sp::PrinterSearchSpace, env)
ncur = node.tree_order_id
depth = getdepth(node.inner)
npar = node.parent_tree_order_id
db = getvalue(node.inner.ip_dual_bound)
pb = getvalue(get_ip_primal_bound(sp.inner.optstate))
time = elapsed_optim_time(env)
br_constr_description = TreeSearch.get_branch_description(node.inner)
gap_closed = ip_gap_closed(node.inner.conquer_output)
open(filename(f), "r+") do file
# rewind the closing brace character
seekend(file)
pos = position(file)
seek(file, pos - 1)
# start writing over this character
if gap_closed
@printf file "\n\tn%i [label= \"N_%i (%.0f s) \\n[PRUNED , %.4f]\"];" ncur ncur time pb
else
@printf file "\n\tn%i [label= \"N_%i (%.0f s) \\n[%.4f , %.4f]\"];" ncur ncur time db pb
end
if depth > 0 # not root node
@printf file "\n\tn%i -> n%i [label= \"%s\"];}" npar ncur br_constr_description
else
print(file, "}")
end
end
return
end
function close_tree_search_file!(f::DotFilePrinter)
open(filename(f), "r+") do file
# rewind the closing brace character
seekend(file)
pos = position(file)
seek(file, pos - 1)
# just move the closing brace to the next line
println(file, "\n}")
end
return
end
############################################################################################
# Default node printers.
############################################################################################
"""
Does not log anything.
"""
struct DevNullLogPrinter <: AbstractLogPrinter end
new_log_printer(::Type{DevNullLogPrinter}) = DevNullLogPrinter()
print_log(::DevNullLogPrinter, _, _, _, _) = nothing
############################################################################################
"Default log printer."
struct DefaultLogPrinter <: AbstractLogPrinter end
new_log_printer(::Type{DefaultLogPrinter}) = DefaultLogPrinter()
function print_log(
::DefaultLogPrinter, sp::PrinterSearchSpace, node::PrintedNode, env, nb_untreated_nodes
)
is_root_node = iszero(getdepth(node.inner))
current_node_id = node.tree_order_id
current_node_depth = getdepth(node.inner)
current_parent_id = node.parent_tree_order_id
local_db = getvalue(node.inner.ip_dual_bound)
global_db = getvalue(get_ip_dual_bound(sp.inner.optstate))
global_pb = getvalue(get_global_primal_bound(sp.inner.inc_primal_manager))
time = elapsed_optim_time(env)
br_constr_description = TreeSearch.get_branch_description(node.inner)
bold = Crayon(bold = true)
unbold = Crayon(bold = false)
yellow_bg = Crayon(background = :light_yellow)
cyan_bg = Crayon(background = :light_cyan)
normal_bg = Crayon(background = :default)
println("***************************************************************************************")
if is_root_node
println("**** ", yellow_bg,"B&B tree root node", normal_bg)
else
println(
"**** ", yellow_bg, "B&B tree node N°", bold, current_node_id, unbold, normal_bg,
", parent N°", bold, current_parent_id, unbold,
", depth ", bold, current_node_depth, unbold,
", ", bold, nb_untreated_nodes, unbold, " untreated node", nb_untreated_nodes > 1 ? "s" : ""
)
end
@printf "**** Local DB = %.4f," local_db
@printf " global bounds: [ %.4f , %.4f ]," global_db global_pb
@printf " time = %.2f sec.\n" time
if !isempty(br_constr_description)
println("**** Branching constraint: ", cyan_bg, br_constr_description, normal_bg)
end
println("***************************************************************************************")
return
end
| Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 2051 | ############################################################################################
#
############################################################################################
is_cont_var(form, var_id) = getperenkind(form, var_id) == Continuous
is_int_val(val, tol) = abs(round(val) - val) < tol
dist_to_int(val) = min(val - floor(val), ceil(val) - val)
function dist_to_non_zero_int(val)
dist_to_floor = iszero(floor(val)) ? 1.0 : val - floor(val)
dist_to_ceil = iszero(ceil(val)) ? 1.0 : ceil(val) - val
return min(dist_to_floor, dist_to_ceil)
end
############################################################################################
# Iterate over variables and constraints
############################################################################################
# We need to inject the formulation in the filter function to retrieve variables & constraints
# data & filter on them.
# This has the same cost of doing a for loop but it allows separation of data manipulation
# and algorithmic logic that were mixed together in the body of the for loop.
filter_collection(filter, form, collection) =
Iterators.filter(filter, Iterators.zip(Iterators.cycle(Ref(form)), collection))
filter_vars(filter, form) = filter_collection(filter, form, getvars(form))
filter_constrs(filter, form) = filter_collection(filter, form, getconstrs(form))
# Predefined filters (two cases: pair and tuple):
active_and_explicit((form, key_val)) = iscuractive(form, first(key_val)) && isexplicit(form, first(key_val))
duty((_, (id, _))) = getduty(id)
combine(op, args, functions...) = Iterators.mapreduce(f -> f(args...), op, functions)
############################################################################################
# Time limit
############################################################################################
function time_limit_reached!(optim_state, env)
if Coluna.time_limit_reached(env)
setterminationstatus!(optim_state, TIME_LIMIT)
return true
end
return false
end | Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 15942 | mutable struct OptimizationState{F<:AbstractFormulation}
termination_status::TerminationStatus
incumbents::MathProg.ObjValues
max_length_ip_primal_sols::Int
max_length_lp_primal_sols::Int
max_length_lp_dual_sols::Int
insert_function_ip_primal_sols::Function
insert_function_lp_primal_sols::Function
insert_function_lp_dual_sols::Function
ip_primal_sols::Vector{PrimalSolution{F}}
lp_primal_sols::Vector{PrimalSolution{F}}
lp_dual_sols::Vector{DualSolution{F}}
end
function bestbound!(solutions::Vector{Sol}, max_len::Int, new_sol::Sol) where {Sol<:AbstractSolution}
push!(solutions, new_sol)
sort!(solutions, rev = true)
while length(solutions) > max_len
pop!(solutions)
end
return
end
function set!(solutions::Vector{Sol}, ::Int, new_sol::Sol) where {Sol<:AbstractSolution}
empty!(solutions)
push!(solutions, new_sol)
return
end
"""
OptimizationState(
form;
termination_status = OPTIMIZE_NOT_CALLED,
ip_primal_bound = nothing,
ip_dual_bound = nothing,
lp_primal_bound = nothing,
lp_dual_bound = nothing,
max_length_ip_primal_sols = 1,
max_length_lp_primal_sols = 1,
max_length_lp_dual_sols = 1,
insert_function_ip_primal_sols = bestbound!,
insert_function_lp_primal_sols = bestbound!,
insert_function_lp_dual_sols = bestbound!
)
A convenient structure to maintain and return solutions and bounds of a formulation
`form` during an optimization process. The termination status is `OPTIMIZE_NOT_CALLED`
by default. You can define the initial incumbent bounds using `ip_primal_bound`,
`ip_dual_bound`, `lp_primal_bound`, and `lp_primal_bound` keyword arguments. Incumbent
bounds are set to infinite (according to formulation objective sense) by default.
You can store three types of solutions `ip_primal_sols`, `lp_primal_sols`, and `lp_dual_sols`.
These solutions are stored in three lists. Keywords `max_length_ip_primal_sols`,
`max_length_lp_primal_sols`, and `max_length_lp_dual_sols` let you define the maximum
size of the lists. Keywords `insert_function_ip_primal_sols`, `insert_function_lp_primal_sols`,
and `insert_function_lp_dual_sols` let you provide a function to define the way
you want to insert a new solution in each list. By default, lists are sorted by
best bound.
You can also create an `OptimizationState` from another one :
OptimizationState(
form, source_state, copy_ip_primal_sol, copy_lp_primal_sol
)
It copies the termination status, all the bounds of `source_state`.
If copies the best IP primal solution when `copy_ip_primal_sol` equals `true` and
the best LP primal solution when `copy_lp_primal_sol` equals `true`.
"""
function OptimizationState(
form::F;
termination_status::TerminationStatus = OPTIMIZE_NOT_CALLED,
ip_primal_bound = nothing,
ip_dual_bound = nothing,
lp_primal_bound = nothing,
lp_dual_bound = nothing,
max_length_ip_primal_sols = 1,
max_length_lp_primal_sols = 1,
max_length_lp_dual_sols = 1,
insert_function_ip_primal_sols = bestbound!,
insert_function_lp_primal_sols = bestbound!,
insert_function_lp_dual_sols = bestbound!,
global_primal_bound_handler = nothing
) where {F <: AbstractFormulation}
if !isnothing(global_primal_bound_handler)
if !isnothing(ip_primal_bound)
@warn "Value of `ip_primal_bound` will be replaced by the value of the best primal bound stored in `global_primal_bound_manager``."
end
ip_primal_bound = get_global_primal_bound(global_primal_bound_handler)
end
incumbents = MathProg.ObjValues(
form;
ip_primal_bound = ip_primal_bound,
ip_dual_bound = ip_dual_bound,
lp_primal_bound = lp_primal_bound,
lp_dual_bound = lp_dual_bound
)
state = OptimizationState{F}(
termination_status,
incumbents,
max_length_ip_primal_sols,
max_length_lp_primal_sols,
max_length_lp_dual_sols,
insert_function_ip_primal_sols,
insert_function_lp_primal_sols,
insert_function_lp_dual_sols,
PrimalSolution{F}[], PrimalSolution{F}[], DualSolution{F}[]
)
return state
end
function OptimizationState(
form::AbstractFormulation, source_state::OptimizationState,
copy_ip_primal_sol::Bool, copy_lp_primal_sol::Bool
)
state = OptimizationState(
form,
termination_status = getterminationstatus(source_state),
ip_primal_bound = get_ip_primal_bound(source_state),
lp_primal_bound = PrimalBound(form),
ip_dual_bound = get_ip_dual_bound(source_state),
lp_dual_bound = get_lp_dual_bound(source_state)
)
best_ip_primal_sol = get_best_ip_primal_sol(source_state)
if best_ip_primal_sol !== nothing
set_ip_primal_sol!(state, best_ip_primal_sol)
end
best_lp_primal_sol = get_best_lp_primal_sol(source_state)
if best_lp_primal_sol !== nothing
set_lp_primal_sol!(state, best_lp_primal_sol)
end
return state
end
getterminationstatus(state::OptimizationState) = state.termination_status
setterminationstatus!(state::OptimizationState, status::TerminationStatus) = state.termination_status = status
"Return the best IP primal bound."
get_ip_primal_bound(state::OptimizationState) = state.incumbents.ip_primal_bound
"Return the best LP primal bound."
get_lp_primal_bound(state::OptimizationState) = state.incumbents.lp_primal_bound
"Return the best IP dual bound."
get_ip_dual_bound(state::OptimizationState) = state.incumbents.ip_dual_bound
"Return the best LP dual bound."
get_lp_dual_bound(state::OptimizationState) = state.incumbents.lp_dual_bound
"""
Update the primal bound of the mixed-integer program if the new one is better
than the current one according to the objective sense.
"""
update_ip_primal_bound!(state::OptimizationState, bound) = MathProg._update_ip_primal_bound!(state.incumbents, bound)
"""
Update the dual bound of the mixed-integer program if the new one is better than
the current one according to the objective sense.
"""
update_ip_dual_bound!(state::OptimizationState, bound) = MathProg._update_ip_dual_bound!(state.incumbents, bound)
"""
Update the primal bound of the linear program if the new one is better than the
current one according to the objective sense.
"""
update_lp_primal_bound!(state::OptimizationState, bound) = MathProg._update_lp_primal_bound!(state.incumbents, bound)
"""
Update the dual bound of the linear program if the new one is better than the
current one according to the objective sense.
"""
update_lp_dual_bound!(state::OptimizationState, bound) = MathProg._update_lp_dual_bound!(state.incumbents, bound)
"Set the best IP primal bound."
set_ip_primal_bound!(state::OptimizationState, bound) = state.incumbents.ip_primal_bound = bound
"Set the best LP primal bound."
set_lp_primal_bound!(state::OptimizationState, bound) = state.incumbents.lp_primal_bound = bound
"Set the best IP dual bound."
set_ip_dual_bound!(state::OptimizationState, bound) = state.incumbents.ip_dual_bound = bound
"Set the best LP dual bound."
set_lp_dual_bound!(state::OptimizationState, bound) = state.incumbents.lp_dual_bound = bound
"""
Return the gap between the best primal and dual bounds of the integer program.
Should not be used to check convergence
"""
ip_gap(state::OptimizationState) = MathProg._ip_gap(state.incumbents)
"Return the gap between the best primal and dual bounds of the linear program."
lp_gap(state::OptimizationState) = MathProg._lp_gap(state.incumbents)
"""
ip_gap_closed(optstate; atol = Coluna.DEF_OPTIMALITY_ATOL, rtol = Coluna.DEF_OPTIMALITY_RTOL)
Return true if the gap between the best primal and dual bounds of the integer program is closed
given optimality tolerances.
"""
ip_gap_closed(state::OptimizationState; kw...) = MathProg._ip_gap_closed(state.incumbents; kw...)
"""
lp_gap_closed(optstate; atol = Coluna.DEF_OPTIMALITY_ATOL, rtol = Coluna.DEF_OPTIMALITY_RTOL)
Return true if the gap between the best primal and dual bounds of the linear program is closed
given optimality tolerances.
"""
lp_gap_closed(state::OptimizationState; kw...) = MathProg._lp_gap_closed(state.incumbents; kw...)
"Return all IP primal solutions."
get_ip_primal_sols(state::OptimizationState) = state.ip_primal_sols
"Return the best IP primal solution if it exists; `nothing` otherwise."
function get_best_ip_primal_sol(state::OptimizationState)
length(state.ip_primal_sols) == 0 && return nothing
return state.ip_primal_sols[1]
end
"Return all LP primal solutions."
get_lp_primal_sols(state::OptimizationState) = state.lp_primal_sols
"Return the best LP primal solution if it exists; `nothing` otherwise."
function get_best_lp_primal_sol(state::OptimizationState)
length(state.lp_primal_sols) == 0 && return nothing
return state.lp_primal_sols[1]
end
"Return all LP dual solutions."
get_lp_dual_sols(state::OptimizationState) = state.lp_dual_sols
"Return the best LP dual solution if it exists; `nothing` otherwise."
function get_best_lp_dual_sol(state::OptimizationState)
length(state.lp_dual_sols) == 0 && return nothing
return state.lp_dual_sols[1]
end
# TODO : refactoring ?
function update!(dest_state::OptimizationState, orig_state::OptimizationState)
setterminationstatus!(dest_state, getterminationstatus(orig_state))
add_ip_primal_sols!(dest_state, get_ip_primal_sols(orig_state)...)
update_ip_dual_bound!(dest_state, get_ip_dual_bound(orig_state))
update_lp_dual_bound!(dest_state, get_lp_dual_bound(orig_state))
set_lp_primal_bound!(dest_state, get_lp_primal_bound(orig_state))
best_lp_primal_sol = get_best_lp_primal_sol(orig_state)
if !isnothing(best_lp_primal_sol)
set_lp_primal_sol!(dest_state, best_lp_primal_sol)
end
best_lp_dual_sol = get_best_lp_dual_sol(orig_state)
if !isnothing(best_lp_dual_sol)
set_lp_dual_sol!(dest_state, best_lp_dual_sol)
end
return
end
"""
update_ip_primal_sol!(optstate, sol)
Add the solution `sol` in the solutions list of `optstate` if and only if the
value of the solution is better than the incumbent. The solution is inserted in the list
by the method defined in `insert_function_ip_primal_sols` field of `OptimizationState`.
If the maximum length of the list is reached, the solution located at the end of the list
is removed.
Similar methods :
update_lp_primal_sol!(optstate, sol)
update_lp_dual_sol!(optstate, sol)
"""
function update_ip_primal_sol!(state::OptimizationState{F}, sol::PrimalSolution{F}) where {F}
state.max_length_ip_primal_sols == 0 && return
b = ColunaBase.Bound(state.incumbents.min, true, getvalue(sol))
if update_ip_primal_bound!(state, b)
state.insert_function_ip_primal_sols(state.ip_primal_sols, state.max_length_ip_primal_sols, sol)
end
return
end
"""
add_ip_primal_sol!(optstate, sol)
add_ip_primal_sols!(optstate, sols...)
Add the solution `sol` at the end of the solution list of `opstate`, sort the solution list,
remove the worst solution if the solution list size is exceded, and update the incumbent bound if
the solution is better.
Similar methods :
add_lp_primal_sol!(optstate, sol)
add_lp_dual_sol!(optstate, sol)
"""
function add_ip_primal_sol!(state::OptimizationState{F}, sol::PrimalSolution{F}) where {F}
state.max_length_ip_primal_sols == 0 && return
state.insert_function_ip_primal_sols(state.ip_primal_sols, state.max_length_ip_primal_sols, sol)
pb = ColunaBase.Bound(state.incumbents.min, true, getvalue(sol))
update_ip_primal_bound!(state, pb)
return
end
function add_ip_primal_sols!(state::OptimizationState, sols...)
for sol in sols
add_ip_primal_sol!(state, sol)
end
return
end
"""
set_ip_primal_sol!(optstate, sol)
Empties the list of solutions and add solution `sol` in the list.
The incumbent bound is not updated even if the value of the solution is better.
Similar methods :
set_lp_primal_sol!(optstate, sol)
set_lp_dual_sol!(optstate, sol)
"""
function set_ip_primal_sol!(state::OptimizationState{F}, sol::PrimalSolution{F}) where {F}
state.max_length_ip_primal_sols == 0 && return
set!(state.ip_primal_sols, state.max_length_ip_primal_sols, sol)
return
end
"""
empty_ip_primal_sols!(optstate)
Remove all IP primal solutions from `optstate`.
Similar methods :
empty_lp_primal_sols!(optstate)
empty_lp_dual_sols!(optstate)
"""
empty_ip_primal_sols!(state::OptimizationState) = empty!(state.ip_primal_sols)
"Similar to [`update_ip_primal_sol!`](@ref)."
function update_lp_primal_sol!(state::OptimizationState{F}, sol::PrimalSolution{F}) where {F}
state.max_length_lp_primal_sols == 0 && return
pb = ColunaBase.Bound(state.incumbents.min, true, getvalue(sol))
if update_lp_primal_bound!(state, pb)
state.insert_function_lp_primal_sols(state.lp_primal_sols, state.max_length_lp_primal_sols, sol)
end
return
end
"Similar to [`add_ip_primal_sol!`](@ref)."
function add_lp_primal_sol!(state::OptimizationState{F}, sol::PrimalSolution{F}) where {F}
state.max_length_lp_primal_sols == 0 && return
state.insert_function_lp_primal_sols(state.lp_primal_sols, state.max_length_lp_primal_sols, sol)
pb = ColunaBase.Bound(state.incumbents.min, true, getvalue(sol))
update_lp_primal_bound!(state, pb)
return
end
"Similar to [`set_ip_primal_sol!`](@ref)."
function set_lp_primal_sol!(state::OptimizationState{F}, sol::PrimalSolution{F}) where {F}
state.max_length_lp_primal_sols == 0 && return
set!(state.lp_primal_sols, state.max_length_lp_primal_sols, sol)
return
end
"Similar to [`empty_ip_primal_sols!`](@ref)."
empty_lp_primal_sols!(state::OptimizationState) = empty!(state.lp_primal_sols)
"Similar to [`update_ip_primal_sol!`](@ref)."
function update_lp_dual_sol!(state::OptimizationState{F}, sol::DualSolution{F}) where {F}
state.max_length_lp_dual_sols == 0 && return
db = ColunaBase.Bound(state.incumbents.min, false, getvalue(sol))
if update_lp_dual_bound!(state, db)
state.insert_function_lp_dual_sols(state.lp_dual_sols, state.max_length_lp_dual_sols, sol)
end
return
end
"Similar to [`add_ip_primal_sol!`](@ref)."
function add_lp_dual_sol!(state::OptimizationState{F}, sol::DualSolution{F}) where {F}
state.max_length_lp_dual_sols == 0 && return
state.insert_function_lp_dual_sols(state.lp_dual_sols, state.max_length_lp_dual_sols, sol)
db = ColunaBase.Bound(state.incumbents.min, false, getvalue(sol))
update_lp_dual_bound!(state, db)
return
end
"Similar to [`set_ip_primal_sol!`](@ref)."
function set_lp_dual_sol!(state::OptimizationState{F}, sol::DualSolution{F}) where {F}
state.max_length_lp_dual_sols == 0 && return
set!(state.lp_dual_sols, state.max_length_lp_dual_sols, sol)
return
end
"Similar to [`empty_ip_primal_sols!`](@ref)."
empty_lp_dual_sols!(state::OptimizationState) = empty!(state.lp_dual_sols)
function Base.print(io::IO, form::AbstractFormulation, optstate::OptimizationState)
println(io, "┌ Optimization state ")
println(io, "│ Termination status: ", optstate.termination_status)
println(io, "| Incumbents: ", optstate.incumbents)
n = length(optstate.ip_primal_sols)
println(io, "| IP Primal solutions (",n,")")
if n > 0
for sol in optstate.ip_primal_sols
print(io, form, sol)
end
end
n = length(optstate.lp_primal_sols)
println(io, "| LP Primal solutions (",n,"):")
if n > 0
for sol in optstate.lp_primal_sols
print(io, form, sol)
end
end
n = length(optstate.lp_dual_sols)
println(io, "| LP Dual solutions (",n,"):")
if n > 0
for sol in optstate.lp_dual_sols
print(io, form, sol)
end
end
println(io, "└")
return
end | Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 4700 | module Benders
include("../MustImplement/MustImplement.jl")
using .MustImplement
"""
Supertype for the objects to which belongs the implementation of the Benders cut generation and
that stores any kind of information during the execution of the Bender cut generation algorithm.
"""
abstract type AbstractBendersContext end
struct UnboundedError <: Exception end
include("interface.jl")
"Main loop of the Benders cut generation algorithm."
function run_benders_loop!(context, env; iter = 1)
iteration = iter
phase = nothing
ip_primal_sol = nothing
benders_iter_output = nothing
setup_reformulation!(get_reform(context), env)
while !stop_benders(context, benders_iter_output, iteration)
benders_iter_output = run_benders_iteration!(context, phase, env, ip_primal_sol)
after_benders_iteration(context, phase, env, iteration, benders_iter_output)
iteration += 1
end
O = benders_output_type(context)
return new_output(O, benders_iter_output)
end
"Runs one iteration of a Benders cut generation algorithm."
function run_benders_iteration!(context, phase, env, ip_primal_sol) ##TODO: remove arg phase from method signature
master = get_master(context)
mast_result = optimize_master_problem!(master, context, env)
O = benders_iteration_output_type(context)
is_min_sense = is_minimization(context)
# At least at the first iteration, if the master does not contain any Benders cut, the master will be
# unbounded. The implementation must provide a routine to handle this case.
# If the master is a MIP, we have to relax integrality constraints to retrieve a dual infeasibility
# certificate.
if is_unbounded(mast_result)
mast_result = treat_unbounded_master_problem_case!(master, context, env)
end
# If the master is unbounded (even after treating unbounded master problem case), we
# stop the algorithm because we don't handle unboundedness.
if is_unbounded(mast_result)
throw(UnboundedError())
end
# If the master is infeasible, it means the first level is infeasible and so the whole problem.
# We stop Benders.
if is_infeasible(mast_result)
return new_iteration_output(O, is_min_sense, 0, nothing, true, false, nothing)
end
mast_primal_sol = get_primal_sol(mast_result)
# Depending on whether the master was unbounded, we will solve a different separation problem.
# See Lemma 2 of "Implementing Automatic Benders Decomposition in a Modern MIP Solver" (Bonami et al., 2020)
# for more information.
unbounded_master_case = is_certificate(mast_result)
# Separation problems setup.
for (_, sp) in get_benders_subprobs(context)
if unbounded_master_case
setup_separation_for_unbounded_master_case!(context, sp, mast_primal_sol)
else
update_sp_rhs!(context, sp, mast_primal_sol)
end
end
# Solve the separation problems.
# Here one subproblem = one dual sol = possibly one cut (multi-cuts approach).
generated_cuts = set_of_cuts(context)
sep_sp_sols = set_of_sep_sols(context)
second_stage_cost = 0.0
for (_, sp_to_solve) in get_benders_subprobs(context)
sep_result = optimize_separation_problem!(context, sp_to_solve, env, unbounded_master_case)
if is_infeasible(sep_result)
sep_result = treat_infeasible_separation_problem_case!(context, sp_to_solve, env, unbounded_master_case)
end
if is_unbounded(sep_result)
throw(UnboundedError())
end
if is_infeasible(sep_result)
return new_iteration_output(O, is_min_sense, 0, nothing, true, false, nothing)
end
second_stage_cost += get_obj_val(sep_result) ## update η = sum of the costs of the subproblems given a fixed 1st level solution
# Push generated dual sol and cut in the context.
nb_cuts_pushed = 0
if push_in_set!(context, generated_cuts, sep_result)
nb_cuts_pushed += 1
else
push_in_set!(context, sep_sp_sols, sep_result)
end
end
if master_is_unbounded(context, second_stage_cost, unbounded_master_case)
throw(UnboundedError())
end
cut_ids = insert_cuts!(get_reform(context), context, generated_cuts)
nb_cuts_inserted = length(cut_ids)
# Build primal solution
ip_primal_sol = nothing
if nb_cuts_inserted == 0
ip_primal_sol = build_primal_solution(context, mast_primal_sol, sep_sp_sols)
end
master_obj_val = get_obj_val(mast_result)
return new_iteration_output(O, is_min_sense, nb_cuts_inserted, ip_primal_sol, false, false, master_obj_val)
end
end | Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 10125 | ############################################################################################
# Reformulation getters
############################################################################################
"Returns `true` if the objective sense is minimization, `false` otherwise."
@mustimplement "BendersProbInfo" is_minimization(context::AbstractBendersContext) = nothing
"Returns Benders reformulation."
@mustimplement "BendersProbInfo" get_reform(context::AbstractBendersContext) = nothing
"Returns the master problem."
@mustimplement "BendersProbInfo" get_master(context::AbstractBendersContext) = nothing
"Returns the separation subproblems."
@mustimplement "BendersProbInfo" get_benders_subprobs(context) = nothing
############################################################################################
# Main loop
############################################################################################
"Prepares the reformulation before starting the Benders cut generation algorithm."
@mustimplement "Benders" setup_reformulation!(reform, env) = nothing
"Returns `true` if the Benders cut generation algorithm must stop, `false` otherwise."
@mustimplement "Benders" stop_benders(::AbstractBendersContext, benders_iter_output, iteration) = nothing
"Placeholder method called after each iteration of the Benders cut generation algorithm."
@mustimplement "Benders" after_benders_iteration(::AbstractBendersContext, phase, env, iteration, benders_iter_output) = nothing
############################################################################################
# Benders output
############################################################################################
"Supertype for the custom objects that will store the output of the Benders cut generation algorithm."
abstract type AbstractBendersOutput end
"""
benders_output_type(context) -> Type{<:AbstractBendersOutput}
Returns the type of the custom object that will store the output of the Benders cut generation
algorithm.
"""
@mustimplement "Benders" benders_output_type(::AbstractBendersContext) = nothing
"Returns a new instance of the custom object that stores the output of the Benders cut generation algorithm."
@mustimplement "Benders" new_output(::Type{<:AbstractBendersOutput}, benders_iter_output) = nothing
############################################################################################
# Master optimization
############################################################################################
"""
optimize_master_problem!(master, context, env) -> MasterResult
Returns an instance of a custom object `MasterResult` that implements the following methods:
- `is_unbounded(res::MasterResult) -> Bool`
- `is_infeasible(res::MasterResult) -> Bool`
- `is_certificate(res::MasterResult) -> Bool`
- `get_primal_sol(res::MasterResult) -> Union{Nothing, PrimalSolution}`
"""
@mustimplement "Benders" optimize_master_problem!(master, context, env) = nothing
############################################################################################
# Unbounded master case
############################################################################################
"""
treat_unbounded_master_problem_case!(master, context, env) -> MasterResult
When after a call to `optimize_master_problem!`, the master is unbounded, this method is called.
Returns an instance of a custom object `MasterResult`.
"""
@mustimplement "Benders" treat_unbounded_master_problem_case!(master, context, env) = nothing
############################################################################################
# Update separation subproblems
############################################################################################
"""
update_sp_rhs!(context, sp, mast_primal_sol)
Updates the right-hand side of the separation problem `sp` by fixing the first-level solution
obtained by solving the master problem `mast_primal_sol`.
"""
@mustimplement "Benders" update_sp_rhs!(context, sp, mast_primal_sol) = nothing
"""
setup_separation_for_unbounded_master_case!(context, sp, mast_primal_sol)
Updates the separation problem to derive a cut when the master problem is unbounded.
"""
@mustimplement "Benders" setup_separation_for_unbounded_master_case!(context, sp, mast_primal_sol) = nothing
############################################################################################
# Separation problem optimization
############################################################################################
"""
optimize_separation_problem!(context, sp_to_solve, env, unbounded_master) -> SeparationResult
Returns an instance of a custom object `SeparationResult` that implements the following methods:
- `is_unbounded(res::SeparationResult) -> Bool`
- `is_infeasible(res::SeparationResult) -> Bool`
- `get_obj_val(res::SeparationResult) -> Float64`
- `get_primal_sol(res::SeparationResult) -> Union{Nothing, PrimalSolution}`
- `get_dual_sp_sol(res::SeparationResult) -> Union{Nothing, DualSolution}`
"""
@mustimplement "Benders" optimize_separation_problem!(context, sp_to_solve, env, unbounded_master) = nothing
"""
treat_infeasible_separation_problem_case!(context, sp_to_solve, env, unbounded_master) -> SeparationResult
When after a call to `optimize_separation_problem!`, the separation problem is infeasible, this method is called.
Returns an instance of a custom object `SeparationResult`.
"""
@mustimplement "Benders" treat_infeasible_separation_problem_case!(context, sp_to_solve, env, unbounded_master_case) = nothing
############################################################################################
# Cuts and primal solutions
############################################################################################
"""
Returns an empty container that will store all the cuts generated by the separation problems
during an iteration of the Benders cut generation algorithm.
One must be able to iterate on this container to insert the cuts in the master problem.
"""
@mustimplement "Benders" set_of_cuts(context) = nothing
"""
Returns an empty container that will store the primal solutions to the separation problems
at a given iteration of the Benders cut generation algorithm.
"""
@mustimplement "Benders" set_of_sep_sols(context) = nothing
"""
push_in_set!(context, cut_pool, sep_result) -> Bool
Inserts a cut in the set of cuts generated at a given iteration of the Benders cut generation algorithm.
The `cut_pool` structure is generated by `set_of_cuts(context)`.
push_in_set!(context, sep_sp_sols, sep_result) -> Bool
Inserts a primal solution to a separation problem in the set of primal solutions generated at a given iteration of the Benders cut generation algorithm.
The `sep_sp_sols` structure is generated by `set_of_sep_sols(context)`.
Returns `true` if the cut or the primal solution was inserted in the set, `false` otherwise.
"""
@mustimplement "Benders" push_in_set!(context, pool, elem) = nothing
############################################################################################
# Cuts insertion
############################################################################################
"Inserts the cuts into the master."
@mustimplement "Benders" insert_cuts!(reform, context, generated_cuts) = nothing
############################################################################################
# Benders iteration output
############################################################################################
"Supertype for the custom objects that will store the output of a Benders iteration."
abstract type AbstractBendersIterationOutput end
"""
benders_iteration_output_type(context) -> Type{<:AbstractBendersIterationOutput}
Returns the type of the custom object that will store the output of a Benders iteration.
"""
@mustimplement "Benders" benders_iteration_output_type(::AbstractBendersContext) = nothing
"Returns a new instance of the custom object that stores the output of a Benders iteration."
@mustimplement "Benders" new_iteration_output(::Type{<:AbstractBendersIterationOutput}, is_min_sense, nb_cuts_inserted, ip_primal_sol, infeasible, time_limit_reached, master_obj_val) = nothing
############################################################################################
# Optimization result getters
############################################################################################
"Returns `true` if the problem is unbounded, `false` otherwise."
@mustimplement "Benders" is_unbounded(res) = nothing
"Returns `true` if the master is infeasible, `false` otherwise."
@mustimplement "Benders" is_infeasible(res) = nothing
"Returns the certificate of dual infeasibility if the master is unbounded, `nothing` otherwise."
@mustimplement "Benders" is_certificate(res) = nothing
"Returns the primal solution of the master problem if it exists, `nothing` otherwise."
@mustimplement "Benders" get_primal_sol(res) = nothing
"Returns the dual solution of the separation problem if it exists; `nothing` otherwise."
@mustimplement "Benders" get_dual_sol(res) = nothing
"Returns the objective value of the master or separation problem."
@mustimplement "BendersMasterResult" get_obj_val(master_res) = nothing
############################################################################################
# Build primal solution
############################################################################################
"""
Builds a primal solution to the original problem from the primal solution to the master
problem and the primal solutions to the separation problems.
"""
@mustimplement "Benders" build_primal_solution(context, mast_primal_sol, sep_sp_sols) = nothing
############################################################################################
# Master unboundedness
############################################################################################
"Returns `true` if the master has been proven unbounded, `false` otherwise."
@mustimplement "Benders" master_is_unbounded(context, second_stage_cost, unbounded_master_case) = nothing
| Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 13530 | module Branching
!true && include("../MustImplement/MustImplement.jl") # linter
using ..MustImplement
!true && include("../interface.jl") # linter
using ..AlgoAPI
include("candidate.jl")
include("criteria.jl")
include("rule.jl")
include("score.jl")
"""
Input of a divide algorithm used by the tree search algorithm.
Contains the parent node in the search tree for which children should be generated.
"""
abstract type AbstractDivideInput end
@mustimplement "DivideInput" get_parent_depth(i::AbstractDivideInput) = nothing
@mustimplement "DivideInput" get_conquer_opt_state(i::AbstractDivideInput) = nothing
@mustimplement "DivideInput" get_global_primal_handler(i::AbstractDivideInput) = nothing
@mustimplement "DivideInput" parent_is_root(i::AbstractDivideInput) = nothing
@mustimplement "DivideInput" parent_records(i::AbstractDivideInput) = nothing
"""
Output of a divide algorithm used by the tree search algorithm.
Should contain the vector of generated nodes.
"""
abstract type AbstractDivideOutput end
@mustimplement "DivideOutput" get_children(output::AbstractDivideOutput) = nothing
############################################################################################
# Branching API
############################################################################################
"Supertype for divide algorithm contexts."
abstract type AbstractDivideContext end
"Returns the number of candidates that the candidates selection step must return."
@mustimplement "Branching" get_selection_nb_candidates(::AlgoAPI.AbstractDivideAlgorithm) = nothing
"Returns the type of context required by the algorithm parameters."
@mustimplement "Branching" branching_context_type(::AlgoAPI.AbstractDivideAlgorithm) = nothing
"Creates a context."
@mustimplement "Branching" new_context(::Type{<:AbstractDivideContext}, algo::AlgoAPI.AbstractDivideAlgorithm, reform) = nothing
# TODO: can have a default implemntation when strong branching will be generic.
"Advanced candidates selection that selects candidates by evaluating their children."
@mustimplement "Branching" advanced_select!(::AbstractDivideContext, candidates, env, reform, input::AbstractDivideInput) = nothing
"Returns integer tolerance."
@mustimplement "Branching" get_int_tol(::AbstractDivideContext) = nothing
"Returns branching rules."
@mustimplement "Branching" get_rules(::AbstractDivideContext) = nothing
"Returns the selection criterion."
@mustimplement "Branching" get_selection_criterion(::AbstractDivideContext) = nothing
# find better name
@mustimplement "Branching" projection_on_master_is_possible(ctx, reform) = nothing
# branching output
"""
new_divide_output(children::Union{Vector{N}, Nothing}) where {N} -> AbstractDivideOutput
where:
- `N` is the type of nodes generated by the branching algorithm.
If no nodes are found, the generic implementation may provide `nothing`.
"""
@mustimplement "BranchingOutput" new_divide_output(children) = nothing
# Default implementations.
"Candidates selection for branching algorithms."
function select!(rule::AbstractBranchingRule, env, reform, input::Branching.BranchingRuleInput)
candidates = apply_branching_rule(rule, env, reform, input)
local_id = input.local_id + length(candidates)
select_candidates!(candidates, input.criterion, input.max_nb_candidates)
return BranchingRuleOutput(local_id, candidates)
end
abstract type AbstractBranchingContext <: AbstractDivideContext end
function advanced_select!(ctx::AbstractBranchingContext, candidates, env, reform, input::AbstractDivideInput)
children = generate_children!(ctx, first(candidates), env, reform, input)
return new_divide_output(children)
end
############################################################################################
# Strong branching API
############################################################################################
# Implementation
"Supertype for the strong branching contexts."
abstract type AbstractStrongBrContext <: AbstractDivideContext end
"Supertype for the branching phase contexts."
abstract type AbstractStrongBrPhaseContext end
"Creates a context for the branching phase."
@mustimplement "StrongBranching" new_phase_context(::Type{<:AbstractDivideContext}, phase, reform, phase_index) = nothing
"""
Returns the storage units that must be restored by the conquer algorithm called by the
strong branching phase.
"""
@mustimplement "StrongBranching" get_units_to_restore_for_conquer(::AbstractStrongBrPhaseContext) = nothing
"Returns all phases context of the strong branching algorithm."
@mustimplement "StrongBranching" get_phases(::AbstractStrongBrContext) = nothing
"Returns the type of score used to rank the candidates at a given strong branching phase."
@mustimplement "StrongBranching" get_score(::AbstractStrongBrPhaseContext) = nothing
"Returns the conquer algorithm used to evaluate the candidate's children at a given strong branching phase."
@mustimplement "StrongBranching" get_conquer(::AbstractStrongBrPhaseContext) = nothing
"Returns the maximum number of candidates kept at the end of a given strong branching phase."
@mustimplement "StrongBranching" get_max_nb_candidates(::AbstractStrongBrPhaseContext) = nothing
function advanced_select!(ctx::Branching.AbstractStrongBrContext, candidates, env, reform, input::Branching.AbstractDivideInput)
return perform_strong_branching!(ctx, env, reform, input, candidates)
end
function perform_strong_branching!(
ctx::AbstractStrongBrContext, env, reform, input::Branching.AbstractDivideInput, candidates::Vector{C}
) where {C<:AbstractBranchingCandidate}
return perform_strong_branching_inner!(ctx, env, reform, input, candidates)
end
function perform_strong_branching_inner!(
ctx::AbstractStrongBrContext, env, reform, input::Branching.AbstractDivideInput, candidates::Vector{C}
) where {C<:AbstractBranchingCandidate}
cand_children = [generate_children!(ctx, candidate, env, reform, input) for candidate in candidates]
phases = get_phases(ctx)
for (phase_index, current_phase) in enumerate(phases)
nb_candidates_for_next_phase = 1
if phase_index < length(phases)
nb_candidates_for_next_phase = get_max_nb_candidates(phases[phase_index + 1])
if length(cand_children) <= nb_candidates_for_next_phase
# If at the current phase, we have less candidates than the number of candidates
# we want to evaluate at the next phase, we skip the current phase.
continue
end
# In phase 1, we make sure that the number of candidates for the next phase is
# at least equal to the number of initial candidates.
nb_candidates_for_next_phase = min(nb_candidates_for_next_phase, length(cand_children))
end
scores = perform_branching_phase!(candidates, cand_children, current_phase, env, reform, input)
perm = sortperm(scores, rev=true)
permute!(cand_children, perm)
permute!(candidates, perm)
# The case where one/many candidate is conquered is not supported yet.
# In this case, the number of candidates for next phase is one.
# before deleting branching candidates which are not kept for the next phase
# we need to remove record kept in these nodes
resize!(cand_children, nb_candidates_for_next_phase)
resize!(candidates, nb_candidates_for_next_phase)
end
return new_divide_output(first(cand_children))
end
function perform_branching_phase!(candidates, cand_children, phase, env, reform, input)
return perform_branching_phase_inner!(cand_children, phase, env, reform, input)
end
"Performs a branching phase."
function perform_branching_phase_inner!(cand_children, phase, env, reform, input)
return map(cand_children) do children
# TODO; I don't understand why we need to sort the children here.
# Looks like eval_children_of_candidiate! and the default implementation of
# eval_child_of_candidate is fully independent of the order of the children.
# Moreover, given the generic implementation of perform_branching_phase!,
# it's not clear to me how the order of the children can affect the result.
# At the end, only the score matters and AFAIK, the score is also independent of the order.
# The reason of sorting (by Ruslan) : Ideally, we need to estimate the score of the candidate after
# the first branch is solved if the score estimation is worse than the best score found so far, we discard the candidate
# and do not evaluate the second branch. As estimation of score is not implemented, sorting is useless for now.
# children = sort(
# Branching.get_children(candidate),
# by = child -> get_lp_primal_bound(child)
# )
return eval_candidate!(children, phase, env, reform, input)
end
end
function eval_candidate!(children, phase::AbstractStrongBrPhaseContext, env, reform, input)
return eval_candidate_inner!(children, phase, env, reform, input)
end
"Evaluates a candidate."
function eval_candidate_inner!(children, phase::AbstractStrongBrPhaseContext, env, reform, input)
for child in children
eval_child_of_candidate!(child, phase, env, reform, input)
end
return compute_score(get_score(phase), children, input)
end
"Evaluate children of a candidate."
@mustimplement "StrongBranching" eval_child_of_candidate!(child, phase, env, reform, input) = nothing
@mustimplement "Branching" isroot(node) = nothing
##############################################################################
# Default implementation of the branching algorithm
##############################################################################
function candidates_selection(ctx::Branching.AbstractDivideContext, max_nb_candidates, reform, env, extended_sol, original_sol, input)
if isnothing(extended_sol)
error("Error") #TODO (talk with Ruslan.)
end
# We sort branching rules by their root/non-root priority.
sorted_rules = sort(Branching.get_rules(ctx), rev = true, by = x -> Branching.getpriority(x, parent_is_root(input)))
kept_branch_candidates = Branching.AbstractBranchingCandidate[]
local_id = 0 # TODO: this variable needs an explicit name.
priority_of_last_gen_candidates = nothing
for prioritised_rule in sorted_rules
rule = prioritised_rule.rule
# Priority of the current branching rule.
priority = Branching.getpriority(prioritised_rule, parent_is_root(input))
nb_candidates_found = length(kept_branch_candidates)
# Before selecting new candidates with the current branching rule, check if generation
# of candidates stops. Generation of candidates stops when:
# 1. at least one candidate was generated, and its priority rounded down is stricly greater
# than priorities of not yet considered branching rules; (TODO: example? use case?)
# 2. all needed candidates were generated and their smallest priority is strictly greater
# than priorities of not yet considered branching rules.
stop_gen_condition_1 = !isnothing(priority_of_last_gen_candidates) &&
nb_candidates_found > 0 && priority < floor(priority_of_last_gen_candidates)
stop_gen_condition_2 = !isnothing(priority_of_last_gen_candidates) &&
nb_candidates_found >= max_nb_candidates && priority < priority_of_last_gen_candidates
if stop_gen_condition_1 || stop_gen_condition_2
break
end
# Generate candidates.
output = Branching.select!(
rule, env, reform, Branching.BranchingRuleInput(
original_sol, true, max_nb_candidates, Branching.get_selection_criterion(ctx),
local_id, Branching.get_int_tol(ctx), priority, input
)
)
append!(kept_branch_candidates, output.candidates)
local_id = output.local_id
if projection_on_master_is_possible(ctx, reform) && !isnothing(extended_sol)
output = Branching.select!(
rule, env, reform, Branching.BranchingRuleInput(
extended_sol, false, max_nb_candidates, Branching.get_selection_criterion(ctx),
local_id, Branching.get_int_tol(ctx), priority, input
)
)
append!(kept_branch_candidates, output.candidates)
local_id = output.local_id
end
select_candidates!(kept_branch_candidates, Branching.get_selection_criterion(ctx), max_nb_candidates)
priority_of_last_gen_candidates = priority
end
return kept_branch_candidates
end
@mustimplement "Branching" why_no_candidate(reform, input, extended_sol, original_sol) = nothing
function run_branching!(ctx, env, reform, input::Branching.AbstractDivideInput, extended_sol, original_sol)
max_nb_candidates = get_selection_nb_candidates(ctx)
candidates = candidates_selection(ctx, max_nb_candidates, reform, env, extended_sol, original_sol, input)
# We stop branching if no candidate generated.
if length(candidates) == 0
@warn "No candidate generated. No children will be generated. However, the node is not conquered."
why_no_candidate(reform, input, extended_sol, original_sol)
return new_divide_output(nothing)
end
return advanced_select!(ctx, candidates, env, reform, input)
end
end | Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 1522 | ############################################################################################
# Candidates
############################################################################################
"""
A branching candidate is a data structure that contain all information needed to generate
children of a node.
"""
abstract type AbstractBranchingCandidate end
"Returns a string which serves to print the branching rule in the logs."
@mustimplement "BranchingCandidate" getdescription(candidate::AbstractBranchingCandidate) = nothing
# Branching candidate and branching rule should be together.
# the rule generates the candidate.
## Note: Branching candidates must be created in the BranchingRule algorithm so they do not need
## a generic constructor.
"Returns the left-hand side of the candidate."
@mustimplement "BranchingCandidate" get_lhs(c::AbstractBranchingCandidate) = nothing
"Returns the generation id of the candidiate."
@mustimplement "BranchingCandidate" get_local_id(c::AbstractBranchingCandidate) = nothing
"""
generate_children!(branching_context, branching_candidate, lhs, env, reform, node)
This method generates the children of a node described by `branching_candidate`.
"""
@mustimplement "BranchingCandidate" generate_children!(ctx, candidate::AbstractBranchingCandidate, env, reform, parent) = nothing
"List of storage units to restore before evaluating the node."
@mustimplement "BranchingCandidate" get_branching_candidate_units_usage(::AbstractBranchingCandidate, reform) = nothing
| Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 821 | ############################################################################################
# Selection Criteria of branching candidates
############################################################################################
"""
Supertype of selection criteria of branching candidates.
A selection criterion provides a way to keep only the most promising branching
candidates. To create a new selection criterion, one needs to create a subtype of
`AbstractSelectionCriterion` and implements the method `select_candidates!`.
"""
abstract type AbstractSelectionCriterion end
"Sort branching candidates according to the selection criterion and remove excess ones."
@mustimplement "BranchingSelection" select_candidates!(::Vector{<:AbstractBranchingCandidate}, selection::AbstractSelectionCriterion, ::Int) = nothing
| Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 1665 | ############################################################################################
# Branching rules
############################################################################################
"""
Supertype of branching rules.
"""
abstract type AbstractBranchingRule <: AlgoAPI.AbstractAlgorithm end
"""
PrioritisedBranchingRule
A branching rule with root and non-root priorities.
"""
struct PrioritisedBranchingRule
rule::AbstractBranchingRule
root_priority::Float64
nonroot_priority::Float64
end
function getpriority(rule::PrioritisedBranchingRule, isroot::Bool)::Float64
return isroot ? rule.root_priority : rule.nonroot_priority
end
"""
Input of a branching rule (branching separation algorithm)
Contains current solution, max number of candidates and local candidate id.
"""
struct BranchingRuleInput{SelectionCriterion<:AbstractSelectionCriterion,DivideInput,Solution}
solution::Solution
isoriginalsol::Bool
max_nb_candidates::Int64
criterion::SelectionCriterion
local_id::Int64
int_tol::Float64
minimum_priority::Float64
input::DivideInput
end
"""
Output of a branching rule (branching separation algorithm)
It contains the branching candidates generated and the updated local id value
"""
struct BranchingRuleOutput
local_id::Int64
candidates::Vector{AbstractBranchingCandidate}
end
# branching rules are always manager algorithms (they manage storing and restoring storage units)
ismanager(algo::AbstractBranchingRule) = true
"Returns all candidates that satisfy a given branching rule."
@mustimplement "BranchingRule" apply_branching_rule(rule, env, reform, input) = nothing
| Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 421 |
############################################################################################
# Branching score
############################################################################################
"""
Supertype of branching scores.
"""
abstract type AbstractBranchingScore end
"Returns the score of a candidate."
@mustimplement "BranchingScore" compute_score(::AbstractBranchingScore, candidate, input) = nothing | Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 13137 | "API and high-level implementation of the column generation algorithm in Julia."
module ColGen
include("../MustImplement/MustImplement.jl")
using .MustImplement
"""
Supertype for the objects to which belongs the implementation of the column generation and
that stores any kind of information during the execution of the column generation algorithm.
**IMPORTANT**: implementation of the column generation mainly depends on the context type.
"""
abstract type AbstractColGenContext end
include("stages.jl")
include("phases.jl")
include("pricing.jl")
include("stabilization.jl")
include("interface.jl")
"""
run!(ctx, env, ip_primal_sol; iter = 1) -> AbstractColGenOutput
Runs the column generation algorithm.
Arguments are:
- `ctx`: column generation context
- `env`: Coluna environment
- `ip_primal_sol`: current best primal solution to the master problem
- `iter`: iteration number (default: 1)
This function is responsible for initializing the column generation context, the reformulation,
and the stabilization. We iterate on the loop each time the phase or the stage changes.
"""
function run!(context, env, ip_primal_sol; iter = 1)
phase_it = new_phase_iterator(context)
phase = initial_phase(phase_it)
stage_it = new_stage_iterator(context)
stage = initial_stage(stage_it)
stab = setup_stabilization!(context, get_master(context))
phase_output = nothing
while !isnothing(phase) && !stop_colgen(context, phase_output) && !isnothing(stage)
setup_reformulation!(get_reform(context), phase)
setup_context!(context, phase)
last_iter = isnothing(phase_output) ? iter : phase_output.nb_iterations
phase_output = run_colgen_phase!(context, phase, stage, env, ip_primal_sol, stab; iter = last_iter)
phase = next_phase(phase_it, phase, phase_output)
stage = next_stage(stage_it, stage, phase_output)
end
O = colgen_output_type(context)
return new_output(O, phase_output)
end
"""
run_colgen_phase!(ctx, phase, stage, env, ip_primal_sol, stab; iter = 1) -> AbstractColGenPhaseOutput
Runs a phase of the column generation algorithm.
Arguments are:
- `ctx`: column generation context
- `phase`: current column generation phase
- `stage`: current column generation stage
- `env`: Coluna environment
- `ip_primal_sol`: current best primal solution to the master problem
- `stab`: stabilization
- `iter`: iteration number (default: 1)
This function is responsible for running the column generation iterations until the phase
is finished.
"""
function run_colgen_phase!(context, phase, stage, env, ip_primal_sol, stab; iter = 1)
iteration = iter
colgen_iter_output = nothing
incumbent_dual_bound = nothing
while !stop_colgen_phase(context, phase, env, colgen_iter_output, incumbent_dual_bound, ip_primal_sol, iteration)
before_colgen_iteration(context, phase)
colgen_iter_output = run_colgen_iteration!(context, phase, stage, env, ip_primal_sol, stab)
dual_bound = ColGen.get_dual_bound(colgen_iter_output)
if !isnothing(dual_bound) && (isnothing(incumbent_dual_bound) || is_better_dual_bound(context, dual_bound, incumbent_dual_bound))
incumbent_dual_bound = dual_bound
end
after_colgen_iteration(context, phase, stage, env, iteration, stab, ip_primal_sol, colgen_iter_output)
iteration += 1
end
O = colgen_phase_output_type(context)
return new_phase_output(O, is_minimization(context), phase, stage, colgen_iter_output, iteration, incumbent_dual_bound)
end
"""
run_colgen_iteration!(context, phase, stage, env, ip_primal_sol, stab) -> AbstractColGenIterationOutput
Runs an iteration of column generation.
Arguments are:
- `context`: column generation context
- `phase`: current column generation phase
- `stage`: current column generation stage
- `env`: Coluna environment
- `ip_primal_sol`: current best primal solution to the master problem
- `stab`: stabilization
"""
function run_colgen_iteration!(context, phase, stage, env, ip_primal_sol, stab)
master = get_master(context)
is_min_sense = is_minimization(context)
O = colgen_iteration_output_type(context)
mast_result = optimize_master_lp_problem!(master, context, env)
# Iteration continues only if master is not infeasible nor unbounded and has dual
# solution.
if is_infeasible(mast_result)
return new_iteration_output(O, is_min_sense, nothing, _inf(is_min_sense), 0, false, true, false, false, false, false, nothing, ip_primal_sol, nothing)
elseif is_unbounded(mast_result)
throw(UnboundedProblemError("Unbounded master problem."))
end
# Master primal solution
mast_primal_sol = get_primal_sol(mast_result)
if !isnothing(mast_primal_sol) && is_better_primal_sol(mast_primal_sol, ip_primal_sol)
# If the master LP problem has a primal solution, we can try to find a integer feasible
# solution.
# If the model has essential cut callbacks and the master LP solution is integral, one
# needs to make sure that the master LP solution does not violate any essential cuts.
# If an essential cut is violated, we expect that the `check_primal_ip_feasibility!` method
# will add the violated cut to the master formulation.
# If the formulation changes, one needs to restart the column generation to update
# memoization to calculate reduced costs and stabilization.
# TODO: the user can get the reformulation from the context.
new_ip_primal_sol, new_cut_in_master = check_primal_ip_feasibility!(mast_primal_sol, context, phase, env)
if new_cut_in_master
return new_iteration_output(O, is_min_sense, nothing, nothing, 0, true, false, false, false, false, false, nothing, ip_primal_sol, nothing)
end
if !isnothing(new_ip_primal_sol)
update_inc_primal_sol!(context, ip_primal_sol, new_ip_primal_sol)
end
end
mast_dual_sol = get_dual_sol(mast_result)
if isnothing(mast_dual_sol)
error("Column generation interrupted: LP solver did not return an optimal dual solution")
end
# Stores dual solution in the constraint. This is used when the pricing solver supports
# non-robust cuts.
update_master_constrs_dual_vals!(context, mast_dual_sol)
# Compute reduced cost (generic operation) by you must support math operations.
# We always compute the reduced costs of the subproblem variables against the real master
# dual solution because this is the cost of the subproblem variables in the pricing problems
# if we don't use stabilization, or because we use this cost to compute the real reduced cost
# of the columns when using stabilization.
c = get_subprob_var_orig_costs(context)
A = get_subprob_var_coef_matrix(context)
red_costs = c - transpose(A) * mast_dual_sol
# Buffer when using stabilization to compute the real reduced cost
# of the column once generated.
update_reduced_costs!(context, phase, red_costs)
# Stabilization
stab_changes_mast_dual_sol = update_stabilization_after_master_optim!(stab, phase, mast_dual_sol)
# TODO: check the compatibility of the pricing strategy and the stabilization.
# All generated columns during this iteration will be stored in the following container.
# We will insert them into the master after the optimization of the pricing subproblems.
# It is empty.
generated_columns = set_of_columns(context)
valid_db = nothing
misprice = true # because we need to run the pricing at least once.
# This variable is updated at the end of the pricing loop.
# If there is no stabilization, the pricing loop is run only once.
while misprice
# `sep_mast_dual_sol` is the master dual solution used to optimize the pricing subproblems.
# in the current misprice iteration.
sep_mast_dual_sol = get_stab_dual_sol(stab, phase, mast_dual_sol)
# We will optimize the pricing subproblem using the master dual solution returned
# by the stabilization. We this need to recompute the reduced cost of the subproblem
# variables if the stabilization changes the master dual solution.
cur_red_costs = if stab_changes_mast_dual_sol
c - transpose(A) * sep_mast_dual_sol
else
red_costs
end
# Updates subproblems reduced costs.
for (_, sp) in get_pricing_subprobs(context)
update_sp_vars_red_costs!(context, sp, cur_red_costs)
end
# To compute the master dual bound, we need a dual bound to each pricing subproblems.
# So we ask for an initial dual bound for each pricing subproblem that we update when
# solving the pricing subproblem.
# Depending on the pricing strategy, the user can choose to solve only some subproblems.
# If the some subproblems have not been solved, we use this initial dual bound to
# compute the master dual bound.
sps_db = Dict(sp_id => compute_sp_init_db(context, sp) for (sp_id, sp) in get_pricing_subprobs(context))
# The primal bound is used to compute the psueudo dual bound (used by stabilization).
sps_pb = Dict(sp_id => compute_sp_init_pb(context, sp) for (sp_id, sp) in get_pricing_subprobs(context))
# Solve pricing subproblems
pricing_strategy = get_pricing_strategy(context, phase)
sp_to_solve_it = pricing_strategy_iterate(pricing_strategy)
while !isnothing(sp_to_solve_it)
(sp_id, sp_to_solve), state = sp_to_solve_it
optimizer = get_pricing_subprob_optimizer(stage, sp_to_solve)
pricing_result = optimize_pricing_problem!(context, sp_to_solve, env, optimizer, mast_dual_sol, stab_changes_mast_dual_sol)
# Iteration continues only if the pricing solution is not infeasible nor unbounded.
if is_infeasible(pricing_result)
# TODO: if the lower multiplicity of the subproblem is zero, we can continue.
return new_iteration_output(O, is_min_sense, nothing, _inf(is_min_sense), 0, false, false, false, true, false, false, mast_primal_sol, ip_primal_sol, mast_dual_sol)
elseif is_unbounded(pricing_result)
# We do not support unbounded pricing (even if it's theorically possible).
# We must stop Coluna here by throwing an exception because we can't claim
# the problem is unbounded.
throw(UnboundedProblemError("Unbounded subproblem."))
end
primal_sols = get_primal_sols(pricing_result)
nb_cols_pushed = 0
for primal_sol in primal_sols # multi column generation support.
# The implementation is reponsible for checking if the column is a candidate
# for insertion into the master.
if push_in_set!(context, generated_columns, primal_sol)
nb_cols_pushed += 1
end
end
# Updates the initial bound if the pricing subproblem result has a dual bound.
sp_db = get_dual_bound(pricing_result)
if !isnothing(sp_db)
sps_db[sp_id] = sp_db
end
sp_pb = get_primal_bound(pricing_result)
if !isnothing(sp_pb)
sps_pb[sp_id] = sp_pb
end
sp_to_solve_it = pricing_strategy_iterate(pricing_strategy, state)
end
# compute valid dual bound using the dual bounds returned by the user (cf pricing result).
valid_db = compute_dual_bound(context, phase, sps_db, generated_columns, sep_mast_dual_sol)
# pseudo dual bound is used for stabilization only.
pseudo_db = compute_dual_bound(context, phase, sps_pb, generated_columns, sep_mast_dual_sol)
update_stabilization_after_pricing_optim!(stab, context, generated_columns, master, pseudo_db, sep_mast_dual_sol)
# We have finished to solve all pricing subproblems.
# If we have stabilization, we need to check if we have misprice, i.e. if smoothing is active
# and no negative reduced cost columns are generated
# If we have misprice, we need to update the stabilization center and the smoothed dual solution
# and solve again the pricing subproblems.
# If we don't have misprice, we can stop the pricing loop.
misprice = check_misprice(stab, generated_columns, mast_dual_sol)
if misprice
update_stabilization_after_misprice!(stab, mast_dual_sol)
end
end
# Insert columns into the master.
# The implementation is responsible for checking if the column is "valid".
col_ids = insert_columns!(context, phase, generated_columns)
nb_cols_inserted = length(col_ids)
update_stabilization_after_iter!(stab, mast_dual_sol)
return new_iteration_output(O, is_min_sense, get_obj_val(mast_result), valid_db, nb_cols_inserted, false, false, false, false, false, false, mast_primal_sol, ip_primal_sol, mast_dual_sol)
end
end | Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 14099 | struct UnboundedProblemError <: Exception
message::String
end
############################################################################################
# Reformulation getters
############################################################################################
"Returns Dantzig-Wolfe reformulation."
@mustimplement "ColGen" get_reform(ctx) = nothing
"Returns master formulation."
@mustimplement "ColGen" get_master(ctx) = nothing
"Returns `true` if the objective sense is minimization; `false` otherwise."
@mustimplement "ColGen" is_minimization(ctx) = nothing
"""
get_pricing_subprobs(ctx) -> Vector{Tuple{SuproblemId, SpFormulation}}
Returns subproblem formulations.
"""
@mustimplement "ColGen" get_pricing_subprobs(ctx) = nothing
############################################################################################
# Result getters
############################################################################################
"Returns true if a master or pricing problem result is infeasible; false otherwise."
@mustimplement "ColGenResultGetter" is_infeasible(res) = nothing
"Returns true if a master or pricing problem result is unbounded; false otherwise."
@mustimplement "ColGenResultGetter" is_unbounded(res) = nothing
"""
Returns the optimal objective value of the master LP problem."
See `optimize_master_lp_problem!`.
"""
@mustimplement "ColGenResultGetter" get_obj_val(master_res) = nothing
"Returns primal solution to the master LP problem."
@mustimplement "ColGenResultGetter" get_primal_sol(master_res) = nothing
"Returns dual solution to the master optimization problem."
@mustimplement "ColGenResultGetter" get_dual_sol(master_res) = nothing
"Array of primal solutions to the pricing subproblem"
@mustimplement "ColGenResultGetter" get_primal_sols(pricing_res) = nothing
"""
Returns dual bound of the pricing subproblem; `nothing` if no dual bound is available and
the initial dual bound returned by `compute_sp_init_db` will be used to compute the master
dual bound.
"""
@mustimplement "ColGenResultGetter" get_dual_bound(pricing_res) = nothing
"""
Returns primal bound of the pricing subproblem; `nothing` if no primal bound is available
and the initial dual bound returned by `compute_sp_init_pb` will be used to compute the
pseudo dual bound.
"""
@mustimplement "ColGenResultGetter" get_primal_bound(pricing_res) = nothing
############################################################################################
# Master resolution.
############################################################################################
"""
optimize_master_lp_problem!(master, context, env) -> MasterResult
Returns an instance of a custom object `MasterResult` that implements the following methods:
- `get_obj_val`: objective value of the master (mandatory)
- `get_primal_sol`: primal solution to the master (optional)
- `get_dual_sol`: dual solution to the master (mandatory otherwise column generation stops)
It should at least return a dual solution (obtained with LP optimization or subgradient)
otherwise column generation cannot continue.
"""
@mustimplement "ColGenMaster" optimize_master_lp_problem!(master, context, env) = nothing
############################################################################################
# Master solution integrality.
############################################################################################
"""
Returns a primal solution expressed in the original problem variables if the current master
LP solution is integer feasible; `nothing` otherwise.
"""
@mustimplement "ColGenMasterIntegrality" check_primal_ip_feasibility!(mast_lp_primal_sol, ::AbstractColGenContext, phase, env) = nothing
"""
Returns `true` if the new master IP primal solution is better than the current; `false` otherwise.
"""
@mustimplement "ColGenMasterIntegrality" is_better_primal_sol(new_ip_primal_sol, ip_primal_sol) = nothing
############################################################################################
# Master IP incumbent.
############################################################################################
"""
Updates the current master IP primal solution.
"""
@mustimplement "ColGenMasterUpdateIncumbent" update_inc_primal_sol!(ctx::AbstractColGenContext, ip_primal_sol, new_ip_primal_sol) = nothing
############################################################################################
# Reduced costs calculation.
############################################################################################
"""
Updates dual value of the master constraints.
Dual values of the constraints can be used when the pricing solver supports non-robust cuts.
"""
@mustimplement "ColGenReducedCosts" update_master_constrs_dual_vals!(ctx, mast_lp_dual_sol) = nothing
"""
Method that you can implement if you want to store the reduced cost of subproblem variables
in the context.
"""
@mustimplement "ColGenReducedCosts" update_reduced_costs!(context, phase, red_costs) = nothing
"""
Returns the original cost `c` of subproblems variables.
to compute reduced cost `̄c = c - transpose(A) * π`.
"""
@mustimplement "ColGenReducedCosts" get_subprob_var_orig_costs(ctx::AbstractColGenContext) = nothing
"""
Returns the coefficient matrix `A` of subproblem variables in the master
to compute reduced cost `̄c = c - transpose(A) * π`.
"""
@mustimplement "ColGenReducedCosts" get_subprob_var_coef_matrix(ctx::AbstractColGenContext) = nothing
"Updates reduced costs of variables of a given subproblem."
@mustimplement "ColGenReducedCosts" update_sp_vars_red_costs!(ctx::AbstractColGenContext, sp, red_costs) = nothing
############################################################################################
# Dual bound calculation.
############################################################################################
"""
Returns an initial dual bound for a pricing subproblem.
Default value should be +/- infinite depending on the optimization sense.
"""
@mustimplement "ColGenDualBound" compute_sp_init_db(ctx, sp) = nothing
"""
Returns an initial primal bound for a pricing subproblem.
Default value should be +/- infinite depending on the optimization sense.
"""
@mustimplement "ColGenDualBound" compute_sp_init_pb(ctx, sp) = nothing
"""
compute_dual_bound(ctx, phase, master_lp_obj_val, master_dbs, generated_columns, mast_dual_sol) -> Float64
Caculates the dual bound at a given iteration of column generation.
The dual bound is composed of:
- `master_lp_obj_val`: objective value of the master LP problem
- `master_dbs`: dual values of the pricing subproblems
- the contribution of the master convexity constraints that you should compute from `mast_dual_sol`.
"""
@mustimplement "ColGenDualBound" compute_dual_bound(ctx, phase, master_dbs, generated_columns, mast_dual_sol) = nothing
############################################################################################
# Columns insertion.
############################################################################################
"""
Inserts columns into the master. Returns the number of columns inserted.
Implementation is responsible for checking if the column must be inserted and warn the user
if something unexpected happens.
"""
@mustimplement "ColGenColInsertion" insert_columns!(ctx, phase, columns) = nothing
############################################################################################
# Iteration Output
############################################################################################
"Supertype for the objects that contains the output of a column generation iteration."
abstract type AbstractColGenIterationOutput end
"""
colgen_iteration_output_type(ctx) -> Type{<:AbstractColGenIterationOutput}
Returns the type of the column generation iteration output associated to the context.
"""
@mustimplement "ColGenIterationOutput" colgen_iteration_output_type(::AbstractColGenContext) = nothing
"""
new_iteration_output(::Type{<:AbstractColGenIterationOutput}, args...) -> AbstractColGenIterationOutput
Arguments (i.e. `arg...`) of this function are the following:
- `min_sense`: `true` if the objective is a minimization function; `false` otherwise
- `mlp`: the optimal solution value of the master LP
- `db`: the Lagrangian dual bound
- `nb_new_cols`: the number of columns inserted into the master
- `new_cut_in_master`: `true` if valid inequalities or new constraints added into the master; `false` otherwise
- `infeasible_master`: `true` if the master is proven infeasible; `false` otherwise
- `unbounded_master`: `true` if the master is unbounded; `false` otherwise
- `infeasible_subproblem`: `true` if a pricing subproblem is proven infeasible; `false` otherwise
- `unbounded_subproblem`: `true` if a pricing subproblem is unbounded; `false` otherwise
- `time_limit_reached`: `true` if time limit is reached; `false` otherwise
- `master_primal_sol`: the primal master LP solution
- `ip_primal_sol`: the incumbent primal master solution
- `dual_sol`: the dual master LP solution
"""
@mustimplement "ColGenIterationOutput" new_iteration_output(
::Type{<:AbstractColGenIterationOutput},
min_sense,
mlp,
db,
nb_new_cols,
new_cut_in_master,
infeasible_master,
unbounded_master,
infeasible_subproblem,
unbounded_subproblem,
time_limit_reached,
master_primal_sol,
ip_primal_sol,
dual_sol
) = nothing
############################################################################################
# Phase Output
############################################################################################
"Supertype for the objects that contains the output of a column generation phase."
abstract type AbstractColGenPhaseOutput end
"""
colgen_phase_outputype(ctx) -> Type{<:AbstractColGenPhaseOutput}
Returns the type of the column generation phase output associated to the context.
"""
@mustimplement "ColGenPhaseOutput" colgen_phase_output_type(::AbstractColGenContext) = nothing
"""
new_phase_output(OutputType, min_sense, phase, stage, colgen_iter_output, iter, inc_dual_bound) -> OutputType
Returns the column generation phase output.
Arguments of this function are:
- `OutputType`: the type of the column generation phase output
- `min_sense`: `true` if it is a minimization problem; `false` otherwise
- `phase`: the current column generation phase
- `stage`: the current column generation stage
- `col_gen_iter_output`: the last column generation iteration output
- `iter`: the last iteration number
- `inc_dual_bound`: the current incumbent dual bound
"""
@mustimplement "ColGenPhaseOutput" new_phase_output(::Type{<:AbstractColGenPhaseOutput}, min_sense, phase, stage, ::AbstractColGenIterationOutput, iteration, incumbent_dual_bound) = nothing
"Returns `true` when the column generation algorithm must stop; `false` otherwise."
@mustimplement "ColGenPhaseOutput" stop_colgen(context, phase_output) = nothing
############################################################################################
# Colgen Output
############################################################################################
"Supertype for the objects that contains the output of the column generation algorithm."
abstract type AbstractColGenOutput end
"""
colgen_output_type(ctx) -> Type{<:AbstractColGenOutput}
Returns the type of the column generation output associated to the context.
"""
@mustimplement "ColGenOutput" colgen_output_type(::AbstractColGenContext) = nothing
"""
new_output(OutputType, colgen_phase_output) -> OutputType
Returns the column generation output where `colgen_phase_output` is the output of the last
column generation phase executed.
"""
@mustimplement "ColGenOutput" new_output(::Type{<:AbstractColGenOutput}, colgen_phase_output::AbstractColGenPhaseOutput) = nothing
############################################################################################
# Common to outputs
############################################################################################
"Returns the number of new columns inserted into the master at the end of an iteration."
@mustimplement "ColGenOutputs" get_nb_new_cols(output) = nothing
"Returns the incumbent primal master IP solution at the end of an iteration or a phase."
@mustimplement "ColGenOutputs" get_master_ip_primal_sol(output) = nothing
"Returns the primal master LP solution found at the last iteration of the column generation algorithm."
@mustimplement "ColGenOutputs" get_master_lp_primal_sol(output) = nothing
"Returns the dual master LP solution found at the last iteration of the column generation algorithm."
@mustimplement "ColGenOutputs" get_master_dual_sol(output) = nothing
"Returns the master LP solution value at the last iteration of the column generation algorithm."
@mustimplement "ColGenOutputs" get_master_lp_primal_bound(output) = nothing
############################################################################################
# ColGen Main Loop
############################################################################################
"""
Placeholder method called before the column generation iteration.
Does nothing by default but can be redefined to print some informations for instance.
We strongly advise users against the use of this method to modify the context or the reformulation.
"""
@mustimplement "ColGen" before_colgen_iteration(ctx::AbstractColGenContext, phase) = nothing
"""
Placeholder method called after the column generation iteration.
Does nothing by default but can be redefined to print some informations for instance.
We strongly advise users against the use of this method to modify the context or the reformulation.
"""
@mustimplement "ColGen" after_colgen_iteration(::AbstractColGenContext, phase, stage, env, colgen_iteration, stab, ip_primal_sol, colgen_iter_output) = nothing
"Returns `true` if `new_dual_bound` is better than `dual_bound`; `false` otherwise."
@mustimplement "ColGen" is_better_dual_bound(context, new_dual_bound, dual_bound) = nothing
###
_inf(is_min_sense) = is_min_sense ? Inf : -Inf
| Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 1239 | """
A phase of the column generation.
Each phase is associated with a specific set up of the reformulation.
"""
abstract type AbstractColGenPhase end
"""
An iterator that indicates how phases follow each other.
"""
abstract type AbstractColGenPhaseIterator end
"Returns a new phase iterator."
@mustimplement "ColGenPhase" new_phase_iterator(::AbstractColGenContext) = nothing
"Returns the phase with which the column generation algorithm must start."
@mustimplement "ColGenPhase" initial_phase(::AbstractColGenPhaseIterator) = nothing
"""
Returns the next phase of the column generation algorithm.
Returns `nothing` if the algorithm must stop.
"""
@mustimplement "ColGenPhase" next_phase(::AbstractColGenPhaseIterator, ::AbstractColGenPhase, output) = nothing
"Setup the reformulation for the given phase."
@mustimplement "ColGenPhase" setup_reformulation!(reform, ::AbstractColGenPhase) = nothing
"Setup the context for the given phase."
@mustimplement "ColGenPhase" setup_context!(context, ::AbstractColGenPhase) = nothing
"Returns `true` if the column generation phase must stop."
@mustimplement "ColGenPhase" stop_colgen_phase(context, phase, env, colgen_iter_output, inc_dual_bound, ip_primal_sol, colgen_iteration) = nothing
| Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 3235 | #############################################################################
# Pricing strategy
#############################################################################
"""
A pricing strategy defines how we iterate on pricing subproblems.
A default pricing strategy consists in iterating on all pricing subproblems.
Basically, this object is used like this:
```julia
pricing_strategy = ColGen.get_pricing_strategy(ctx, phase)
next = ColGen.pricing_strategy_iterate(pricing_strategy)
while !isnothing(next)
(sp_id, sp_to_solve), state = next
# Solve the subproblem `sp_to_solve`.
next = ColGen.pricing_strategy_iterate(pricing_strategy, state)
end
```
"""
abstract type AbstractPricingStrategy end
"""
get_pricing_strategy(ctx, phase) -> AbstractPricingStrategy
Returns the pricing strategy object.
"""
@mustimplement "ColGenPricing" get_pricing_strategy(ctx, phase) = nothing
"""
pricing_strategy_iterate(pricing_strategy) -> ((sp_id, sp_to_solve), state)
pricing_strategy_iterate(pricing_strategy, state) -> ((sp_id, sp_to_solve), state)
Returns an iterator with the first pricing subproblem that must be optimized.
The next subproblem is returned by a call to `Base.iterate` using the information
provided by this method.
"""
@mustimplement "ColGenPricing" pricing_strategy_iterate(::AbstractPricingStrategy) = nothing
@mustimplement "ColGenPricing" pricing_strategy_iterate(::AbstractPricingStrategy, state) = nothing
#############################################################################
# Pricing subproblem optimization
#############################################################################
"""
optimize_pricing_problem!(ctx, sp, env, optimizer, mast_dual_sol) -> PricingResult
Returns a custom object `PricingResult` that must implement the following functions:
- `get_primal_sols`: array of primal solution to the pricing subproblem
- `get_primal_bound`: best reduced cost (optional ?)
- `get_dual_bound`: dual bound of the pricing subproblem (used to compute the master dual bound)
- `master_dual_sol`: dual solution ``\\pi^{\\text{out}}`` to the master problem used to compute the real reduced cost of the column when stabilization is active
"""
@mustimplement "ColGenPricing" optimize_pricing_problem!(ctx, sp, env, optimizer, mast_dual_sol, stab_changes_mast_dual_sol) = nothing
#############################################################################
# Set of Generated Columns.
#############################################################################
"""
Returns an empty container that will store all the columns generated by the pricing problems
during an iteration of the column generation algorithm.
One must be able to iterate on this container to insert the columns in the master problem.
"""
@mustimplement "ColGenColumnsSet" set_of_columns(ctx) = nothing
"""
Pushes the column in the set of columns generated at a given iteration of the column
generation algorithm.
Columns stored in the set will then be considered for insertion in the master problem.
Returns `true` if column was inserted in the set, `false` otherwise.
"""
@mustimplement "ColGenColumnsSet" push_in_set!(context, pool, column) = nothing
| Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 2255 | """
Returns an instance of a data structure that contain information about the stabilization
used in the column generation algorithm.
"""
@mustimplement "ColGenStab" setup_stabilization!(ctx, master) = nothing
"""
update_stabilization_after_master_optim!(stab, phase, mast_dual_sol) -> Bool
Update stabilization after master optimization where `mast_dual_sol` is the dual solution
to the master problem.
Returns `true` if the stabilization will change the dual solution used for the pricing in the current
column generation iteration, `false` otherwise.
"""
@mustimplement "ColGenStab" update_stabilization_after_master_optim!(stab, phase, mast_dual_sol) = nothing
"""
Returns the dual solution used for the pricing in the current column generation iteration
(stabilized dual solution).
"""
@mustimplement "ColGenStab" get_stab_dual_sol(stab, phase, mast_dual_sol) = nothing
"Returns `true` if the stabilized dual solution leads to a misprice, `false` otherwise."
@mustimplement "ColGenStab" check_misprice(stab, generated_cols, mast_dual_sol) = nothing
"""
Updates stabilization after pricing optimization where:
- `mast_dual_sol` is the dual solution to the master problem
- `pseudo_db` is the pseudo dual bound of the problem after optimization of the pricing problems
- `smooth_dual_sol` is the current smoothed dual solution
"""
@mustimplement "ColGenStab" update_stabilization_after_pricing_optim!(stab, ctx, generated_columns, master, pseudo_db, smooth_dual_sol) = nothing
"""
Updates stabilization after a misprice.
Argument `mast_dual_sol` is the dual solution to the master problem.
"""
@mustimplement "ColGenStab" update_stabilization_after_misprice!(stab, mast_dual_sol) = nothing
"""
Updates stabilization after an iteration of the column generation algorithm. Arguments:
- `stab` is the stabilization data structure
- `ctx` is the column generation context
- `master` is the master problem
- `generated_columns` is the set of generated columns
- `mast_dual_sol` is the dual solution to the master problem
"""
@mustimplement "ColGenStab" update_stabilization_after_iter!(stab, mast_dual_sol) = nothing
"Returns a string with a short information about the stabilization."
@mustimplement "ColGenStab" get_output_str(stab) = nothing | Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 1448 | """
A stage of the column generation algorithm.
Each stage is associated to a specific solver for each pricing subproblem.
"""
abstract type AbstractColGenStage end
"An iterator that indicates how stages follow each other."
abstract type AbstractColGenStageIterator end
"Returns a new stage iterator."
@mustimplement "ColGenStage" new_stage_iterator(::AbstractColGenContext) = nothing
"Returns the stage at which the column generation algorithm must start."
@mustimplement "ColGenStage" initial_stage(::AbstractColGenStageIterator) = nothing
"""
Returns the next stage involving a "more exact solver" than the current one.
Returns `nothing` if the algorithm has already reached the exact phase (last phase).
"""
@mustimplement "ColGenStage" decrease_stage(::AbstractColGenStageIterator, stage, phase_output) = nothing
"""
Returns the next stage that column generation must use.
"""
@mustimplement "ColGenStage" next_stage(::AbstractColGenStageIterator, stage, phase_output) = nothing
"Returns the optimizer for the pricing subproblem associated to the given stage."
@mustimplement "ColGenStage" get_pricing_subprob_optimizer(::AbstractColGenStage, form) = nothing
"Returns the id of the stage."
@mustimplement "ColGenStage" stage_id(::AbstractColGenStage) = nothing
"Returns `true` if the stage uses an exact solver for the pricing subproblem; `false` otherwise."
@mustimplement "ColGenStage" is_exact_stage(::AbstractColGenStage) = nothing | Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 1523 | module ColunaBase
include("../MustImplement/MustImplement.jl")
using .MustImplement
using DynamicSparseArrays, MathOptInterface, TimerOutputs, RandomNumbers, Random, SparseArrays
const MOI = MathOptInterface
const TO = TimerOutputs
import BlockDecomposition
import Base
import Printf
# interface.jl
export AbstractModel, AbstractProblem, AbstractSense, AbstractMinSense, AbstractMaxSense,
getuid, getstorage
# nestedenum.jl
export NestedEnum, @nestedenum, @exported_nestedenum
# solsandbounds.jl
export Bound, Solution, getvalue, getbound, isbetter, best, worst, gap, printbounds,
getstatus, remove_until_last_point, getmodel, isunbounded, isinfeasible
# Statuses
export TerminationStatus, SolutionStatus, OPTIMIZE_NOT_CALLED, OPTIMAL,
INFEASIBLE, UNBOUNDED, TIME_LIMIT, NODE_LIMIT, OTHER_LIMIT, UNCOVERED_TERMINATION_STATUS,
FEASIBLE_SOL, INFEASIBLE_SOL, UNKNOWN_FEASIBILITY, UNKNOWN_SOLUTION_STATUS,
UNCOVERED_SOLUTION_STATUS, convert_status
# hashtable
export HashTable, gethash, savesolid!, getsolids
# Storages (TODO : clean)
export UnitType,
UnitPermission, READ_AND_WRITE, READ_ONLY, NOT_USED,
getstorageunit, getstoragewrapper
export Storage, RecordUnitManager, AbstractRecordUnit, AbstractRecord, storage_unit,
record, record_type, storage_unit_type, restore_from_record!, create_record
include("interface.jl")
include("nestedenum.jl")
include("solsandbounds.jl")
include("hashtable.jl")
# TODO: extract storage
include("recordmanager.jl")
include("storage.jl")
end
| Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 2295 | const MT_SEED = 1234567
const MT_MASK = 0x0ffff # hash keys from 1 to 65536
"""
This datastructure allows us to quickly find solution that shares the same members:
variables for primal solutions and constraints for dual solutions.
"""
struct HashTable{MemberId,SolId}
rng::MersenneTwisters.MT19937
memberid_to_hash::Dict{MemberId, UInt32} # members of the primal/dual solution -> hash
hash_to_solids::Vector{Vector{SolId}} # hash of the primal/dual solution -> solution id
HashTable{MemberId,SolId}() where {MemberId,SolId} = new(
MersenneTwisters.MT19937(MT_SEED),
Dict{MemberId, UInt32}(),
[SolId[] for _ in 0:MT_MASK]
)
end
function _gethash!(
hashtable::HashTable{MemberId,SolId}, id::MemberId, bad_hash = Int(MT_MASK) + 2
) where {MemberId,SolId}
hash = UInt32(get(hashtable.memberid_to_hash, id, bad_hash) - 1)
if hash > MT_MASK
hash = MersenneTwisters.mt_get(hashtable.rng) & MT_MASK
hashtable.memberid_to_hash[id] = Int(hash) + 1
end
return hash
end
_gethash!(hashtable, entry::Tuple, bad_hash = Int(MT_MASK) + 2) =
_gethash!(hashtable, first(entry), bad_hash)
# By default, we consider that the iterator of the `sol` argument returns a tuple that
# contains the id as first element.
function gethash(hashtable::HashTable, sol)
acum_hash = UInt32(0)
for entry in sol
acum_hash ⊻= _gethash!(hashtable, entry)
end
return Int(acum_hash) + 1
end
# If the solution is in a sparse vector, we just want to check indices associated to non-zero
# values.
function gethash(hashtable::HashTable, sol::SparseVector)
acum_hash = UInt32(0)
for nzid in SparseArrays.nonzeroinds(sol)
acum_hash ⊻= _gethash!(hashtable, nzid)
end
return Int(acum_hash) + 1
end
savesolid!(hashtable::HashTable, solid, sol) =
push!(getsolids(hashtable, sol), solid)
getsolids(hashtable::HashTable, sol) =
hashtable.hash_to_solids[gethash(hashtable, sol)]
function Base.show(io::IO, ht::HashTable)
println(io, typeof(ht), ":")
println(io, " memberid_to_hash : ", ht.memberid_to_hash)
println(io, " hash_to_solids :")
for (a,b) in Iterators.filter(a -> !isempty(a[2]), enumerate(ht.hash_to_solids))
println(io, "\t", a, "=>", b)
end
return
end | Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 753 | abstract type AbstractModel end
@mustimplement "Model" getuid(m::AbstractModel) = nothing
"Return the storage of a model."
@mustimplement "Model" getstorage(m::AbstractModel) = nothing
abstract type AbstractProblem end
abstract type AbstractSense end
abstract type AbstractMinSense <: AbstractSense end
abstract type AbstractMaxSense <: AbstractSense end
function remove_until_last_point(str::String)
lastpointindex = findlast(isequal('.'), str)
shortstr = SubString(
str, lastpointindex === nothing ? 1 : lastpointindex + 1, length(str)
)
return shortstr
end
function Base.show(io::IO, model::AbstractModel)
shorttypestring = remove_until_last_point(string(typeof(model)))
print(io, "model ", shorttypestring)
end | Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 5953 | abstract type NestedEnum end
function Base.:(<=)(a::T, b::T) where {T<:NestedEnum}
return a.value % b.value == 0
end
function Base.:(<=)(a::T, b::U) where {T<:NestedEnum,U<:NestedEnum}
return false
end
const PRIMES = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101,
103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227,
229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359,
367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499,
503, 509, 521, 523, 541]
# Store the item defined in expr at position i
function _store!(expr::Symbol, i, names, parent_pos, depths)
names[i] = expr
parent_pos[i] = 0 # No parent
depths[i] = 0 # No parent
return
end
# Store the item defined in expr at position i
function _store!(expr::Expr, i, names, parent_pos, depths)
if i == 1 # parent can be a curly expression e.g. Duty{Variable}
expr.head == :curly || error("Syntax error : parent can be a Symbol or a curly expression.")
names[i] = expr
parent_pos[i] = 0
depths[i] = 0
return
end
expr.head == :call || error("Syntax error : Child <= Parent ")
expr.args[1] == :(<=) || error("Syntax error : Child <= Parent ")
i > 1 || error("First element cannot have a parent.")
name = expr.args[2]
parent_name = expr.args[3]
r = findall(n -> n == parent_name, names[1:i-1])
length(r) == 0 && error("Unknow parent $(parent_name).")
length(r) > 1 && error("$(parent_name) registered more than once.")
pos = r[1]
parent_pos[i] = pos
names[i] = name
depths[i] = depths[pos] + 1
return
end
# Compute the value of each item. The value is equal to the multiplication of
# the prime numbers assigned to the item and its ancestors.
function _compute_values!(values, parent_pos, primes)
for i in 1:length(parent_pos)
factor = 1
j = parent_pos[i]
if j != 0
factor = values[j]
end
values[i] = primes[i] * factor
end
return
end
# Update parent_pos array in function of permutation p
function _update_parent_pos!(parent_pos, p)
permute!(parent_pos, p) # We still use positions of the old order.
inv_p = invperm(p)
for (i, pos) in enumerate(parent_pos)
if pos != 0
parent_pos[i] = inv_p[pos]
end
end
return
end
function _build_expression(names, values, export_symb::Bool = false)
len = length(names)
root_name = names[1]
enum_expr = Expr(:block, :())
# We define a new type iif the root name is a Symbol
# If the root name is a curly expression, the user must have defined the
# template type inheriting from NestedEnum in its code.
if root_name isa Symbol
push!(enum_expr.args, :(struct $root_name <: Coluna.ColunaBase.NestedEnum value::UInt end))
end
for i in 2:len
push!(enum_expr.args, :(const $(names[i]) = $(root_name)(UInt($(values[i])))))
if export_symb
push!(enum_expr.args, :(export $(names[i])))
end
end
return enum_expr
end
function _build_print_expression(names, values)
root_name = names[1]
print_expr = Expr(:function)
push!(print_expr.args, :(Base.print(io::IO, obj::$(root_name)))) #signature
# build the if list in reverse order
prev_cond = :(print(io, "UNKNOWN_DUTY"))
for i in length(names):-1:2
head = (i == 2) ? :if : :elseif
msg = string(names[i])
cond = Expr(head, :(obj == $(names[i])), :(print(io, $msg)), prev_cond)
prev_cond = cond
end
push!(print_expr.args, Expr(:block, prev_cond))
return print_expr
end
function _assign_values_to_items(expr)
Base.remove_linenums!(expr)
expr.head == :block || error("Block expression expected.")
len = length(expr.args)
names = Array{Union{Symbol, Expr}}(undef, len)
parent_pos = zeros(Int, len) # Position of the parent.
depths = zeros(Int, len) # Depth of each item
values = zeros(UInt32, len) # The value is the multiplication of primes of the item and its ancestors.
primes = PRIMES[1:len]
name_values = Dict{Union{Symbol, Expr}, Int}()
for (i, arg) in enumerate(expr.args)
_store!(arg, i, names, parent_pos, depths)
end
p = sortperm(depths)
permute!(names, p)
_update_parent_pos!(parent_pos, p)
_compute_values!(values, parent_pos, primes)
return names, values
end
"""
@nestedenum block_expression
Create a `NestedEnum` subtype such as :
# Example
```@meta
DocTestSetup = quote
using Coluna
end
```
```jldoctest nestedexample
Coluna.ColunaBase.@nestedenum begin
TypeOfItem
ItemA <= TypeOfItem
ChildA1 <= ItemA
GrandChildA11 <= ChildA1
GrandChildA12 <= ChildA1
ChildA2 <= ItemA
ItemB <= TypeOfItem
ItemC <= TypeOfItem
end
# output
```
Create a nested enumeration with items `ItemA`, `ChildA1`, `ChildA2`, `GrandChildA11`,
`GrandChildA12`, `ItemB`, and `ItemC` of type `TypeOfItem`.
The operator `<=` indicates the parent of the item.
```jldoctest nestedexample
julia> GrandChildA11 <= ItemA
true
```
```jldoctest nestedexample
julia> GrandChildA11 <= ItemC
false
```
```@meta
DocTestSetup = nothing
```
"""
macro nestedenum(expr)
return _nestedenum(expr, false)
end
"Create a nested enumeration and export all the items."
macro exported_nestedenum(expr)
return _nestedenum(expr, true)
end
function _nestedenum(expr, export_names)
names, values = _assign_values_to_items(expr)
enum_expr = _build_expression(names, values, export_names)
print_expr = _build_print_expression(names, values)
final_expr = quote
$enum_expr
$print_expr
end
return esc(final_expr)
end
| Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 3121 |
abstract type AbstractRecordUnit end
abstract type AbstractRecord end
# Interface to implement
@mustimplement "Storage" get_id(r::AbstractRecord) = nothing
"Creates a record of information from the model or a storage unit."
@mustimplement "Storage" record(::Type{<:AbstractRecord}, id::Int, model, su::AbstractRecordUnit) = nothing
"Restore information from the model or the storage unit that is recorded in a record."
@mustimplement "Storage" restore_from_record!(model, su::AbstractRecordUnit, r::AbstractRecord) = nothing
"Returns a storage unit from a given type."
@mustimplement "Storage" storage_unit(::Type{<:AbstractRecordUnit}, model) = nothing
mutable struct RecordUnitManager{Model,RecordType<:AbstractRecord,StorageUnitType<:AbstractRecordUnit}
model::Model
storage_unit::StorageUnitType
active_record_id::Int
function RecordUnitManager(::Type{StorageUnitType}, model::M) where {M,StorageUnitType<:AbstractRecordUnit}
return new{M,record_type(StorageUnitType),StorageUnitType}(
model, storage_unit(StorageUnitType, model), 0
)
end
end
# Interface
"Returns the type of record stored in a type of storage unit."
@mustimplement "Storage" record_type(::Type{<:AbstractRecordUnit}) = nothing
"Returns the type of storage unit that stores a type of record."
@mustimplement "Storage" storage_unit_type(::Type{<:AbstractRecord}) = nothing
struct Storage{ModelType}
model::ModelType
units::Dict{DataType,RecordUnitManager}
Storage(model::M) where {M} = new{M}(model, Dict{DataType,RecordUnitManager}())
end
function _get_storage_unit_manager!(storage, ::Type{StorageUnitType}) where {StorageUnitType<:AbstractRecordUnit}
storage_unit_manager = get(storage.units, StorageUnitType, nothing)
if isnothing(storage_unit_manager)
storage_unit_manager = RecordUnitManager(StorageUnitType, storage.model)
storage.units[StorageUnitType] = storage_unit_manager
end
return storage_unit_manager
end
# Creates a new record from the current state of the model and the storage unit.
"""
create_record(storage, storage_unit_type)
Returns a Record that contains a description of the state of the storage unit at the time
when the method is called.
"""
function create_record(storage, ::Type{StorageUnitType}) where {StorageUnitType<:AbstractRecordUnit}
storage_unit_manager = _get_storage_unit_manager!(storage, StorageUnitType)
id = storage_unit_manager.active_record_id += 1
return record(
record_type(StorageUnitType),
id,
storage.model,
storage_unit_manager.storage_unit
)
end
function restore_from_record!(storage::Storage, record::RecordType) where {RecordType}
storage_unit_manager = _get_storage_unit_manager!(storage, storage_unit_type(RecordType))
restore_from_record!(storage.model, storage_unit_manager.storage_unit, record)
return true
end
# TODO: remove
function restore_from_record!(storage_manager, record::RecordType) where {RecordType}
restore_from_record!(storage_manager.model, storage_manager.storage_unit, record)
return true
end
| Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 12694 | # Bounds
struct Bound <: Real
min::Bool # max if false.
primal::Bool # dual if false.
value::Float64
Bound(min::Bool, primal::Bool, x::Number) = new(min, primal, x === NaN ? _defaultboundvalue(primal, min) : x)
end
function _defaultboundvalue(primal::Bool, min::Bool)
sc1 = min ? 1 : -1
sc2 = primal ? 1 : -1
return sc1 * sc2 * Inf
end
"""
Bound(min, primal)
Create a default primal bound for a problem with objective sense (min or max) in the space (primal or dual).
"""
function Bound(min, primal)
val = _defaultboundvalue(primal, min)
return Bound(min, primal, val)
end
getvalue(b::Bound) = b.value
"""
isbetter(b1, b2)
Returns true if bound b1 is better than bound b2.
The function take into account the space (primal or dual) and the objective sense (min, max) of the bounds.
"""
function isbetter(b1::Bound, b2::Bound)
@assert b1.min == b2.min && b1.primal == b2.primal
sc1 = b1.min ? 1 : -1
sc2 = b1.primal ? 1 : -1
return sc1 * sc2 * b1.value < sc1 * sc2 * b2.value
end
# We use nothing when there is no bound. So we can consider that a new bound is better than
# nothing.
isbetter(::Bound, ::Nothing) = true
"""
best(b1, b2)
Returns the best bound between b1 and b2.
"""
best(b1::Bound, b2::Bound) = isbetter(b1, b2) ? b1 : b2
"""
worst(b1, b2)
Returns the worst bound between b1 and b2.
"""
worst(b1::Bound, b2::Bound) = isbetter(b1, b2) ? b2 : b1
"""
diff(pb, db)
diff(db, pb)
Distance between a primal bound and a dual bound that have the same objective sense.
Distance is non-positive if dual bound reached primal bound.
"""
function diff(b1::Bound, b2::Bound)
@assert b1.min == b2.min && b1.primal != b2.primal
pb = b1.primal ? b1 : b2
db = b1.primal ? b2 : b1
sc = b1.min ? 1 : -1
return sc * (pb.value - db.value)
end
"""
gap(pb, db)
gap(db, pb)
Return relative gap. Gap is non-positive if pb reached db.
"""
function gap(b1::Bound, b2::Bound)
@assert b1.primal != b2.primal && b1.min == b2.min
db = b1.primal ? b2 : b1
pb = b1.primal ? b1 : b2
den = b1.min ? db : pb
return diff(b1, b2) / abs(den.value)
end
"""
isunbounded(bound)
Return true is the primal bound or the dual bound is unbounded.
"""
function isunbounded(bound::Bound)
inf = - _defaultboundvalue(bound.primal, bound.min)
return getvalue(bound) == inf
end
"""
isinfeasible(bound)
Return true is the primal bound or the dual bound is infeasible.
"""
isinfeasible(b::Bound) = isnothing(getvalue(b))
"""
printbounds(db, pb [, io])
Prints the lower and upper bound according to the objective sense.
Can receive io::IO as an input, to eventually output the print to a file or buffer.
"""
function printbounds(db::Bound, pb::Bound, io::IO=Base.stdout)
@assert !db.primal && pb.primal && db.min == pb.min
if db.min
Printf.@printf io "[ %.4f , %.4f ]" getvalue(db) getvalue(pb)
else
Printf.@printf io "[ %.4f , %.4f ]" getvalue(pb) getvalue(db)
end
end
function Base.show(io::IO, b::Bound)
print(io, getvalue(b))
end
# If you work with a Bound and another type, the Bound is promoted to the other type.
Base.promote_rule(::Type{Bound}, F::Type{<:AbstractFloat}) = F
Base.promote_rule(::Type{Bound}, I::Type{<:Integer}) = I
Base.promote_rule(::Type{Bound}, I::Type{<:AbstractIrrational}) = I
Base.convert(::Type{<:AbstractFloat}, b::Bound) = b.value
Base.convert(::Type{<:Integer}, b::Bound) = b.value
Base.convert(::Type{<:AbstractIrrational}, b::Bound) = b.value
"""
TerminationStatus
Theses statuses are the possible reasons why an algorithm stopped the optimization.
When a subsolver is called through MOI, the
MOI [`TerminationStatusCode`](https://jump.dev/MathOptInterface.jl/stable/apireference/#MathOptInterface.TerminationStatusCode)
is translated into a Coluna `TerminationStatus`.
Description of the termination statuses:
- `OPTIMAL` : the algorithm found a global optimal solution given the optimality tolerance
- `INFEASIBLE` : the algorithm proved infeasibility
- `UNBOUNDED` : the algorithm proved unboundedness
- `TIME_LIMIT` : the algorithm stopped because of the time limit
- `NODE_LIMIT` : the branch-and-bound based algorithm stopped due to the node limit
- `OTHER_LIMIT` : the algorithm stopped because of a limit that is neither the time limit
nor the node limit
If the algorithm has not been called, the default value of the termination status should be:
- `OPTIMIZE_NOT_CALLED`
If the conversion of a `MOI.TerminationStatusCode` returns `UNCOVERED_TERMINATION_STATUS`,
Coluna should stop because it enters in an undefined behavior.
"""
@enum(
TerminationStatus, OPTIMIZE_NOT_CALLED, OPTIMAL, INFEASIBLE, UNBOUNDED,
TIME_LIMIT, NODE_LIMIT, OTHER_LIMIT, UNCOVERED_TERMINATION_STATUS
)
"""
SolutionStatus
Description of the solution statuses:
- `FEASIBLE_SOL` : the solution is feasible
- `INFEASIBLE_SOL` : the solution is not feasible
If there is no solution or if we don't have information about the solution, the
solution status should be :
- `UNKNOWN_SOLUTION_STATUS`
"""
@enum(
SolutionStatus, FEASIBLE_SOL, INFEASIBLE_SOL, UNKNOWN_FEASIBILITY,
UNKNOWN_SOLUTION_STATUS, UNCOVERED_SOLUTION_STATUS
)
"""
convert_status(status::MOI.TerminationStatusCode) -> Coluna.TerminationStatus
convert_status(status::Coluna.TerminationStatus) -> MOI.TerminationStatusCode
convert_status(status::MOI.ResultStatusCode) -> Coluna.SolutionStatus
convert_status(status::Coluna.SolutionStatus) -> MOI.ResultStatusCode
Convert a termination or solution `status` of a given type to the corresponding status in another type.
This method is used to communicate between Coluna and MathOptInterface.
"""
function convert_status(moi_status::MOI.TerminationStatusCode)
moi_status == MOI.OPTIMIZE_NOT_CALLED && return OPTIMIZE_NOT_CALLED
moi_status == MOI.OPTIMAL && return OPTIMAL
moi_status == MOI.INFEASIBLE && return INFEASIBLE
moi_status == MOI.LOCALLY_INFEASIBLE && return INFEASIBLE
moi_status == MOI.DUAL_INFEASIBLE && return UNBOUNDED
# TODO: Happens in MIP presolve (cf JuMP doc), we treat this case as unbounded.
moi_status == MOI.INFEASIBLE_OR_UNBOUNDED && return UNBOUNDED
moi_status == MOI.TIME_LIMIT && return TIME_LIMIT
moi_status == MOI.NODE_LIMIT && return NODE_LIMIT
moi_status == MOI.OTHER_LIMIT && return OTHER_LIMIT
return UNCOVERED_TERMINATION_STATUS
end
function convert_status(coluna_status::TerminationStatus)
coluna_status == OPTIMIZE_NOT_CALLED && return MOI.OPTIMIZE_NOT_CALLED
coluna_status == OPTIMAL && return MOI.OPTIMAL
coluna_status == UNBOUNDED && return MOI.DUAL_INFEASIBLE
coluna_status == INFEASIBLE && return MOI.INFEASIBLE
coluna_status == TIME_LIMIT && return MOI.TIME_LIMIT
coluna_status == NODE_LIMIT && return MOI.NODE_LIMIT
coluna_status == OTHER_LIMIT && return MOI.OTHER_LIMIT
return MOI.OTHER_LIMIT
end
function convert_status(moi_status::MOI.ResultStatusCode)
moi_status == MOI.NO_SOLUTION && return UNKNOWN_SOLUTION_STATUS
moi_status == MOI.FEASIBLE_POINT && return FEASIBLE_SOL
moi_status == MOI.INFEASIBLE_POINT && return INFEASIBLE_SOL
return UNCOVERED_SOLUTION_STATUS
end
function convert_status(coluna_status::SolutionStatus)
coluna_status == FEASIBLE_SOL && return MOI.FEASIBLE_POINT
coluna_status == INFEASIBLE_SOL && return MOI.INFEASIBLE_POINT
return MOI.OTHER_RESULT_STATUS
end
# Basic structure of a solution
struct Solution{Model<:AbstractModel,Decision<:Integer,Value} <: AbstractSparseVector{Decision,Value}
model::Model
bound::Float64
status::SolutionStatus
sol::SparseVector{Value,Decision}
end
"""
Solution is an internal data structure of Coluna and should not be used in
algorithms. See `MathProg.PrimalSolution` & `MathProg.DualSolution` instead.
Solution(
model::AbstractModel,
decisions::Vector,
values::Vector,
solution_value::Float64,
status::SolutionStatus
)
Create a solution to the `model`. Other arguments are:
- `decisions` is a vector with the index of each decision.
- `values` is a vector with the values for each decision.
- `solution_value` is the value of the solution.
- `status` is the solution status.
"""
function Solution{Mo,De,Va}(
model::Mo, decisions::Vector{De}, values::Vector{Va}, solution_value::Float64, status::SolutionStatus
) where {Mo<:AbstractModel,De,Va}
sol = sparsevec(decisions, values, typemax(Int32)) #Coluna.MAX_NB_ELEMS)
return Solution(model, solution_value, status, sol)
end
"Return the model of a solution."
getmodel(s::Solution) = s.model
"Return the value (as a Bound) of `solution`"
getbound(s::Solution) = s.bound
"Return the value of `solution`."
getvalue(s::Solution) = float(s.bound)
"Return the solution status of `solution`."
getstatus(s::Solution) = s.status
# implementing indexing interface
Base.getindex(s::Solution, i::Integer) = getindex(s.sol, i)
Base.setindex!(s::Solution, v, i::Integer) = setindex!(s.sol, v, i)
Base.firstindex(s::Solution) = firstindex(s.sol)
Base.lastindex(s::Solution) = lastindex(s.sol)
# implementing abstract array interface
Base.size(s::Solution) = size(s.sol)
Base.length(s::Solution) = length(s.sol)
Base.IndexStyle(::Type{<:Solution{Mo,De,Va}}) where {Mo,De,Va} =
IndexStyle(SparseVector{Va,De})
SparseArrays.nnz(s::Solution) = nnz(s.sol)
# It iterates only on non-zero values because:
# - we use indices (`Id`) that behaves like an Int with additional information and given a
# indice, we cannot deduce the additional information for the next one (i.e. impossible to
# create an Id for next integer);
# - we don't know the length of the vector (it depends on the number of variables &
# constraints that varies over time).
function Base.iterate(s::Solution)
iterator = Iterators.zip(findnz(s.sol)...)
next = iterate(iterator)
isnothing(next) && return nothing
(item, zip_state) = next
return (item, (zip_state, iterator))
end
function Base.iterate(::Solution, state)
(zip_state, iterator) = state
next = iterate(iterator, zip_state)
isnothing(next) && return nothing
(next_item, next_zip_state) = next
return (next_item, (next_zip_state, iterator))
end
# # implementing sparse array interface
# SparseArrays.nnz(s::Solution) = nnz(s.sol)
# SparseArrays.nonzeroinds(s::Solution) = SparseArrays.nonzeroinds(s.sol)
# SparseArrays.nonzeros(s::Solution) = nonzeros(s.sol)
function _eq_sparse_vec(a::SparseVector, b::SparseVector)
a_ids, a_vals = findnz(a)
b_ids, b_vals = findnz(b)
return a_ids == b_ids && a_vals == b_vals
end
Base.:(==)(::Solution, ::Solution) = false
function Base.:(==)(a::S, b::S) where {S<:Solution}
return a.model == b.model && a.bound == b.bound && a.status == b.status &&
_eq_sparse_vec(a.sol, b.sol)
end
function Base.in(p::Tuple{De,Va}, a::Solution{Mo,De,Va}, valcmp=(==)) where {Mo,De,Va}
v = get(a, p[1], Base.secret_table_token)
if v !== Base.secret_table_token
return valcmp(v, p[2])
end
return false
end
function Base.show(io::IOContext, solution::Solution{Mo,De,Va}) where {Mo,De,Va}
println(io, "Solution")
for (decision, value) in solution
println(io, "| ", decision, " = ", value)
end
Printf.@printf(io, "└ value = %.2f \n", getvalue(solution))
end
# Todo : revise method
Base.copy(s::S) where {S<:Solution} = S(s.model, s.bound, s.status, copy(s.sol))
# Implementing comparison between solution & dynamic matrix col view for solution comparison
function Base.:(==)(v1::DynamicMatrixColView, v2::Solution)
for ((i1,j1), (i2,j2)) in Iterators.zip(v1,v2)
if !(i1 == i2 && j1 == j2)
return false
end
end
return true
end
# Implementation of the addition & subtraction in SparseArrays always converts indices into
# `Int`. We need a custom implementation to presever the index type.
function _sol_custom_binarymap(
f::Function, s1::Solution{Mo,De,Va1}, s2::Solution{Mo,De,Va2}
) where {Mo,De,Va1,Va2}
x = s1.sol
y = s2.sol
R = Base.Broadcast.combine_eltypes(f, (x, y))
n = length(x)
length(y) == n || throw(DimensionMismatch())
xnzind = SparseArrays.nonzeroinds(x)
xnzval = nonzeros(x)
ynzind = SparseArrays.nonzeroinds(y)
ynzval = nonzeros(y)
mx = length(xnzind)
my = length(ynzind)
cap = mx + my
rind = Vector{De}(undef,cap)
rval = Vector{R}(undef,cap)
ir = SparseArrays._binarymap_mode_1!(f, mx, my, xnzind, xnzval, ynzind, ynzval, rind, rval)
resize!(rind, ir)
resize!(rval, ir)
return SparseVector(n, rind, rval)
end | Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 888 | #######
# TODO: old code below
#######
@enum(UnitPermission, NOT_USED, READ_ONLY, READ_AND_WRITE)
# UnitType = Pair{Type{<:AbstractStorageUnit}, Type{<:AbstractRecord}}.
# see https://github.com/atoptima/Coluna.jl/pull/323#discussion_r418972805
const UnitType = DataType #Type{<:AbstractStorageUnit}
"""
IMPORTANT!
Every stored or copied record should be either restored or removed so that it's
participation is correctly computed and memory correctly controlled
"""
#####
function getstorageunit(m::AbstractModel, SU::Type{<:AbstractRecordUnit})
return getstoragewrapper(m, SU).storage_unit
end
function getstoragewrapper(m::AbstractModel, SU::Type{<:AbstractRecordUnit})
storagecont = get(getstorage(m).units, SU, nothing)
storagecont === nothing && error("No storage unit of type $SU in $(typeof(m)) with id $(getuid(m)).")
return storagecont
end | Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 16295 | ### Some notes:
#
# - Make use of : MOI.VariablePrimalStart(), MOI.ConstraintPrimalStart(),
# MOI.ConstraintDualStart(), MOI.ConstraintBasisStatus()
#
# - RawSolver() -> For directly interacting with solver
#
############################################################
function set_obj_sense!(optimizer::MoiOptimizer, ::Type{<:MaxSense})
MOI.set(getinner(optimizer), MOI.ObjectiveSense(), MOI.MAX_SENSE)
return
end
function set_obj_sense!(optimizer::MoiOptimizer, ::Type{<:MinSense})
MOI.set(getinner(optimizer), MOI.ObjectiveSense(), MOI.MIN_SENSE)
return
end
function update_bounds_in_optimizer!(form::Formulation, optimizer::MoiOptimizer, var::Variable)
inner = getinner(optimizer)
moi_record = getmoirecord(var)
moi_kind = getkind(moi_record)
moi_lower_bound = getlowerbound(moi_record)
moi_upper_bound = getupperbound(moi_record)
moi_index = getmoiindex(moi_record)
if getcurkind(form, var) == Binary && moi_index.value != -1
MOI.delete(inner, moi_kind)
setkind!(moi_record, MOI.add_constraint(
inner, MOI.VariableIndex(moi_index.value), MOI.Integer()
))
end
if !isnothing(moi_lower_bound) && moi_lower_bound.value != -1
MOI.set(inner, MOI.ConstraintSet(), moi_lower_bound,
MOI.GreaterThan(getcurlb(form, var))
)
else
setlowerbound!(moi_record, MOI.add_constraint(
inner, MOI.VariableIndex(moi_index.value), MOI.GreaterThan(getcurlb(form, var))
))
end
if !isnothing(moi_upper_bound) && moi_upper_bound.value != -1
MOI.set(inner, MOI.ConstraintSet(), moi_upper_bound,
MOI.LessThan(getcurub(form, var))
)
else
setupperbound!(moi_record, MOI.add_constraint(
inner, MOI.VariableIndex(moi_index.value), MOI.LessThan(getcurub(form, var))
))
end
return
end
function update_cost_in_optimizer!(form::Formulation, optimizer::MoiOptimizer, var::Variable)
cost = getcurcost(form, var)
moi_index = getmoiindex(getmoirecord(var))
MOI.modify(
getinner(optimizer), MoiObjective(),
MOI.ScalarCoefficientChange{Float64}(moi_index, cost)
)
return
end
function update_constr_member_in_optimizer!(
optimizer::MoiOptimizer, c::Constraint, v::Variable, coeff::Float64
)
moi_c_index = getmoiindex(getmoirecord(c))
moi_v_index = getmoiindex(getmoirecord(v))
MOI.modify(
getinner(optimizer), moi_c_index,
MOI.ScalarCoefficientChange{Float64}(moi_v_index, coeff)
)
return
end
function update_constr_rhs_in_optimizer!(
form::Formulation, optimizer::MoiOptimizer, constr::Constraint
)
moi_c_index = getmoiindex(getmoirecord(constr))
rhs = getcurrhs(form, constr)
sense = getcursense(form, constr)
MOI.set(getinner(optimizer), MOI.ConstraintSet(), moi_c_index, convert_coluna_sense_to_moi(sense)(rhs))
return
end
function enforce_bounds_in_optimizer!(
form::Formulation, optimizer::MoiOptimizer, var::Variable
)
moirecord = getmoirecord(var)
moi_lower_bound = MOI.add_constraint(
getinner(optimizer), getmoiindex(moirecord),
MOI.GreaterThan(getcurlb(form, var))
)
moi_upper_bound = MOI.add_constraint(
getinner(optimizer), getmoiindex(moirecord),
MOI.LessThan(getcurub(form, var))
)
setlowerbound!(moirecord, moi_lower_bound)
setupperbound!(moirecord, moi_upper_bound)
return
end
function enforce_kind_in_optimizer!(
form::Formulation, optimizer::MoiOptimizer, v::Variable
)
inner = getinner(optimizer)
kind = getcurkind(form, v)
moirecord = getmoirecord(v)
moi_kind = getkind(moirecord)
if moi_kind.value != -1
if MOI.is_valid(inner, moi_kind)
MOI.delete(inner, moi_kind)
end
setkind!(moirecord, MoiVarKind())
end
if kind != Continuous # Continuous is translated as no constraint in MOI
moi_set = (kind == Binary ? MOI.ZeroOne() : MOI.Integer())
setkind!(moirecord, MOI.add_constraint(
inner, getmoiindex(moirecord), moi_set
))
end
return
end
function add_to_optimizer!(form::Formulation, optimizer::MoiOptimizer, var::Variable)
inner = getinner(optimizer)
moirecord = getmoirecord(var)
moi_index = MOI.add_variable(inner)
setmoiindex!(moirecord, moi_index)
update_cost_in_optimizer!(form, optimizer, var)
enforce_kind_in_optimizer!(form, optimizer, var)
enforce_bounds_in_optimizer!(form, optimizer, var)
MOI.set(inner, MOI.VariableName(), moi_index, getname(form, var))
return
end
function add_to_optimizer!(
form::Formulation, optimizer::MoiOptimizer, constr::Constraint, var_checker::Function
)
constr_id = getid(constr)
inner = getinner(optimizer)
matrix = getcoefmatrix(form)
terms = MOI.ScalarAffineTerm{Float64}[]
for (varid, coeff) in @view matrix[constr_id, :]
var = getvar(form, varid)
@assert !isnothing(var)
if var_checker(form, var)
moi_id = getmoiindex(getmoirecord(var))
push!(terms, MOI.ScalarAffineTerm{Float64}(coeff, moi_id))
end
end
lhs = MOI.ScalarAffineFunction(terms, 0.0)
moi_set = convert_coluna_sense_to_moi(getcursense(form, constr))
moi_constr = MOI.add_constraint(
inner, lhs, moi_set(getcurrhs(form, constr))
)
moirecord = getmoirecord(constr)
setmoiindex!(moirecord, moi_constr)
MOI.set(inner, MOI.ConstraintName(), moi_constr, getname(form, constr))
return
end
function remove_from_optimizer!(form::Formulation, optimizer::MoiOptimizer, ids::Set{I}) where {I<:Id}
for id in ids
elem = getelem(form, id)
if elem !== nothing
remove_from_optimizer!(form, optimizer, getelem(form, id))
else
definitive_deletion_from_optimizer!(form, optimizer, id)
end
end
return
end
function definitive_deletion_from_optimizer!(form::Formulation, optimizer::MoiOptimizer, varid::VarId)
var = form.buffer.var_buffer.definitive_deletion[varid]
remove_from_optimizer!(form, optimizer, var)
return
end
function definitive_deletion_from_optimizer!(form::Formulation, optimizer::MoiOptimizer, constrid::ConstrId)
constr = form.buffer.constr_buffer.definitive_deletion[constrid]
remove_from_optimizer!(form, optimizer, constr)
return
end
function remove_from_optimizer!(::Formulation, optimizer::MoiOptimizer, var::Variable)
inner = getinner(optimizer)
moirecord = getmoirecord(var)
@assert getmoiindex(moirecord).value != -1
MOI.delete(inner, getlowerbound(moirecord))
MOI.delete(inner, getupperbound(moirecord))
setlowerbound!(moirecord, MoiVarLowerBound())
setupperbound!(moirecord, MoiVarUpperBound())
if getkind(moirecord).value != -1
MOI.delete(inner, getkind(moirecord))
end
setkind!(moirecord, MoiVarKind())
MOI.delete(inner, getmoiindex(moirecord))
setmoiindex!(moirecord, MoiVarIndex())
return
end
function remove_from_optimizer!(
::Formulation, optimizer::MoiOptimizer, constr::Constraint
)
moirecord = getmoirecord(constr)
@assert getmoiindex(moirecord).value != -1
MOI.delete(getinner(optimizer), getmoiindex(moirecord))
setmoiindex!(moirecord, MoiConstrIndex())
return
end
function _getcolunakind(record::MoiVarRecord)
record.kind.value == -1 && return Continuous
record.kind isa MoiBinary && return Binary
return Integ
end
function get_primal_solutions(form::F, optimizer::MoiOptimizer) where {F <: Formulation}
inner = getinner(optimizer)
nb_primal_sols = MOI.get(inner, MOI.ResultCount())
solutions = PrimalSolution{F}[]
for res_idx in 1:nb_primal_sols
if MOI.get(inner, MOI.PrimalStatus(res_idx)) != MOI.FEASIBLE_POINT
continue
end
solcost = getobjconst(form)
solvars = VarId[]
solvals = Float64[]
# Get primal values of variables
for (id, var) in getvars(form)
iscuractive(form, id) && isexplicit(form, id) || continue
moirec = getmoirecord(var)
moi_index = getmoiindex(moirec)
val = MOI.get(inner, MOI.VariablePrimal(res_idx), moi_index)
solcost += val * getcurcost(form, id)
val = round(val, digits = Coluna.TOL_DIGITS)
if abs(val) > Coluna.TOL
push!(solvars, id)
push!(solvals, val)
end
end
fixed_obj = 0.0
for (var_id, fixed_val) in getpartialsol(form)
push!(solvars, var_id)
push!(solvals, fixed_val)
fixed_obj += getcurcost(form, var_id) * fixed_val
end
solcost += fixed_obj
push!(solutions, PrimalSolution(form, solvars, solvals, solcost, FEASIBLE_SOL))
end
return solutions
end
# Retrieve dual solutions stored in the optimizer of a formulation
# It works only if the optimizer is wrapped with MathOptInterface.
# NOTE: we don't use the same convention as MOI for signs of duals in the maximisation case.
function get_dual_solutions(form::F, optimizer::MoiOptimizer) where {F <: Formulation}
inner = getinner(optimizer)
nb_dual_sols = MOI.get(inner, MOI.ResultCount())
solutions = DualSolution{F}[]
sense = getobjsense(form) == MinSense ? 1.0 : -1.0
for res_idx in 1:nb_dual_sols
# We retrieve only feasible dual solutions
if MOI.get(inner, MOI.DualStatus(res_idx)) != MOI.FEASIBLE_POINT
continue
end
# Cost of the dual solution
solcost = getobjconst(form)
# Get dual value of constraints
solconstrs = ConstrId[]
solvals = Float64[]
for (id, constr) in getconstrs(form)
moi_index = getmoiindex(getmoirecord(constr))
MOI.is_valid(inner, moi_index) || continue
val = MOI.get(inner, MOI.ConstraintDual(res_idx), moi_index)
solcost += val * getcurrhs(form, id)
val = round(val, digits = Coluna.TOL_DIGITS)
if abs(val) > Coluna.TOL
push!(solconstrs, id)
push!(solvals, sense * val)
end
end
# Get dual value & active bound of variables
varids = VarId[]
varvals = Float64[]
activebounds = ActiveBound[]
for (varid, var) in getvars(form)
moi_var_index = getmoiindex(getmoirecord(var))
moi_lower_bound_index = getlowerbound(getmoirecord(var))
if MOI.is_valid(inner, moi_var_index) && MOI.is_valid(inner, moi_lower_bound_index)
val = MOI.get(inner, MOI.ConstraintDual(res_idx), moi_lower_bound_index)
if abs(val) > Coluna.TOL
solcost += val * getcurlb(form, varid)
push!(varids, varid)
push!(varvals, sense * val)
push!(activebounds, LOWER)
end
end
moi_upper_bound_index = getupperbound(getmoirecord(var))
if MOI.is_valid(inner, moi_var_index) && MOI.is_valid(inner, moi_upper_bound_index)
val = MOI.get(inner, MOI.ConstraintDual(res_idx), moi_upper_bound_index)
if abs(val) > Coluna.TOL
solcost += val * getcurub(form, varid)
push!(varids, varid)
push!(varvals, sense * val)
push!(activebounds, UPPER)
end
end
end
fixed_obj = 0.0
for (var_id, fixed_val) in getpartialsol(form)
cost = getcurcost(form, var_id)
if abs(cost) > Coluna.TOL
fixed_obj += cost * fixed_val
end
end
solcost += fixed_obj
push!(solutions, DualSolution(
form, solconstrs, solvals, varids, varvals, activebounds, sense*solcost,
FEASIBLE_SOL
))
end
return solutions
end
function get_dual_infeasibility_certificate(form::F, optimizer::MoiOptimizer) where {F <: Formulation}
inner = getinner(optimizer)
nb_certificates = MOI.get(inner, MOI.ResultCount())
certificates = PrimalSolution{F}[]
for res_idx in 1:nb_certificates
if MOI.get(inner, MOI.PrimalStatus(res_idx)) != MOI.INFEASIBILITY_CERTIFICATE
continue
end
# The ray is stored in the primal status.
certificate_var_ids = VarId[]
certificate_var_vals = Float64[]
for (varid, var) in getvars(form)
moi_index = getmoiindex(getmoirecord(var))
MOI.is_valid(inner, moi_index) || continue
val = MOI.get(inner, MOI.VariablePrimal(res_idx), moi_index)
val = round(val, digits = Coluna.TOL_DIGITS)
if abs(val) > Coluna.TOL
push!(certificate_var_ids, varid)
push!(certificate_var_vals, val)
end
end
push!(certificates, PrimalSolution(form, certificate_var_ids, certificate_var_vals, 0.0, INFEASIBLE_SOL))
end
return certificates
end
function _show_function(io::IO, moi_model::MOI.ModelLike,
func::MOI.ScalarAffineFunction)
for term in func.terms
moi_index = term.variable
coeff = term.coefficient
name = MOI.get(moi_model, MOI.VariableName(), moi_index)
if name == ""
name = string("x", moi_index.value)
end
print(io, " + ", coeff, " ", name)
end
return
end
function _show_function(io::IO, moi_model::MOI.ModelLike,
func::MOI.VariableIndex)
moi_index = func.variable
name = MOI.get(moi_model, MOI.VariableName(), moi_index)
if name == ""
name = string("x", moi_index.value)
end
print(io, " + ", name)
return
end
get_moi_set_info(set::MOI.EqualTo) = ("==", set.value)
get_moi_set_info(set::MOI.GreaterThan) = (">=", set.lower)
get_moi_set_info(set::MOI.LessThan) = ("<=", set.upper)
get_moi_set_info(::MOI.Integer) = ("is", "Integer")
get_moi_set_info(::MOI.ZeroOne) = ("is", "Binary")
get_moi_set_info(set::MOI.Interval) = (
"is bounded in", string("[", set.lower, ";", set.upper, "]")
)
function _show_set(io::IO, moi_model::MOI.ModelLike,
set::MOI.AbstractScalarSet)
op, rhs = get_moi_set_info(set)
print(io, " ", op, " ", rhs)
return
end
function _show_constraint(io::IO, moi_model::MOI.ModelLike,
moi_index::MOI.ConstraintIndex)
name = MOI.get(moi_model, MOI.ConstraintName(), moi_index)
if name == ""
name = string("constr_", moi_index.value)
end
print(io, name, " : ")
func = MOI.get(moi_model, MOI.ConstraintFunction(), moi_index)
_show_function(io, moi_model, func)
set = MOI.get(moi_model, MOI.ConstraintSet(), moi_index)
_show_set(io, moi_model, set)
println(io, "")
return
end
function _show_constraints(io::IO, moi_model::MOI.ModelLike)
for (F, S) in MOI.get(moi_model, MOI.ListOfConstraintTypesPresent())
F == MOI.VariableIndex && continue
for moi_index in MOI.get(moi_model, MOI.ListOfConstraintIndices{F, S}())
_show_constraint(io, moi_model, moi_index)
end
end
for (F, S) in MOI.get(moi_model, MOI.ListOfConstraintTypesPresent())
F !== MOI.VariableIndex && continue
for moi_index in MOI.get(moi_model, MOI.ListOfConstraintIndices{MOI.VariableIndex,S}())
_show_constraint(io, moi_model, moi_index)
end
end
return
end
function _show_obj_fun(io::IO, moi_model::MOI.ModelLike)
sense = MOI.get(moi_model, MOI.ObjectiveSense())
sense == MOI.MIN_SENSE ? print(io, "Min") : print(io, "Max")
obj = MOI.get(moi_model, MoiObjective())
_show_function(io, moi_model, obj)
println(io, "")
return
end
function _show_optimizer(io::IO, optimizer::MOI.ModelLike)
println(io, "MOI Optimizer {", typeof(optimizer), "} = ")
_show_obj_fun(io, optimizer)
_show_constraints(io, optimizer)
return
end
_show_optimizer(io::IO, optimizer::MOI.Utilities.CachingOptimizer) = _show_optimizer(io, optimizer.model_cache)
Base.show(io::IO, optimizer::MoiOptimizer) = _show_optimizer(io, getinner(optimizer))
| Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 3673 | module MathProg
import BlockDecomposition
import MathOptInterface
import TimerOutputs
using ..Coluna # for NestedEnum (types.jl:210)
using ..ColunaBase
import Base: haskey, length, iterate, diff, delete!, contains, setindex!, getindex, view, isequal
using DynamicSparseArrays, SparseArrays, Logging, Printf, LinearAlgebra
const BD = BlockDecomposition
const ClB = ColunaBase
const MOI = MathOptInterface
const TO = TimerOutputs
const MAX_NB_FORMULATIONS = typemax(Int16)
include("types.jl")
include("vcids.jl")
include("variable.jl")
include("constraint.jl")
include("bounds.jl")
include("solutions.jl")
include("buffer.jl")
include("manager.jl")
include("pool.jl")
include("duties.jl")
include("formulation.jl")
include("varconstr.jl")
include("optimizerwrappers.jl")
include("clone.jl")
include("reformulation.jl")
include("projection.jl")
include("problem.jl")
include("MOIinterface.jl")
# TODO : clean up
# Types
export MaxSense, MinSense,
Id, ConstrSense, VarSense,
FormId, FormulationPhase, Annotations,
Counter, MoiObjective
# Methods
export no_optimizer_builder, set_original_formulation!,
getid,
enforce_integrality!, relax_integrality!,
getobjsense, getoptimizer, getoptimizers,
update!,
getduty,
find_owner_formulation,
getsortuid,
contains, get_original_formulation,
getoriginformuid, sync_solver!, getinner,
get_primal_solutions, get_dual_solutions, constraint_primal
# Below this line, clean up has been done :
# Methods related to Problem
export Problem, set_initial_dual_bound!, set_initial_primal_bound!,
get_initial_dual_bound, get_initial_primal_bound, get_optimization_target,
set_default_optimizer_builder!
# Methods related to Reformulation
export Reformulation, getmaster, add_dw_pricing_sp!, add_benders_sep_sp!, get_dw_pricing_sps,
set_reformulation!, get_benders_sep_sps, get_dw_pricing_sp_ub_constrid,
get_dw_pricing_sp_lb_constrid, setmaster!
# Methods related to formulations
export AbstractFormulation, Formulation, create_formulation!, getvar, getvars,
getconstr, getconstrs, getelem, getcoefmatrix, get_primal_sol_pool, get_dual_sol_pool,
setvar!, setconstr!,
set_robust_constr_generator!, get_robust_constr_generators,
set_objective_sense!, clonevar!, cloneconstr!, clonecoeffs!, initialize_optimizer!,
push_optimizer!, getobjconst, setobjconst!,
insert_column!, get_column_from_pool, getfixedvars
# Duties of formulations
export Original, DwMaster, BendersMaster, DwSp, BendersSp
# Methods related to duties
export isanArtificialDuty, isaStaticDuty, isaDynamicDuty, isanOriginalRepresentatives
# Types and methods related to variables and constraints
export Variable, Constraint, VarId, ConstrId, VarMembership, ConstrMembership,
getperencost, setperencost!, getcurcost, setcurcost!, getperenlb, getcurlb, setcurlb!,
getperenub, getcurub, setcurub!, getperenrhs, setperenrhs!, getcurrhs, setcurrhs!, getperensense, setperensense!,
getcursense, setcursense!, getperenkind, getcurkind, setcurkind!, getperenincval,
getcurincval, setcurincval!, isperenactive, iscuractive, activate!, deactivate!,
isexplicit, getname, getbranchingpriority, reset!, setperenkind!, add_to_partial_solution!,
getcustomdata
# Types & methods related to solutions & bounds
export PrimalBound, DualBound, AbstractSolution, PrimalSolution, DualSolution, ActiveBound, ObjValues,
get_var_redcosts
# Methods related to projections
export projection_is_possible, proj_cols_on_rep
# Optimizers of formulations
export MoiOptimizer, CustomOptimizer, UserOptimizer, NoOptimizer
end
| Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 4828 | """
PrimalBound(formulation)
PrimalBound(formulation, value)
PrimalBound(formualtion, pb)
Create a new primal bound for the formulation `formulation`.
The value of the primal bound is infinity if you do not specify any initial value.
"""
function PrimalBound(form::AbstractFormulation)
min = getobjsense(form) == MinSense
return ColunaBase.Bound(min, true)
end
function PrimalBound(form::AbstractFormulation, val)
min = getobjsense(form) == MinSense
return ColunaBase.Bound(min, true, val)
end
function PrimalBound(form::AbstractFormulation, pb::ColunaBase.Bound)
min = getobjsense(form) == MinSense
@assert pb.primal && pb.min == min
return ColunaBase.Bound(min, true, ColunaBase.getvalue(pb))
end
PrimalBound(::AbstractFormulation, ::Nothing) = nothing
"""
DualBound(formulation)
DualBound(formulation, value)
DualBound(formulation, db)
Create a new dual bound for the formulation `formulation`.
The value of the dual bound is infinity if you do not specify any initial value.
"""
function DualBound(form::AbstractFormulation)
min = getobjsense(form) == MinSense
return ColunaBase.Bound(min, false)
end
function DualBound(form::AbstractFormulation, val::Real)
min = getobjsense(form) == MinSense
return ColunaBase.Bound(min, false, val)
end
DualBound(::AbstractFormulation, ::Nothing) = nothing
function DualBound(form::AbstractFormulation, db::ColunaBase.Bound)
min = getobjsense(form) == MinSense
@assert !db.primal && db.min == min
return ColunaBase.Bound(min, false, ColunaBase.getvalue(db))
end
# ObjValues
mutable struct ObjValues
min::Bool
lp_primal_bound::Union{Nothing,ColunaBase.Bound}
lp_dual_bound::Union{Nothing,ColunaBase.Bound}
ip_primal_bound::Union{Nothing,ColunaBase.Bound}
ip_dual_bound::Union{Nothing,ColunaBase.Bound}
end
"A convenient structure to maintain and return incumbent bounds."
function ObjValues(
form::M;
ip_primal_bound = nothing,
ip_dual_bound = nothing,
lp_primal_bound = nothing,
lp_dual_bound = nothing
) where {M<:AbstractFormulation}
min = getobjsense(form) == MinSense
ov = ObjValues(
min, PrimalBound(form), DualBound(form), PrimalBound(form), DualBound(form)
)
if !isnothing(ip_primal_bound)
ov.ip_primal_bound = PrimalBound(form, ip_primal_bound)
end
if !isnothing(ip_dual_bound)
ov.ip_dual_bound = DualBound(form, ip_dual_bound)
end
if !isnothing(lp_primal_bound)
ov.lp_primal_bound = PrimalBound(form, lp_primal_bound)
end
if !isnothing(lp_dual_bound)
ov.lp_dual_bound = DualBound(form, lp_dual_bound)
end
return ov
end
## Gaps
_ip_gap(ov::ObjValues) = gap(ov.ip_primal_bound, ov.ip_dual_bound)
_lp_gap(ov::ObjValues) = gap(ov.lp_primal_bound, ov.lp_dual_bound)
function gap_closed(
pb::Bound, db::Bound; atol = Coluna.DEF_OPTIMALITY_ATOL, rtol = Coluna.DEF_OPTIMALITY_RTOL
)
return gap(pb, db) <= 0 || _gap_closed(
pb.value, db.value, atol = atol, rtol = rtol
)
end
function _ip_gap_closed(
ov::ObjValues; atol = Coluna.DEF_OPTIMALITY_ATOL, rtol = Coluna.DEF_OPTIMALITY_RTOL
)
return gap_closed(ov.ip_primal_bound, ov.ip_dual_bound, atol = atol, rtol = rtol)
end
function _lp_gap_closed(
ov::ObjValues; atol = Coluna.DEF_OPTIMALITY_ATOL, rtol = Coluna.DEF_OPTIMALITY_RTOL
)
return gap_closed(ov.lp_primal_bound, ov.lp_dual_bound, atol = atol, rtol = rtol)
end
function _gap_closed(
x::Number, y::Number; atol::Real = 0, rtol::Real = atol > 0 ? 0 : √eps,
norm::Function = abs
)
return x == y || (isfinite(x) && isfinite(y) && norm(x - y) <= max(atol, rtol*min(norm(x), norm(y))))
end
## Bound updates
function _update_lp_primal_bound!(ov::ObjValues, pb::ColunaBase.Bound)
@assert pb.primal && pb.min == ov.min
if isnothing(ov.lp_primal_bound) || ColunaBase.isbetter(pb, ov.lp_primal_bound)
ov.lp_primal_bound = pb
return true
end
return false
end
function _update_lp_dual_bound!(ov::ObjValues, db::ColunaBase.Bound)
@assert !db.primal && db.min == ov.min
if isnothing(ov.lp_dual_bound) || ColunaBase.isbetter(db, ov.lp_dual_bound)
ov.lp_dual_bound = db
return true
end
return false
end
function _update_ip_primal_bound!(ov::ObjValues, pb::ColunaBase.Bound)
@assert pb.primal && pb.min == ov.min
if isnothing(ov.ip_primal_bound) || ColunaBase.isbetter(pb, ov.ip_primal_bound)
ov.ip_primal_bound = pb
return true
end
return false
end
function _update_ip_dual_bound!(ov::ObjValues, db::ColunaBase.Bound)
@assert !db.primal && db.min == ov.min
if isnothing(ov.ip_dual_bound) || ColunaBase.isbetter(db, ov.ip_dual_bound)
ov.ip_dual_bound = db
return true
end
return false
end | Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 5295 | """
A `VarConstrBuffer{I,VC}` stores the ids of type `I` of the variables or constraints
that will be added and removed from a formulation.
"""
mutable struct VarConstrBuffer{I,VC}
added::Set{I}
removed::Set{I}
definitive_deletion::Dict{I,VC}
end
function VarConstrBuffer{I,VC}() where {I,VC}
return VarConstrBuffer(Set{I}(), Set{I}(), Dict{I,VC}())
end
function Base.isequal(a::VarConstrBuffer{I,VC}, b::VarConstrBuffer{I,VC}) where {I,VC}
return isequal(a.added, b.added) && isequal(a.removed, b.removed)
end
function add!(buffer::VarConstrBuffer{I,VC}, id::I) where {I,VC}
if id ∉ buffer.removed
push!(buffer.added, id)
else
delete!(buffer.removed, id)
end
return
end
function remove!(buffer::VarConstrBuffer{I,VC}, id::I) where {I,VC}
if id ∉ buffer.added
push!(buffer.removed, id)
else
delete!(buffer.added, id)
end
return
end
function definitive_deletion!(buffer::VarConstrBuffer{I,VC}, elem::VC) where {I,VC}
id = getid(elem)
if id ∉ buffer.added
push!(buffer.removed, id)
buffer.definitive_deletion[id] = elem
else
delete!(buffer.added, id)
end
return
end
"""
A `FormulationBuffer` stores all changes done to a formulation since last call to `sync_solver!`.
When function `sync_solver!` is called, the optimizer is synched with all changes in FormulationBuffer
**Warning** : You should not pass formulation changes straight to its optimizer.
Changes must be always buffered.
"""
mutable struct FormulationBuffer{Vi,V,Ci,C}
changed_obj_sense::Bool # sense of the objective function
changed_cost::Set{Vi} # cost of a variable
changed_bound::Set{Vi} # bound of a variable
changed_var_kind::Set{Vi} # kind of a variable
changed_rhs::Set{Ci} # rhs and sense of a constraint
var_buffer::VarConstrBuffer{Vi,V} # variable added or removed
constr_buffer::VarConstrBuffer{Ci,C} # constraint added or removed
reset_coeffs::Dict{Pair{Ci,Vi},Float64} # coefficient of the matrix changed
end
FormulationBuffer{Vi,V,Ci,C}() where {Vi,V,Ci,C} = FormulationBuffer(
false, Set{Vi}(), Set{Vi}(), Set{Vi}(), Set{Ci}(),
VarConstrBuffer{Vi, V}(), VarConstrBuffer{Ci, C}(),
Dict{Pair{Ci,Vi},Float64}()
)
function empty!(buffer::FormulationBuffer{Vi,V,Ci,C}) where {Vi,V,Ci,C}
buffer.changed_obj_sense = false
buffer.changed_cost = Set{Vi}()
buffer.changed_bound = Set{Vi}()
buffer.changed_var_kind = Set{Vi}()
buffer.changed_rhs = Set{Ci}()
buffer.var_buffer = VarConstrBuffer{Vi,V}()
buffer.constr_buffer = VarConstrBuffer{Ci,C}()
buffer.reset_coeffs = Dict{Pair{Ci,Vi},Float64}()
end
add!(b::FormulationBuffer{Vi,V,Ci,C}, varid::Vi) where {Vi,V,Ci,C} = add!(b.var_buffer, varid)
add!(b::FormulationBuffer{Vi,V,Ci,C}, constrid::Ci) where {Vi,V,Ci,C} = add!(b.constr_buffer, constrid)
# Since there is no efficient way to remove changes done to the coefficient matrix,
# we propagate them if the variable is active and explicit
function remove!(buffer::FormulationBuffer{Vi,V,Ci,C}, varid::Vi) where {Vi,V,Ci,C}
remove!(buffer.var_buffer, varid)
delete!(buffer.changed_cost, varid)
delete!(buffer.changed_bound, varid)
delete!(buffer.changed_var_kind, varid)
return
end
# Use definitive deletion when you delete the variable from the formulation,
# Otherwise, the variable object is garbage collected so we can't retrieve the
# other constraints attached to the variable anymore.
# definitive_deletion! keeps the object until deletion is performed in the subsolver.
function definitive_deletion!(buffer::FormulationBuffer{Vi,V,Ci,C}, var::V) where {Vi,V,Ci,C}
varid = getid(var)
definitive_deletion!(buffer.var_buffer, var)
delete!(buffer.changed_cost, varid)
delete!(buffer.changed_bound, varid)
delete!(buffer.changed_var_kind, varid)
return
end
# Since there is no efficient way to remove changes done to the coefficient matrix,
# we propagate them if and only if the constraint is active and explicit
function remove!(buffer::FormulationBuffer{Vi,V,Ci,C}, constrid::Ci) where {Vi,V,Ci,C}
remove!(buffer.constr_buffer, constrid)
delete!(buffer.changed_rhs, constrid)
return
end
# Same as definitive_deletion! of a variable.
function definitive_deletion!(buffer::FormulationBuffer{Vi,V,Ci,C}, constr::C) where {Vi,V,Ci,C}
definitive_deletion!(buffer.constr_buffer, constr)
delete!(buffer.changed_rhs, getid(constr))
return
end
function change_rhs!(buffer::FormulationBuffer{Vi,V,Ci,C}, constrid::Ci) where {Vi,V,Ci,C}
push!(buffer.changed_rhs, constrid)
return
end
function change_cost!(buffer::FormulationBuffer{Vi,V,Ci,C}, varid::Vi) where {Vi,V,Ci,C}
push!(buffer.changed_cost, varid)
return
end
function change_bound!(buffer::FormulationBuffer{Vi,V,Ci,C}, varid::Vi) where {Vi,V,Ci,C}
push!(buffer.changed_bound, varid)
return
end
function change_kind!(buffer::FormulationBuffer{Vi,V,Ci,C}, varid::Vi) where {Vi,V,Ci,C}
push!(buffer.changed_var_kind, varid)
return
end
function change_matrix_coeff!(
buffer::FormulationBuffer{Vi,V,Ci,C}, constrid::Ci, varid::Vi, new_coeff::Float64
) where {Vi,V,Ci,C}
buffer.reset_coeffs[Pair(constrid, varid)] = new_coeff
return
end
| Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 2877 | # TODO : these methods should not be part of MathProg.
function clonevar!(
originform::Formulation,
destform::Formulation,
assignedform::Formulation,
var::Variable,
duty::Duty{Variable};
name::String = getname(originform, var),
cost::Float64 = getperencost(originform, var),
lb::Float64 = getperenlb(originform, var),
ub::Float64 = getperenub(originform, var),
kind::VarKind = getperenkind(originform, var),
inc_val::Float64 = getperenincval(originform, var),
is_active::Bool = isperenactive(originform, var),
is_explicit::Bool = isexplicit(originform, var),
branching_priority::Float64 = getbranchingpriority(originform, var),
members::Union{ConstrMembership,Nothing} = nothing,
custom_data = getcustomdata(originform, var)
)
id_of_clone = VarId(
getid(var);
duty = duty,
assigned_form_uid = getuid(assignedform)
)
return setvar!(
destform, name, duty;
cost = cost, lb = lb, ub = ub, kind = kind,
inc_val = inc_val, is_active = is_active, is_explicit = is_explicit,
branching_priority = branching_priority, members = members,
id = id_of_clone, custom_data = custom_data
)
end
function cloneconstr!(
originform::Formulation,
destform::Formulation,
assignedform::Formulation,
constr::Constraint,
duty::Duty{Constraint};
name::String = getname(originform, constr),
rhs::Float64 = getperenrhs(originform, constr),
kind::ConstrKind = getperenkind(originform, constr),
sense::ConstrSense = getperensense(originform, constr),
inc_val::Float64 = getperenincval(originform, constr),
is_active::Bool = isperenactive(originform, constr),
is_explicit::Bool = isexplicit(originform, constr),
members::Union{VarMembership,Nothing} = nothing,
loc_art_var_abs_cost::Float64 = 0.0,
custom_data = getcustomdata(originform, constr)
)
id_of_clone = ConstrId(
getid(constr);
duty = duty,
assigned_form_uid = getuid(assignedform)
)
return setconstr!(
destform, name, duty;
rhs = rhs, kind = kind, sense = sense, inc_val = inc_val,
is_active = is_active, is_explicit = is_explicit, members = members,
loc_art_var_abs_cost = loc_art_var_abs_cost,
id = id_of_clone, custom_data = custom_data
)
end
function clonecoeffs!(originform::Formulation, destform::Formulation)
dest_matrix = getcoefmatrix(destform)
orig_matrix = getcoefmatrix(originform)
for (cid, constr) in getconstrs(destform)
if haskey(originform, cid)
row = @view orig_matrix[cid, :]
for (vid, val) in row
if haskey(destform, vid) && val != 0
dest_matrix[cid, getid(getvar(destform, vid))] = val
end
end
end
end
return
end
| Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 2091 | """
Information that defines a state of a constraint.
These data might change during the optimisation procedure.
"""
mutable struct ConstrData <: AbstractVcData
rhs::Float64
kind::ConstrKind
sense::ConstrSense
inc_val::Float64
is_active::Bool
is_explicit::Bool
end
function ConstrData(;
rhs::Float64 = -Inf,
kind::ConstrKind = Essential,
sense::ConstrSense = Greater,
inc_val::Float64 = -1.0,
is_active::Bool = true,
is_explicit::Bool = true
)
return ConstrData(rhs, kind, sense, inc_val, is_active, is_explicit)
end
ConstrData(cd::ConstrData) = ConstrData(
cd.rhs, cd.kind, cd.sense, cd.inc_val, cd.is_active, cd.is_explicit
)
"Structure to hold the pointers to the MOI representation of a Coluna Constraint."
mutable struct MoiConstrRecord
index::MoiConstrIndex
end
MoiConstrRecord(;index = MoiConstrIndex()) = MoiConstrRecord(index)
getmoiindex(record::MoiConstrRecord)::MoiConstrIndex = record.index
setmoiindex!(record::MoiConstrRecord, index::MoiConstrIndex) = record.index = index
"""
Representation of a constraint in Coluna.
Coefficients of variables involved in the constraints are stored in the coefficient matrix.
"""
mutable struct Constraint <: AbstractVarConstr
id::Id{Constraint}
name::String
perendata::ConstrData
curdata::ConstrData
moirecord::MoiConstrRecord
art_var_ids::Vector{VarId}
custom_data::Union{Nothing, BD.AbstractCustomConstrData}
end
const ConstrId = Id{Constraint}
# Internal use only, see `MathProg.setconstr!` to create a constraint.
function Constraint(
id::ConstrId, name::String;
constr_data = ConstrData(), moi_index::MoiConstrIndex = MoiConstrIndex(),
custom_data::Union{Nothing, BD.AbstractCustomConstrData} = nothing
)
return Constraint(
id, name, constr_data, ConstrData(constr_data), MoiConstrRecord(index = moi_index),
VarId[], custom_data
)
end
"""
Constraints generator (cut callback).
"""
mutable struct RobustConstraintsGenerator
nb_generated::Int
kind::ConstrKind
separation_alg::Function
end | Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 6621 | ############################################################################################
# Duties for a Formulation
############################################################################################
# These contain data specific to a type of formulation.
# For example, the pool of primal solution generated from a Dantzig-Wolfe subproblem.
abstract type AbstractFormDuty end
abstract type AbstractMasterDuty <: AbstractFormDuty end
abstract type AbstractSpDuty <: AbstractFormDuty end
"Formulation provided by the user."
struct Original <: AbstractFormDuty end
"Master of a formulation decomposed using Dantzig-Wolfe."
struct DwMaster <: AbstractMasterDuty end
"Master of a formulation decomposed using Benders."
struct BendersMaster <: AbstractMasterDuty end
mutable struct DwSp <: AbstractSpDuty
setup_var::Union{VarId,Nothing}
lower_multiplicity_constr_id::Union{ConstrId,Nothing}
upper_multiplicity_constr_id::Union{ConstrId,Nothing}
column_var_kind::VarKind
branching_priority::Float64
# Pool of solutions to the Dantzig-Wolfe subproblem.
pool::Pool
end
"A pricing subproblem of a formulation decomposed using Dantzig-Wolfe."
function DwSp(setup_var, lower_multiplicity_constr_id, upper_multiplicity_constr_id, column_var_kind)
return DwSp(
setup_var,
lower_multiplicity_constr_id,
upper_multiplicity_constr_id,
column_var_kind,
1.0,
Pool()
)
end
mutable struct BendersSp <: AbstractSpDuty
slack_to_first_stage::Dict{VarId,VarId}
second_stage_cost_var::Union{VarId,Nothing}
pool::DualSolutionPool
end
"A Benders subproblem of a formulation decomposed using Benders."
BendersSp() = BendersSp(Dict{VarId,VarId}(), nothing, DualSolutionPool())
############################################################################################
# Duties tree for a Variable
############################################################################################
@exported_nestedenum begin
Duty{Variable}
AbstractOriginalVar <= Duty{Variable}
OriginalVar <= AbstractOriginalVar
AbstractMasterVar <= Duty{Variable}
AbstractOriginMasterVar <= AbstractMasterVar
MasterPureVar <= AbstractOriginMasterVar
MasterBendFirstStageVar <= AbstractOriginMasterVar
AbstractAddedMasterVar <= AbstractMasterVar
MasterCol <= AbstractAddedMasterVar
MasterArtVar <= AbstractAddedMasterVar
MasterBendSecondStageCostVar <= AbstractAddedMasterVar
AbstractImplicitMasterVar <= AbstractMasterVar
AbstractMasterRepDwSpVar <= AbstractImplicitMasterVar
MasterRepPricingVar <= AbstractMasterRepDwSpVar
MasterRepPricingSetupVar <= AbstractMasterRepDwSpVar
AbstractDwSpVar <= Duty{Variable}
DwSpPricingVar <= AbstractDwSpVar
DwSpSetupVar <= AbstractDwSpVar
DwSpPrimalSol <= AbstractDwSpVar
AbstractBendSpVar <= Duty{Variable}
AbstractBendSpSlackMastVar <= AbstractBendSpVar
BendSpSlackFirstStageVar <= AbstractBendSpSlackMastVar
BendSpPosSlackFirstStageVar <= BendSpSlackFirstStageVar
BendSpNegSlackFirstStageVar <= BendSpSlackFirstStageVar
BendSpSlackSecondStageCostVar <= AbstractBendSpSlackMastVar
BendSpSecondStageArtVar <= AbstractBendSpSlackMastVar
BendSpSepVar <= AbstractBendSpVar
BendSpFirstStageRepVar <= AbstractBendSpVar
BendSpCostRepVar <= AbstractBendSpVar
end
############################################################################################
# Duties tree for a Constraint
############################################################################################
@exported_nestedenum begin
Duty{Constraint}
AbstractOriginalConstr <= Duty{Constraint}
OriginalConstr <= AbstractOriginalConstr
AbstractMasterConstr <= Duty{Constraint}
AbstractMasterOriginConstr <= AbstractMasterConstr
MasterPureConstr <= AbstractMasterOriginConstr
MasterMixedConstr <= AbstractMasterOriginConstr
AbstractMasterAddedConstr <= AbstractMasterConstr
MasterConvexityConstr <= AbstractMasterAddedConstr
AbstractMasterCutConstr <= AbstractMasterConstr
MasterBendCutConstr <= AbstractMasterCutConstr
MasterUserCutConstr <= AbstractMasterCutConstr
AbstractMasterBranchingConstr <= AbstractMasterConstr
MasterBranchOnOrigVarConstr <= AbstractMasterBranchingConstr
AbstractDwSpConstr <= Duty{Constraint}
DwSpPureConstr <= AbstractDwSpConstr
AbstractBendSpConstr <= Duty{Constraint}
AbstractBendSpMasterConstr <= AbstractBendSpConstr
BendSpSecondStageCostConstr <= AbstractBendSpMasterConstr
BendSpTechnologicalConstr <= AbstractBendSpMasterConstr
BendSpPureConstr <= AbstractBendSpConstr
BendSpDualSol <= AbstractBendSpConstr
end
############################################################################################
# Methods to get extra information about duties
############################################################################################
function isaStaticDuty(duty::NestedEnum)
return duty <= OriginalVar ||
duty <= MasterPureVar ||
duty <= MasterArtVar ||
duty <= MasterBendSecondStageCostVar ||
duty <= MasterBendFirstStageVar ||
duty <= MasterRepPricingVar ||
duty <= MasterRepPricingSetupVar ||
duty <= DwSpPricingVar ||
duty <= DwSpSetupVar ||
duty <= DwSpPrimalSol ||
duty <= BendSpSepVar ||
duty <= BendSpSlackFirstStageVar ||
duty <= BendSpSlackSecondStageCostVar ||
duty <= OriginalConstr ||
duty <= MasterPureConstr ||
duty <= MasterMixedConstr ||
duty <= MasterConvexityConstr ||
duty <= DwSpPureConstr ||
duty <= BendSpPureConstr ||
duty <= BendSpDualSol ||
duty <= BendSpSecondStageCostConstr ||
duty <= BendSpTechnologicalConstr
end
function isaDynamicDuty(duty::NestedEnum)
return duty <= MasterCol ||
duty <= MasterBranchOnOrigVarConstr ||
duty <= MasterBendCutConstr ||
duty <= MasterBranchOnOrigVarConstr
end
function isanOriginalRepresentatives(duty::NestedEnum)
return duty <= MasterPureVar ||
duty <= MasterRepPricingVar
end
function isanArtificialDuty(duty::NestedEnum)
return duty <= MasterArtVar || duty <= BendSpSecondStageArtVar
end
function isaNonUserDefinedDuty(duty::NestedEnum)
return duty <= MasterArtVar ||
duty <= MasterRepPricingSetupVar ||
duty <= MasterCol ||
duty <= DwSpSetupVar ||
duty <= MasterConvexityConstr
end | Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 26627 | mutable struct Formulation{Duty<:AbstractFormDuty} <: AbstractFormulation
uid::Int
parent_formulation::Union{AbstractFormulation,Nothing} # master for sp, reformulation for master
optimizers::Vector{AbstractOptimizer}
manager::FormulationManager
obj_sense::Type{<:Coluna.AbstractSense}
buffer::FormulationBuffer
storage::Union{Nothing,Storage}
duty_data::Duty
env::Env{VarId}
end
############################################################################################
############################################################################################
# Formulation classic API
############################################################################################
############################################################################################
"""
A `Formulation` stores a mixed-integer linear program.
create_formulation!(
env::Coluna.Env,
duty::AbstractFormDuty;
parent_formulation = nothing,
obj_sense::Type{<:Coluna.AbstractSense} = MinSense
)
Creates a new formulation in the Coluna's environment `env`.
Arguments are `duty` that contains specific information related to the duty of
the formulation, `parent_formulation` that is the parent formulation (master for a subproblem,
reformulation for a master, `nothing` by default), and `obj_sense` the sense of the objective
function (`MinSense` or `MaxSense`).
"""
function create_formulation!(
env::Env{VarId},
duty::AbstractFormDuty;
parent_formulation=nothing,
obj_sense::Type{<:Coluna.AbstractSense}=MinSense
)
if env.form_counter >= MAX_NB_FORMULATIONS
error("Maximum number of formulations reached.")
end
buffer = FormulationBuffer{VarId,Variable,ConstrId,Constraint}()
form = Formulation(
env.form_counter += 1, parent_formulation, AbstractOptimizer[],
FormulationManager(buffer, custom_families_id=env.custom_families_id), obj_sense,
buffer, nothing, duty, env
)
storage = Storage(form)
form.storage = storage
return form
end
# methods of the AbstractModel interface
"""
getuid(form) -> Int
Returns the id of the formulation.
"""
ClB.getuid(form::Formulation) = form.uid
"""
getstorage(form) -> Storage
Returns the storage of a formulation.
Read the documentation of the [Storage API](https://atoptima.github.io/Coluna.jl/stable/api/storage/).
"""
ClB.getstorage(form::Formulation) = form.storage
# methods specific to Formulation
"""
haskey(formulation, id) -> Bool
Returns `true` if `formulation` has a variable or a constraint with given `id`.
"""
haskey(form::Formulation, id::VarId) = haskey(form.manager.vars, id)
haskey(form::Formulation, id::ConstrId) = haskey(form.manager.constrs, id) || haskey(form.manager.single_var_constrs, id)
"""
getvar(formulation, varid) -> Variable
Returns the variable with given `varid` that belongs to `formulation`.
"""
getvar(form::Formulation, id::VarId) = get(form.manager.vars, id, nothing)
"""
getconstr(formulation, constrid) -> Constraint
Returns the constraint with given `constrid` that belongs to `formulation`.
"""
getconstr(form::Formulation, id::ConstrId) = get(form.manager.constrs, id, nothing)
"""
getvars(formulation) -> Dict{VarId, Variable}
Returns all variables in `formulation`.
"""
getvars(form::Formulation) = form.manager.vars
"""
getconstrs(formulation) -> Dict{ConstrId, Constraint}
Returns all constraints in `formulation`.
"""
getconstrs(form::Formulation) = form.manager.constrs
"Returns objective constant of the formulation."
getobjconst(form::Formulation) = form.manager.objective_constant
"Sets objective constant of the formulation."
function setobjconst!(form::Formulation, val::Float64)
form.manager.objective_constant = val
return
end
"Returns the representation of the coefficient matrix stored in the formulation manager."
getcoefmatrix(form::Formulation) = form.manager.coefficients
"Returns the objective function sense of a formulation."
getobjsense(form::Formulation) = form.obj_sense
"Returns the optimizer of a formulation at a given position."
function getoptimizer(form::Formulation, pos::Int)
if pos <= 0 || pos > length(form.optimizers)
return NoOptimizer()
end
return form.optimizers[pos]
end
"Returns the list of optimizers of a formulation."
getoptimizers(form::Formulation) = form.optimizers
"""
getelem(form, varid) -> Variable
getelem(form, constrid) -> Constraint
Return the element of formulation `form` that has a given id.
"""
getelem(form::Formulation, id::VarId) = getvar(form, id)
getelem(form::Formulation, id::ConstrId) = getconstr(form, id)
"""
getmaster(form) -> Formulation
Returns the master formulation of a given formulation.
"""
getmaster(form::Formulation{<:AbstractSpDuty}) = form.parent_formulation
"""
getparent(form) -> AbstractFormulation
Returns the parent formulation of a given formulation.
This is usually:
- the master for a subproblem
- the reformulation for the master
"""
getparent(form::Formulation) = form.parent_formulation
# Used to compute the coefficient of a column in the coefficient matrix.
_setrobustmembers!(::Formulation, ::Variable, ::Nothing) = nothing
function _setrobustmembers!(form::Formulation, var::Variable, members::ConstrMembership)
coef_matrix = getcoefmatrix(form)
varid = getid(var)
for (constrid, constr_coeff) in members
coef_matrix[constrid, varid] = constr_coeff
end
return
end
# Used to compute the coefficient of a row in the coefficient matrix.
_setrobustmembers!(::Formulation, ::Constraint, ::Nothing) = nothing
function _setrobustmembers!(form::Formulation, constr::Constraint, members::VarMembership)
# Compute row vector from the recorded subproblem solution
# This adds the column to the convexity constraints automatically
# since the setup variable is in the sp solution and it has a
# a coefficient of 1.0 in the convexity constraints
coef_matrix = getcoefmatrix(form)
constrid = getid(constr)
for (varid, var_coeff) in members
# Add coef for its own variables
coef_matrix[constrid, varid] = var_coeff
if getduty(varid) <= MasterRepPricingVar || getduty(varid) <= MasterRepPricingSetupVar
# then for all columns having its own variables
for (_, spform) in get_dw_pricing_sps(form.parent_formulation)
for (col_id, col_coeff) in @view get_primal_sol_pool(spform).solutions[:, varid]
coef_matrix[constrid, col_id] += col_coeff * var_coeff
end
end
end
end
return
end
"""
computecoeff(var_custom_data, constr_custom_data) -> Float64
Dispatches on the type of custom data attached to the variable and the constraint to compute
the coefficient of the variable in the constraint.
"""
function computecoeff(var_custom_data::BD.AbstractCustomVarData, constr_custom_data::BD.AbstractCustomConstrData)
error("computecoeff not defined for variable with $(typeof(var_custom_data)) & constraint with $(typeof(constr_custom_data)).")
end
function _computenonrobustmembers(form::Formulation, var::Variable)
coef_matrix = getcoefmatrix(form)
for (constrid, constr) in getconstrs(form) # TODO : improve because we loop over all constraints
if constrid.custom_family_id != -1
coeff = computecoeff(var.custom_data, constr.custom_data)
if coeff != 0
coef_matrix[constrid, getid(var)] = coeff
end
end
end
return
end
function _computenonrobustmembers(form::Formulation, constr::Constraint)
coef_matrix = getcoefmatrix(form)
for (varid, var) in getvars(form) # TODO : improve because we loop over all variables
if varid.custom_family_id != -1
coeff = computecoeff(var.custom_data, constr.custom_data)
if coeff != 0
coef_matrix[getid(constr), varid] = coeff
end
end
end
return
end
function _setmembers!(form::Formulation, varconstr, members)
_setrobustmembers!(form, varconstr, members)
if getid(varconstr).custom_family_id != -1
_computenonrobustmembers(form, varconstr)
end
return
end
"""
setvar!(
formulation, name, duty;
cost = 0.0,
lb = -Inf,
ub = Inf,
kind = Continuous,
is_active = true,
is_explicit = true,
members = nothing,
)
Create a new variable that has name `name` and duty `duty` in the formulation `formulation`.
Following keyword arguments allow the user to set additional information about the new
variable:
- `cost`: cost of the variable in the objective function
- `lb`: lower bound of the variable
- `ub`: upper bound of the variable
- `kind`: kind which can be `Continuous`, `Binary` or `Integ`
- `is_active`: `true` if the variable is used in the formulation, `false` otherwise
- `is_explicit`: `true` if the variable takes part to the formulation, `false` otherwise (e.g. a variable used as a shortcut for calculation purposes)
- `members`: a dictionary `Dict{ConstrId, Float64}` that contains the coefficients of the new variable in the constraints of the formulation (default coefficient is 0).
"""
function setvar!(
form::Formulation,
name::String,
duty::Duty{Variable};
# Perennial state of the variable
cost::Real=0.0,
lb::Real=-Inf,
ub::Real=Inf,
kind::VarKind=Continuous,
inc_val::Real=0.0,
is_active::Bool=true,
is_explicit::Bool=true,
branching_priority::Real=1.0,
# The moi index of the variable contains all the information to change its
# state in the formulation stores in the underlying MOI solver.
moi_index::MoiVarIndex=MoiVarIndex(),
# Coefficient of the variable in the constraints of the `form` formulation.
members::Union{ConstrMembership,Nothing}=nothing,
# Custom representation of the variable (advanced use).
custom_data::Union{Nothing,BD.AbstractCustomVarData}=nothing,
# Default id of the variable.
id=VarId(duty, form.env.var_counter += 1, getuid(form)),
# The formulation from which the variable is generated.
origin::Union{Nothing,Formulation}=nothing,
# By default, the name of the variable is `name`. However, when you do column
# generation, you may want to identify each variable without having to generate
# a new name for each variable. If you set this attribute to `true`, the name of
# the variable will be `name_uid`.
id_as_name_suffix=false,
)
# TODO: we should have a dedicated procedure for preprocessing.
if kind == Binary
lb = lb < 0.0 ? 0.0 : lb
ub = ub > 1.0 ? 1.0 : ub
end
origin_form_uid = origin !== nothing ? FormId(getuid(origin)) : nothing
custom_family_id = if custom_data !== nothing
Int8(form.manager.custom_families_id[typeof(custom_data)])
else
nothing
end
# When the keyword arguments of this `Id` constructor are equal to nothing, they
# retrieve their values from `id` (see the code of the constructor in vcids.jl).
id = VarId(
id; duty=duty, origin_form_uid=origin_form_uid,
custom_family_id=custom_family_id
)
if id_as_name_suffix
name = string(name, "_", getuid(id))
end
if isempty(name)
name = string("v_", getuid(id))
end
v_data = VarData(cost, lb, ub, kind, inc_val, is_active, is_explicit, false)
var = Variable(
id, name;
var_data=v_data,
moi_index=moi_index,
custom_data=custom_data,
branching_priority=branching_priority
)
_addvar!(form, var)
_setmembers!(form, var, members)
return var
end
function _addvar!(form::Formulation, var::Variable)
_addvar!(form.manager, var)
if isexplicit(form, var)
add!(form.buffer, getid(var))
end
return
end
_localartvarduty(::Formulation{DwMaster}) = MasterArtVar
_localartvarduty(::Formulation{BendersSp}) = BendSpSecondStageArtVar
function _addlocalartvar!(form::Formulation, constr::Constraint, abs_cost::Float64)
art_var_duty = _localartvarduty(form)
matrix = getcoefmatrix(form)
cost = (getobjsense(form) == MinSense ? 1.0 : -1.0) * abs_cost
constrid = getid(constr)
constrname = getname(form, constr)
constrsense = getperensense(form, constr)
if constrsense == Equal
name1 = string("local_pos_art_of_", constrname)
name2 = string("local_neg_art_of_", constrname)
var1 = setvar!(
form, name1, art_var_duty; cost=cost, lb=0.0, ub=Inf, kind=Continuous
)
var2 = setvar!(
form, name2, art_var_duty; cost=cost, lb=0.0, ub=Inf, kind=Continuous
)
push!(constr.art_var_ids, getid(var1))
push!(constr.art_var_ids, getid(var2))
matrix[constrid, getid(var1)] = 1.0
matrix[constrid, getid(var2)] = -1.0
else
name = string("local_art_of_", constrname)
var = setvar!(
form, name, art_var_duty; cost=cost, lb=0.0, ub=Inf, kind=Continuous
)
push!(constr.art_var_ids, getid(var))
if constrsense == Greater
matrix[constrid, getid(var)] = 1.0
elseif constrsense == Less
matrix[constrid, getid(var)] = -1.0
end
end
return
end
"""
setconstr!(
formulation, name, duty;
rhs = 0.0,
kind = Essential,
sense = Greater,
is_active = true,
is_explicit = true,
members = nothing,
loc_art_var_abs_cost = 0.0,
)
Create a new constraint that has name `name` and duty `duty` in the formulation `formulation`.
Following keyword arguments allow the user to set additional information about the new constraint :
- `rhs`: right-hand side of the constraint
- `kind`: kind which can be `Essential` or `Facultative`
- `sense`: sense which can be `Greater`, `Less`, or `Equal`
- `is_active`: `true` if the constraint is used in the formulation, `false` otherwise
- `is_explicit`: `true` if the constraint structures the formulation, `false` otherwise
- `members`: a dictionary `Dict{VarId, Float64}` that contains the coefficients of the variables of the formulation in the new constraint (default coefficient is 0).
- `loc_art_var_abs_cost`: absolute cost of the artificial variables of the constraint
"""
function setconstr!(
form::Formulation,
name::String,
duty::Duty{Constraint};
rhs::Real=0.0,
kind::ConstrKind=Essential,
sense::ConstrSense=Greater,
inc_val::Real=0.0,
is_active::Bool=true,
is_explicit::Bool=true,
moi_index::MoiConstrIndex=MoiConstrIndex(),
members=nothing, # todo Union{AbstractDict{VarId,Float64},Nothing}
loc_art_var_abs_cost::Real=0.0,
custom_data::Union{Nothing,BD.AbstractCustomConstrData}=nothing,
id=ConstrId(duty, form.env.constr_counter += 1, getuid(form))
)
if getduty(id) != duty
id = ConstrId(id, duty=duty)
end
if isempty(name)
name = string("c_", getuid(id))
end
if custom_data !== nothing
id = ConstrId(
id,
custom_family_id=form.manager.custom_families_id[typeof(custom_data)]
)
end
c_data = ConstrData(rhs, kind, sense, inc_val, is_active, is_explicit)
constr = Constraint(id, name; constr_data=c_data, moi_index=moi_index, custom_data=custom_data)
_setmembers!(form, constr, members)
_addconstr!(form.manager, constr)
if loc_art_var_abs_cost != 0.0
_addlocalartvar!(form, constr, loc_art_var_abs_cost)
end
if isexplicit(form, constr)
add!(form.buffer, getid(constr))
end
return constr
end
"""
enforce_integrality!(formulation)
Set the current kind of each active & explicit variable of the formulation to its perennial kind.
"""
function enforce_integrality!(form::Formulation)
for (_, var) in getvars(form)
enforce = iscuractive(form, var) && isexplicit(form, var)
enforce &= getcurkind(form, var) === Continuous
enforce &= getperenkind(form, var) !== Continuous
if enforce
setcurkind!(form, var, getperenkind(form, var))
end
end
return
end
"""
relax_integrality!(formulation)
Set the current kind of each active & explicit integer or binary variable of the formulation
to continuous.
"""
function relax_integrality!(form::Formulation)
for (_, var) in getvars(form)
relax = iscuractive(form, var) && isexplicit(form, var)
relax &= getcurkind(form, var) !== Continuous
if relax
setcurkind!(form, var, Continuous)
end
end
return
end
function push_optimizer!(form::Formulation, builder::Function)
opt = builder()
push!(form.optimizers, opt)
initialize_optimizer!(opt, form)
return
end
############################################################################################
############################################################################################
# Methods specific to a Formulation with DwSp duty
############################################################################################
############################################################################################
get_primal_sol_pool(form::Formulation{DwSp}) = form.duty_data.pool
get_dual_sol_pool(form::Formulation{BendersSp}) = form.duty_data.pool
function initialize_solution_pool!(form::Formulation{DwSp}, initial_columns_callback::Function)
master = getmaster(form)
cbdata = InitialColumnsCallbackData(form, PrimalSolution[])
initial_columns_callback(cbdata)
for sol in cbdata.primal_solutions
insert_column!(master, sol, "iMC")
end
return
end
############################################################################################
# Insertion of a column in the master
############################################################################################
# Compute all the coefficients of the column in the coefficient matrix of the
# master formulation.
function _col_members(col, master_coef_matrix)
members = Dict{ConstrId,Float64}()
for (sp_var_id, sp_var_val) in col
for (master_constrid, sp_var_coef) in @view master_coef_matrix[:, sp_var_id]
val = get(members, master_constrid, 0.0)
members[master_constrid] = val + sp_var_val * sp_var_coef
end
end
return members
end
"""
get_column_from_pool(primal_sol)
Returns the `var_id` of the master column that represents the primal solution `primal_sol`
to a Dantzig-Wolfe subproblem if the primal solution exists in the pool of solutions to the
subproblem; `nothing` otherwise.
"""
function get_column_from_pool(primal_sol::PrimalSolution{Formulation{DwSp}})
spform = primal_sol.solution.model
pool = get_primal_sol_pool(spform)
return get_from_pool(pool, primal_sol)
end
"""
insert_column!(master_form, primal_sol, name)
Inserts the primal solution `primal_sol` to a Dantzig-Wolfe subproblem into the
master as a column.
Returns `var_id` the id of the column variable in the master formulation.
**Warning**: this methods does not check if the column already exists in the pool.
"""
function insert_column!(
master_form::Formulation{DwMaster}, primal_sol::PrimalSolution, name::String;
lb::Float64=0.0,
ub::Float64=Inf,
inc_val::Float64=0.0,
is_active::Bool=true,
is_explicit::Bool=true,
store_in_sp_pool=true,
id_as_name_suffix=true
)
spform = primal_sol.solution.model
# Compute perennial cost of the column.
new_col_peren_cost = mapreduce(
((var_id, var_val),) -> getperencost(spform, var_id) * var_val,
+,
primal_sol
)
# Compute coefficient members of the column in the matrix.
members = _col_members(primal_sol, getcoefmatrix(master_form))
branching_priority::Float64 = if BD.branchingpriority(primal_sol.custom_data) !== nothing
BD.branchingpriority(primal_sol.custom_data)
else
spform.duty_data.branching_priority
end
# Insert the column in the master.
col = setvar!(
master_form, name, MasterCol,
cost=new_col_peren_cost,
lb=lb,
ub=ub,
kind=spform.duty_data.column_var_kind,
inc_val=inc_val,
is_active=is_active,
is_explicit=is_explicit,
branching_priority=branching_priority,
moi_index=MoiVarIndex(),
members=members,
custom_data=primal_sol.custom_data,
id_as_name_suffix=id_as_name_suffix,
origin=spform
)
setcurkind!(master_form, col, Continuous)
# Store the solution in the pool if asked.
if store_in_sp_pool
pool = get_primal_sol_pool(spform)
col_id = VarId(getid(col); duty=DwSpPrimalSol)
push_in_pool!(pool, primal_sol, col_id, new_col_peren_cost)
end
return getid(col)
end
############################################################################################
function set_robust_constr_generator!(form::Formulation, kind::ConstrKind, alg::Function)
constrgen = RobustConstraintsGenerator(0, kind, alg)
push!(form.manager.robust_constr_generators, constrgen)
return
end
get_robust_constr_generators(form::Formulation) = form.manager.robust_constr_generators
function set_objective_sense!(form::Formulation, min::Bool)
if min
form.obj_sense = MinSense
else
form.obj_sense = MaxSense
end
form.buffer.changed_obj_sense = true
return
end
function constraint_primal(primalsol::PrimalSolution, constrid::ConstrId)
val = 0.0
for (varid, coeff) in @view getcoefmatrix(getmodel(primalsol))[constrid, :]
val += coeff * primalsol[varid]
end
return val
end
############################################################################################
############################################################################################
# Methods to show a formulation
############################################################################################
############################################################################################
function _show_obj_fun(io::IO, form::Formulation, user_only::Bool=false)
print(io, getobjsense(form), " ")
vars = filter(v -> isexplicit(form, v.first), getvars(form))
ids = sort!(collect(keys(vars)), by=getsortuid)
for id in ids
user_only && isaNonUserDefinedDuty(getduty(id)) && continue
name = getname(form, vars[id])
cost = getcurcost(form, id)
cost == 0.0 && continue
op = (cost < 0.0) ? "-" : "+"
print(io, op, " ", abs(cost), " ", name, " ")
end
if !iszero(getobjconst(form))
op = (getobjconst(form) < 0.0) ? "-" : "+"
print(io, op, " ", abs(getobjconst(form)))
end
println(io, " ")
return
end
function _show_constraint(io::IO, form::Formulation, constrid::ConstrId, user_only::Bool=false)
constr = getconstr(form, constrid)
print(io, getname(form, constr), " : ")
for (varid, coeff) in getcoefmatrix(form)[constrid, :]
user_only && isaNonUserDefinedDuty(getduty(varid)) && continue
!iscuractive(form, varid) && continue
name = getname(form, varid)
op = (coeff < 0.0) ? "-" : "+"
print(io, op, " ", abs(coeff), " ", name, " ")
end
op = "<="
if getcursense(form, constr) == Equal
op = "=="
elseif getcursense(form, constr) == Greater
op = ">="
end
print(io, " ", op, " ", getcurrhs(form, constr))
println(io, " (", getduty(constrid), " | ", isexplicit(form, constr), ")")
return
end
function _show_constraints(io::IO, form::Formulation, user_only::Bool=false)
constrs = getconstrs(form)
ids = sort!(collect(keys(constrs)), by=getsortuid)
for constr_id in ids
user_only && isaNonUserDefinedDuty(getduty(constr_id)) && continue
if iscuractive(form, constr_id)
_show_constraint(io, form, constr_id, user_only)
end
end
return
end
function _show_variable(io::IO, form::Formulation, var::Variable)
name = getname(form, var)
lb = getcurlb(form, var)
ub = getcurub(form, var)
t = getcurkind(form, var)
d = getduty(getid(var))
e = isexplicit(form, var)
println(io, lb, " <= ", name, " <= ", ub, " (", t, " | ", d, " | ", e, ")")
end
function _show_variables(io::IO, form::Formulation, user_only::Bool=false)
vars = getvars(form)
ids = sort!(collect(keys(vars)), by=getsortuid)
for varid in ids
user_only && isaNonUserDefinedDuty(getduty(varid)) && continue
_show_variable(io, form, vars[varid])
end
end
function _show_partial_sol(io::IO, form::Formulation, user_only::Bool=false)
isempty(form.manager.partial_solution) && return
println(io, "Partial solution:")
for (varid, val) in form.manager.partial_solution
if user_only && isaNonUserDefinedDuty(getduty(varid))
if getduty(varid) <= MasterCol
print(io, getname(form, varid), " = [")
origin_form_uid = getoriginformuid(varid)
spform = get_dw_pricing_sps(getparent(form))[origin_form_uid]
spsol = @view get_primal_sol_pool(spform).solutions[varid, :]
for (sp_var_id, value) in spsol
isaNonUserDefinedDuty(getduty(sp_var_id)) && continue
print(io, getname(spform, sp_var_id), " = ", value, " ")
end
println(io, "] = ", val)
end
else
println(io, getname(form, varid), " = ", val)
end
end
return
end
function Base.show(io::IO, form::Formulation{Duty}) where {Duty<:AbstractFormDuty}
compact = get(io, :compact, false)
dutystring = remove_until_last_point(string(Duty))
if compact
print(io, "form. ", dutystring, " with id=", getuid(form))
else
user_only = get(io, :user_only, false)
println(io, "Formulation $dutystring id = ", getuid(form))
if user_only && isa(form.duty_data, DwSp)
lm = round(Int, getcurrhs(getparent(form), form.duty_data.lower_multiplicity_constr_id))
um = round(Int, getcurrhs(getparent(form), form.duty_data.upper_multiplicity_constr_id))
println(io, "Multiplicities: lower = $lm, upper = $um")
end
_show_obj_fun(io, form, user_only)
_show_constraints(io, form, user_only)
_show_variables(io, form, user_only)
_show_partial_sol(io, form, user_only)
end
return
end
| Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 4944 | const VarMembership = Dict{VarId, Float64}
const ConstrMembership = Dict{ConstrId, Float64}
const ConstrConstrMatrix = DynamicSparseArrays.DynamicSparseMatrix{ConstrId,ConstrId,Float64}
const VarConstrDualSolMatrix = DynamicSparseArrays.DynamicSparseMatrix{VarId,ConstrId,Tuple{Float64,ActiveBound}}
const VarVarMatrix = DynamicSparseArrays.DynamicSparseMatrix{VarId,VarId,Float64}
# Define the semaphore of the dynamic sparse matrix using MathProg.Id as index
DynamicSparseArrays.semaphore_key(I::Type{Id{VC}}) where VC = I(Duty{VC}(0), -1, -1, -1, -1)
# We wrap the coefficient matrix because we need to buffer the changes.
struct CoefficientMatrix{C,V,T}
matrix::DynamicSparseArrays.DynamicSparseMatrix{C,V,T}
buffer::FormulationBuffer
end
function CoefficientMatrix{C,V,T}(buffer) where {C,V,T}
return CoefficientMatrix{C,V,T}(dynamicsparse(C,V,T), buffer)
end
const ConstrVarMatrix = CoefficientMatrix{ConstrId,VarId,Float64}
function Base.setindex!(m::CoefficientMatrix{C,V,T}, val, row::C, col::V) where {C,V,T}
setindex!(m.matrix, val, row, col)
if row ∉ m.buffer.constr_buffer.added && col ∉ m.buffer.var_buffer.added
change_matrix_coeff!(m.buffer, row, col, val)
end
return
end
function Base.getindex(m::CoefficientMatrix{C,V,T}, row, col) where {C,V,T}
return getindex(m.matrix, row, col)
end
DynamicSparseArrays.closefillmode!(m::CoefficientMatrix) = closefillmode!(m.matrix)
Base.view(m::CoefficientMatrix{C,V,T}, row::C, ::Colon) where {C,V,T} = view(m.matrix, row, :)
Base.view(m::CoefficientMatrix{C,V,T}, ::Colon, col::V) where {C,V,T} = view(m.matrix, :, col)
Base.transpose(m::CoefficientMatrix) = transpose(m.matrix)
# The formulation manager is an internal data structure that contains & manager
# all the elements which constitute a MILP formulation: variables, constraints,
# objective constant (costs stored in variables), coefficient matrix,
# cut generators (that contain cut callbacks)...
mutable struct FormulationManager
vars::Dict{VarId, Variable}
constrs::Dict{ConstrId, Constraint}
coefficients::ConstrVarMatrix # rows = constraints, cols = variables
objective_constant::Float64
# The partial solution is a lower bound on the absolute value of the variables in the solution.
# When the variable is positive, we remove this fixed part from the formulation and treat the variable like a classic
# non-negative one (>= 0).
# When the variable is negative, we remove this fixed part form the formulation and treat the variable as
# a non-positive one (<= 0).
# When the variable has negative lower bound and positive upper bound, we treat it as a
# non-negative (non-positive) one if the partial solution is positive (negative).
# When the bounds of the variable are [0, 0], the variable is deactivated (not in the formulation anymore).
# Cost of the partial solution is not stored in objective constant.
partial_solution::Dict{VarId, Float64}
robust_constr_generators::Vector{RobustConstraintsGenerator}
custom_families_id::Dict{DataType,Int}
end
function FormulationManager(buffer; custom_families_id = Dict{DataType,Int}())
vars = Dict{VarId, Variable}()
constrs = Dict{ConstrId, Constraint}()
return FormulationManager(
vars,
constrs,
ConstrVarMatrix(buffer),
0.0,
Dict{VarId, Float64}(),
RobustConstraintsGenerator[],
custom_families_id
)
end
# Internal method to store a Variable in the formulation manager.
function _addvar!(m::FormulationManager, var::Variable)
if haskey(m.vars, var.id)
error(string(
"Variable of id ", var.id, " exists. Its name is ", m.vars[var.id].name,
" and you want to add a variable named ", var.name, "."
))
end
m.vars[var.id] = var
return
end
# Internal method to fix a variable in the formulation manager.
function _add_partial_value!(m::FormulationManager, var::Variable, value)
partial_value = get(m.partial_solution, var.id, 0.0)
new_value = partial_value + value
_set_partial_value!(m, var, new_value)
end
function _set_partial_value!(m::FormulationManager, var::Variable, value)
if abs(value) <= Coluna.TOL
var.curdata.is_in_partial_sol = false
delete!(m.partial_solution, var.id)
else
var.curdata.is_in_partial_sol = true
m.partial_solution[var.id] = value
end
return value
end
_partial_sol(m::FormulationManager) = m.partial_solution
# Internal methods to store a Constraint in the formulation manager.
function _addconstr!(m::FormulationManager, constr::Constraint)
if haskey(m.constrs, constr.id)
error(string(
"Constraint of id ", constr.id, " exists. Its name is ", m.constrs[constr.id].name,
" and you want to add a constraint named ", constr.name, "."
))
end
m.constrs[constr.id] = constr
return
end
| Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 6177 | """
NoOptimizer <: AbstractOptimizer
Wrapper when no optimizer is assigned to a formulation.
Basic algorithms that call an optimizer to optimize a formulation won't work.
"""
struct NoOptimizer <: AbstractOptimizer end
no_optimizer_builder(args...) = NoOptimizer()
"""
UserOptimizer <: AbstractOptimizer
Wrap a julia function that acts like the optimizer of a formulation.
It is for example the function used as a pricing callback.
"""
mutable struct UserOptimizer <: AbstractOptimizer
user_oracle::Function
end
mutable struct PricingCallbackData
form::Formulation
primal_solutions::Vector{PrimalSolution}
nb_times_dual_bound_set::Int
dual_bound::Union{Nothing, Float64}
end
function PricingCallbackData(form::F) where {F<:Formulation}
return PricingCallbackData(form, PrimalSolution{F}[], 0, nothing)
end
"""
MoiOptimizer <: AbstractOptimizer
Wrapper that is used when the optimizer of a formulation
is an `MOI.AbstractOptimizer`, thus inheriting MOI functionalities.
"""
struct MoiOptimizer <: AbstractOptimizer
inner::MOI.ModelLike
end
getinner(optimizer::MoiOptimizer) = optimizer.inner
function sync_solver!(optimizer::MoiOptimizer, f::Formulation)
buffer = f.buffer
matrix = getcoefmatrix(f)
# Remove constrs
@logmsg LogLevel(-2) string("Removing constraints")
remove_from_optimizer!(f, optimizer, buffer.constr_buffer.removed)
# Remove vars
@logmsg LogLevel(-2) string("Removing variables")
remove_from_optimizer!(f, optimizer, buffer.var_buffer.removed)
# Add vars
for id in buffer.var_buffer.added
v = getvar(f, id)
if isnothing(v)
error("Sync_solver: var $id is not in formulation.")
else
add_to_optimizer!(f, optimizer, v)
end
end
# Add constrs
for constr_id in buffer.constr_buffer.added
constr = getconstr(f, constr_id)
if isnothing(constr)
error("Sync_solver: constr $constr_id is not in formulation.")
else
add_to_optimizer!(f, optimizer, constr, (f, var) -> iscuractive(f, var) && isexplicit(f, var))
end
end
# Update variable costs
# TODO: Pass a new objective function if too many changes
for id in buffer.changed_cost
(id in buffer.var_buffer.added || id in buffer.var_buffer.removed) && continue
v = getvar(f, id)
if isnothing(v)
error("Sync_solver: var $id is not in formulation.")
else
update_cost_in_optimizer!(f, optimizer, v)
end
end
# Update objective sense
if buffer.changed_obj_sense
set_obj_sense!(optimizer, getobjsense(f))
buffer.changed_obj_sense = false
end
# Update variable bounds
for id in buffer.changed_bound
(id in buffer.var_buffer.added || id in buffer.var_buffer.removed) && continue
v = getvar(f, id)
if isnothing(v)
error("Sync_solver: var $id is not in formulation.")
else
update_bounds_in_optimizer!(f, optimizer, v)
end
end
# Update variable kind
for id in buffer.changed_var_kind
(id in buffer.var_buffer.added || id in buffer.var_buffer.removed) && continue
v = getvar(f, id)
if isnothing(v)
error("Sync_solver: var $id is not in formulation.")
else
enforce_kind_in_optimizer!(f, optimizer, v)
end
end
# Update constraint rhs
for id in buffer.changed_rhs
(id in buffer.constr_buffer.added || id in buffer.constr_buffer.removed) && continue
constr = getconstr(f, id)
if isnothing(constr)
error("Sync_solver: constr $id is not in formulation.")
else
update_constr_rhs_in_optimizer!(f, optimizer, constr)
end
end
# Update matrix
# First check if should update members of just-added vars
matrix = getcoefmatrix(f)
for v_id in buffer.var_buffer.added
for (c_id, coeff) in @view matrix[:,v_id]
iscuractive(f, c_id) || continue
isexplicit(f, c_id) || continue
c_id ∉ buffer.constr_buffer.added || continue
c = getconstr(f, c_id)
v = getvar(f, v_id)
if isnothing(c)
error("Sync_solver: constr $c_id is not in formulation.")
elseif isnothing(v)
error("Sync_solver: var $v_id is not in formulation.")
else
update_constr_member_in_optimizer!(optimizer, c, v, coeff)
end
end
end
# Then updated the rest of the matrix coeffs
for ((c_id, v_id), coeff) in buffer.reset_coeffs
# Ignore modifications involving vc's that were removed
(c_id in buffer.constr_buffer.removed || v_id in buffer.var_buffer.removed) && continue
iscuractive(f, c_id) && isexplicit(f, c_id) || continue
iscuractive(f, v_id) && isexplicit(f, v_id) || continue
c = getconstr(f, c_id)
v = getvar(f, v_id)
if isnothing(c)
error("Sync_solver: constr $c_id is not in formulation.")
elseif isnothing(v)
error("Sync_solver: var $v_id is not in formulation.")
else
update_constr_member_in_optimizer!(optimizer, c, v, coeff)
end
end
empty!(buffer)
return
end
# Initialization of optimizers
function initialize_optimizer!(optimizer::MoiOptimizer, form::Formulation)
f = MOI.ScalarAffineFunction(MOI.ScalarAffineTerm{Float64}[], 0.0)
MOI.set(optimizer.inner, MoiObjective(), f)
set_obj_sense!(optimizer, getobjsense(form))
return
end
initialize_optimizer!(optimizer, form::Formulation) = return
function write_to_LP_file(form::Formulation, optimizer::MoiOptimizer, filename::String)
src = getinner(optimizer)
dest = MOI.FileFormats.Model(format = MOI.FileFormats.FORMAT_LP)
MOI.copy_to(dest, src)
MOI.write_to_file(dest, filename)
end
"""
CustomOptimizer <: AbstractOptimizer
Undocumented because alpha.
"""
struct CustomOptimizer <: AbstractOptimizer
inner::BD.AbstractCustomOptimizer
end
getinner(optimizer::CustomOptimizer) = optimizer.inner
| Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 5892 | abstract type AbstractPool end
############################################################################################
# Primal Solution Pool
############################################################################################
struct Pool <: AbstractPool
solutions::DynamicSparseArrays.DynamicSparseMatrix{VarId,VarId,Float64}
solutions_hash::ColunaBase.HashTable{VarId,VarId}
costs::Dict{VarId,Float64}
custom_data::Dict{VarId,BD.AbstractCustomVarData}
end
function Pool()
return Pool(
DynamicSparseArrays.dynamicsparse(VarId, VarId, Float64; fill_mode = false),
ColunaBase.HashTable{VarId, VarId}(),
Dict{VarId, Float64}(),
Dict{VarId, BD.AbstractCustomVarData}()
)
end
# Returns nothing if there is no identical solutions in pool; the id of the
# identical solution otherwise.
function _get_same_sol_in_pool(solutions, hashtable, sol)
sols_with_same_members = ColunaBase.getsolids(hashtable, sol)
for existing_sol_id in sols_with_same_members
existing_sol = @view solutions[existing_sol_id,:]
if existing_sol == sol
return existing_sol_id
end
end
return nothing
end
# We only keep variables that have certain duty in the representation of the
# solution stored in the pool. The second argument allows us to dispatch because
# filter may change depending on the duty of the formulation.
function _sol_repr_for_pool(primal_sol::PrimalSolution)
var_ids = VarId[]
vals = Float64[]
for (var_id, val) in primal_sol
if getduty(var_id) <= DwSpSetupVar || getduty(var_id) <= DwSpPricingVar
push!(var_ids, var_id)
push!(vals, val)
end
end
return var_ids, vals
end
_same_active_bounds(pool::Pool, existing_sol_id, solution::PrimalSolution) = true
"""
same_custom_data(custom_data1, custom_data2) -> Bool
Returns `true`if the custom data are the same, false otherwise.
"""
same_custom_data(custom_data1, custom_data2) = custom_data1 == custom_data2
function get_from_pool(pool::AbstractPool, solution)
existing_sol_id = _get_same_sol_in_pool(pool.solutions, pool.solutions_hash, solution)
if isnothing(existing_sol_id)
return nothing
end
# If it's a pool of dual solution, we must check if the active bounds are the same.
if !isnothing(existing_sol_id) && !_same_active_bounds(pool, existing_sol_id, solution)
return nothing
end
# When there are non-robust cuts, Coluna has not enough information to identify that two
# columns are identical. The columns may be mapped into the same original variables but
# be internally different, meaning that the coefficients of non-robust cuts to be added
# in the future may differ. This is why we need to check custom data.
custom_data1 = get(pool.custom_data, existing_sol_id, nothing)
custom_data2 = solution.custom_data
if same_custom_data(custom_data1, custom_data2)
return existing_sol_id
end
return nothing
end
function push_in_pool!(pool::Pool, solution::PrimalSolution, sol_id, cost)
var_ids, vals = _sol_repr_for_pool(solution)
DynamicSparseArrays.addrow!(pool.solutions, sol_id, var_ids, vals)
pool.costs[sol_id] = cost
if !isnothing(solution.custom_data)
pool.custom_data[sol_id] = solution.custom_data
end
ColunaBase.savesolid!(pool.solutions_hash, sol_id, solution)
return true
end
############################################################################################
# Dual Solution Pool
############################################################################################
struct DualSolutionPool <: AbstractPool
solutions::DynamicSparseArrays.DynamicSparseMatrix{ConstrId,ConstrId,Float64}
solutions_hash::ColunaBase.HashTable{ConstrId,ConstrId}
solutions_active_bounds::Dict{ConstrId,Dict{VarId,Tuple{Float64,ActiveBound}}}
costs::Dict{ConstrId,Float64}
custom_data::Dict{ConstrId,BD.AbstractCustomConstrData}
end
function DualSolutionPool()
return DualSolutionPool(
DynamicSparseArrays.dynamicsparse(ConstrId, ConstrId, Float64; fill_mode = false),
ColunaBase.HashTable{ConstrId, ConstrId}(),
Dict{ConstrId, Tuple{ActiveBound,Float64}}(),
Dict{ConstrId, Float64}(),
Dict{ConstrId, BD.AbstractCustomConstrData}()
)
end
function _same_active_bounds(pool::DualSolutionPool, existing_sol_id, solution::DualSolution)
existing_active_bounds = pool.solutions_active_bounds[existing_sol_id]
existing_var_ids = keys(existing_active_bounds)
var_ids = keys(get_var_redcosts(solution))
if length(union(existing_var_ids, var_ids)) != length(var_ids)
return false
end
for (varid, (val, bnd)) in get_var_redcosts(solution)
if !isnothing(get(existing_active_bounds, varid, nothing))
if existing_active_bounds[varid][1] != val || existing_active_bounds[varid][2] != bnd
return false
end
else
return false
end
end
return true
end
function _sol_repr_for_pool(dual_sol::DualSolution)
constr_ids = ConstrId[]
vals = Float64[]
for (constr_id, val) in dual_sol
if getduty(constr_id) <= BendSpSepVar
push!(constr_ids, constr_id)
push!(vals, val)
end
end
return constr_ids, vals
end
function push_in_pool!(pool::DualSolutionPool, solution::DualSolution, sol_id, cost)
constr_ids, vals = _sol_repr_for_pool(solution)
DynamicSparseArrays.addrow!(pool.solutions, sol_id, constr_ids, vals)
pool.costs[sol_id] = cost
pool.solutions_active_bounds[sol_id] = get_var_redcosts(solution)
if !isnothing(solution.custom_data)
pool.custom_data[sol_id] = solution.custom_data
end
ColunaBase.savesolid!(pool.solutions_hash, sol_id, solution)
return true
end | Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 2528 | mutable struct Problem <: AbstractProblem
initial_primal_bound::Union{Nothing, Float64}
initial_dual_bound::Union{Nothing, Float64}
original_formulation::Formulation
re_formulation::Union{Nothing, Reformulation}
default_optimizer_builder::Function
initial_columns_callback::Union{Nothing, Function}
end
"""
Problem(env)
Constructs an empty `Problem`.
"""
function Problem(env)
original_formulation = create_formulation!(env, Original())
return Problem(
nothing, nothing, original_formulation, nothing,
no_optimizer_builder, nothing
)
end
set_original_formulation!(m::Problem, of::Formulation) = m.original_formulation = of
set_reformulation!(m::Problem, r::Reformulation) = m.re_formulation = r
get_original_formulation(m::Problem) = m.original_formulation
get_reformulation(m::Problem) = m.re_formulation
set_default_optimizer_builder!(p::Problem, default_opt_builder) = p.default_optimizer_builder = default_opt_builder
set_initial_primal_bound!(p::Problem, value::Real) = p.initial_primal_bound = value
set_initial_dual_bound!(p::Problem, value::Real) = p.initial_dual_bound = value
function get_initial_primal_bound(p::Problem)
if isnothing(p.original_formulation)
error("Cannot retrieve initial primal bound because the problem does not have original formulation.")
end
min = getobjsense(get_original_formulation(p)) == MinSense
if !isnothing(p.initial_primal_bound)
return ColunaBase.Bound(min, true, p.initial_primal_bound)
end
return ColunaBase.Bound(min, true)
end
function get_initial_dual_bound(p::Problem)
if isnothing(p.original_formulation)
error("Cannot retrieve initial dual bound because the problem does not have original formulation.")
end
min = getobjsense(get_original_formulation(p)) == MinSense
if !isnothing(p.initial_dual_bound)
return ColunaBase.Bound(min, false, p.initial_dual_bound)
end
return ColunaBase.Bound(min, false)
end
"""
If the original formulation is not reformulated, it means that the user did not
provide a way to decompose the model. In such a case, Coluna will call the
subsolver to optimize the original formulation.
"""
function get_optimization_target(p::Problem)
if p.re_formulation === nothing
return p.original_formulation
end
return p.re_formulation
end
function _register_initcols_callback!(problem::Problem, callback_function::Function)
problem.initial_columns_callback = callback_function
return
end | Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 7040 | "Returns `true` if we can project a solution of `form` to the original formulation."
projection_is_possible(form) = false
############################################################################################
# Projection of Dantzig-Wolfe master on original formulation.
############################################################################################
projection_is_possible(master::Formulation{DwMaster}) = true
Base.isless(A::DynamicMatrixColView{VarId,VarId,Float64}, B::DynamicMatrixColView{VarId,VarId,Float64}) = cmp(A, B) < 0
function Base.cmp(A::DynamicMatrixColView{VarId,VarId,Float64}, B::DynamicMatrixColView{VarId,VarId,Float64})
for (a, b) in zip(A, B)
if !isequal(a, b)
return isless(a, b) ? -1 : 1
end
end
return 0 # no length for dynamic sparse vectors
end
function _assign_width!(cur_roll, col::Vector, width_to_assign)
for i in 1:length(col)
cur_roll[i] += col[i] * width_to_assign
end
return
end
function _assign_width!(cur_roll::Dict, col::DynamicMatrixColView, width_to_assign)
for (id, val) in col
if !haskey(cur_roll, id)
cur_roll[id] = 0.0
end
cur_roll[id] += val * width_to_assign
end
return
end
_new_set_of_rolls(::Type{Vector{E}}) where {E} = Vector{Float64}[]
_new_roll(::Type{Vector{E}}, col_len) where {E} = zeros(Float64, col_len)
_roll_is_integer(roll::Vector{Float64}) = all(map(r -> abs(r - round(r)) <= Coluna.DEF_OPTIMALITY_ATOL, roll))
_new_set_of_rolls(::Type{DynamicMatrixColView{VarId,VarId,Float64}}) = Dict{VarId,Float64}[]
_new_roll(::Type{DynamicMatrixColView{VarId,VarId,Float64}}, _) = Dict{VarId,Float64}()
_roll_is_integer(roll::Dict{VarId,Float64}) = all(map(r -> abs(r - round(r)) <= Coluna.DEF_OPTIMALITY_ATOL, values(roll)))
function _mapping(columns::Vector{A}, values::Vector{B}; col_len::Int=10) where {A,B}
p = sortperm(columns, rev=true)
columns = columns[p]
values = values[p]
rolls = _new_set_of_rolls(eltype(columns))
total_width_assigned = 0
nb_roll_opened = 1 # roll is width 1
cur_roll = _new_roll(eltype(columns), col_len)
for (val, col) in zip(values, columns)
cur_unassigned_width = val
while cur_unassigned_width > 0
width_to_assign = min(cur_unassigned_width, nb_roll_opened - total_width_assigned)
_assign_width!(cur_roll, col, width_to_assign)
cur_unassigned_width -= width_to_assign
total_width_assigned += width_to_assign
if total_width_assigned == nb_roll_opened
push!(rolls, cur_roll)
cur_roll = _new_roll(eltype(columns), col_len)
nb_roll_opened += 1
end
end
end
return rolls
end
function _mapping_by_subproblem(columns::Dict{Int,Vector{A}}, values::Dict{Int,Vector{B}}) where {A,B}
return Dict(
uid => _mapping(cols, values[uid]) for (uid, cols) in columns
)
end
_rolls_are_integer(rolls) = all(_roll_is_integer.(rolls))
_subproblem_rolls_are_integer(rolls_by_sp::Dict) = all(_rolls_are_integer.(values(rolls_by_sp)))
# removes information about continuous variables from rolls, as this information should be ignored when checking integrality
function _remove_continuous_vars_from_rolls!(rolls_by_sp::Dict, reform::Reformulation)
for (uid, rolls) in rolls_by_sp
spform = get_dw_pricing_sps(reform)[uid]
for roll in rolls
filter!(pair -> getcurkind(spform, pair.first) != Continuous, roll)
end
end
end
function _extract_data_for_mapping(sol::PrimalSolution{Formulation{DwMaster}})
columns = Dict{Int,Vector{DynamicMatrixColView{VarId,VarId,Float64}}}()
values = Dict{Int,Vector{Float64}}()
master = getmodel(sol)
reform = getparent(master)
if isnothing(reform)
error("Projection: master have the reformulation as parent formulation.")
end
dw_pricing_sps = get_dw_pricing_sps(reform)
for (varid, val) in sol
duty = getduty(varid)
if duty <= MasterCol
origin_form_uid = getoriginformuid(varid)
spform = get(dw_pricing_sps, origin_form_uid, nothing)
if isnothing(spform)
error("Projection: cannot retrieve Dantzig-Wolfe pricing subproblem with uid $origin_form_uid")
end
column = @view get_primal_sol_pool(spform).solutions[varid, :]
if !haskey(columns, origin_form_uid)
columns[origin_form_uid] = DynamicMatrixColView{VarId,VarId,Float64}[]
values[origin_form_uid] = Float64[]
end
push!(columns[origin_form_uid], column)
push!(values[origin_form_uid], val)
end
end
return columns, values
end
function _proj_cols_on_rep(sol::PrimalSolution{Formulation{DwMaster}}, extracted_cols, extracted_vals)
projected_sol_vars = VarId[]
projected_sol_vals = Float64[]
for (varid, val) in sol
duty = getduty(varid)
if duty <= MasterPureVar
push!(projected_sol_vars, varid)
push!(projected_sol_vals, val)
end
end
master = getmodel(sol)
for spid in keys(extracted_cols)
for (column, val) in Iterators.zip(extracted_cols[spid], extracted_vals[spid])
for (repid, repval) in column
if getduty(repid) <= DwSpPricingVar || getduty(repid) <= DwSpSetupVar ||
getduty(repid) <= MasterRepPricingVar || getduty(repid) <= MasterRepPricingSetupVar
mastrepvar = getvar(master, repid)
@assert !isnothing(mastrepvar)
mastrepid = getid(mastrepvar)
push!(projected_sol_vars, mastrepid)
push!(projected_sol_vals, repval * val)
end
end
end
end
return PrimalSolution(master, projected_sol_vars, projected_sol_vals, getvalue(sol), FEASIBLE_SOL)
end
function proj_cols_on_rep(sol::PrimalSolution{Formulation{DwMaster}})
columns, values = _extract_data_for_mapping(sol)
projected_sol = _proj_cols_on_rep(sol, columns, values)
return projected_sol
end
function proj_cols_is_integer(sol::PrimalSolution{Formulation{DwMaster}})
columns, values = _extract_data_for_mapping(sol)
projected_sol = _proj_cols_on_rep(sol, columns, values)
rolls = _mapping_by_subproblem(columns, values)
reform = getparent(getmodel(sol))
_remove_continuous_vars_from_rolls!(rolls, reform)
integer_rolls = _subproblem_rolls_are_integer(rolls)
return isinteger(projected_sol) && integer_rolls
end
############################################################################################
# Projection of Benders master on original formulation.
############################################################################################
projection_is_possible(master::Formulation{BendersMaster}) = false
function proj_cols_on_rep(sol::PrimalSolution{Formulation{BendersMaster}})
return sol
end
| Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 5480 | # TODO make immutable
mutable struct Reformulation{MasterDuty} <: AbstractFormulation
uid::Int
parent::Formulation{Original} # reference to (pointer to) ancestor: Formulation or Reformulation (TODO rm Nothing)
master::Formulation{MasterDuty}
dw_pricing_subprs::Dict{FormId,Formulation{DwSp}}
benders_sep_subprs::Dict{FormId,Formulation{BendersSp}}
storage::Union{Nothing,Storage}
end
"""
`Reformulation` is a representation of a formulation which is solved by Coluna
using a decomposition approach.
Reformulation(env, parent, master, dw_pricing_subprs, benders_sep_subprs)
Constructs a `Reformulation` where:
- `env` is the Coluna environment;
- `parent` is the parent formulation (a `Formulation` or a `Reformulation`) (original
formulation for the classic decomposition);
- `master` is the formulation of the master problem;
- `dw_pricing_subprs` is a `Dict{FormId, Formulation}` containing all Dantzig-Wolfe pricing
subproblems of the reformulation;
- `benders_sep_subprs` is a `Dict{FormId, Formulation}` containing all Benders separation
subproblems of the reformulation.
"""
function Reformulation(env, parent, master, dw_pricing_subprs, benders_sep_subprs)
uid = env.form_counter += 1
reform = Reformulation(
uid,
parent,
master,
dw_pricing_subprs,
benders_sep_subprs,
nothing
)
reform.storage = Storage(reform)
return reform
end
# methods of the AbstractModel interface
ClB.getuid(reform::Reformulation) = reform.uid
ClB.getstorage(reform::Reformulation) = reform.storage
# methods specific to Formulation
"""
getobjsense(reformulation)
Return the objective sense of the master problem of the reformulation.
If the master problem has not been defined, it throws an error.
"""
function getobjsense(r::Reformulation)
r.master !== nothing && return getobjsense(r.master)
error("Undefined master in the reformulation, cannot return the objective sense.")
end
"""
getmaster(reform) -> Formulation
Return the formulation of the master problem.
"""
getmaster(r::Reformulation) = r.master
# TODO : remove
setmaster!(r::Reformulation, f::Formulation) = r.master = f
"""
add_dw_pricing_sp!(reformulation, abstractmodel)
Add a Dantzig-Wolfe pricing subproblem in the reformulation.
"""
add_dw_pricing_sp!(r::Reformulation, f) = r.dw_pricing_subprs[getuid(f)] = f
"""
add_benders_sep_sp!(reformulation, abstractmodel)
Add a Benders separation subproblem in the reformulation.
"""
add_benders_sep_sp!(r::Reformulation, f) = r.benders_sep_subprs[getuid(f)] = f
"""
get_dw_pricing_sps(reformulation)
Return a `Dict{FormId, AbstractModel}` containing all Dabtzig-Wolfe pricing subproblems of
the reformulation.
"""
get_dw_pricing_sps(r::Reformulation) = r.dw_pricing_subprs
"""
get_benders_sep_sps(reformulation)
Return a `Dict{FormId, AbstractModel}` containing all Benders separation subproblems of the
reformulation.
"""
get_benders_sep_sps(r::Reformulation) = r.benders_sep_subprs
"""
get_dw_pricing_sp_ub_constrid(reformulation, spid)
Return the `ConstrId` of the upper bounded convexity constraint of Dantzig-Wolfe pricing
subproblem with id `spid`.
"""
get_dw_pricing_sp_ub_constrid(r::Reformulation, spid) = r.dw_pricing_subprs[spid].duty_data.upper_multiplicity_constr_id
"""
get_dw_pricing_sp_lb_constrid(reformulation, spid)
Return the `ConstrId` of the lower bounded convexity constraint of Dantzig-Wolfe pricing
subproblem with id `spid`.
"""
get_dw_pricing_sp_lb_constrid(r::Reformulation, spid) = r.dw_pricing_subprs[spid].duty_data.lower_multiplicity_constr_id
############################################################################################
# Initial columns callback
############################################################################################
struct InitialColumnsCallbackData
form::Formulation
primal_solutions::Vector{PrimalSolution}
end
# Method to initial the solution pools of the subproblems
function initialize_solution_pools!(reform::Reformulation, initial_columns_callback::Function)
for (_, sp) in get_dw_pricing_sps(reform)
initialize_solution_pool!(sp, initial_columns_callback)
end
return
end
initialize_solution_pools!(::Reformulation, ::Nothing) = nothing # fallback
# Following two functions are temporary, we must store a pointer to the vc
# being represented by a representative vc
function vc_belongs_to_formulation(form::Formulation, vc::AbstractVarConstr)
!haskey(form, getid(vc)) && return false
vc_in_formulation = getelem(form, getid(vc))
isexplicit(form, vc_in_formulation) && return true
return false
end
function find_owner_formulation(reform::Reformulation, vc::AbstractVarConstr)
vc_belongs_to_formulation(reform.master, vc) && return reform.master
for (formid, spform) in get_dw_pricing_sps(reform)
vc_belongs_to_formulation(spform, vc) && return spform
end
@error(string("VC ", vc.name, " does not belong to any problem in reformulation"))
end
function Base.show(io::IO, reform::Reformulation)
compact = get(io, :compact, false)
user_only = get(io, :user_only, false)
if compact
print(io, "Reformulation")
elseif user_only
println(io, "--- Reformulation ---")
print(io, getmaster(reform))
for (_, sp) in get_dw_pricing_sps(reform)
print(io, sp)
end
println(io, "---------------------")
end
end | Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 13106 | ############################################################################################
# MathProg > Solutions
# Representations of the primal & dual solutions to a MILP formulation
############################################################################################
"Supertype for solutions operated by Coluna."
abstract type AbstractSolution end
# The API for `AbstractSolution` is not very clear yet.
# Redefine methods from ColunaBase to access the formulation, the value, the
# status of a Solution, and other specific information
ColunaBase.getmodel(s::AbstractSolution) = getmodel(s.solution)
ColunaBase.getvalue(s::AbstractSolution) = getvalue(s.solution)
ColunaBase.getbound(s::AbstractSolution) = getbound(s.solution)
ColunaBase.getstatus(s::AbstractSolution) = getstatus(s.solution)
Base.length(s::AbstractSolution) = length(s.solution)
Base.get(s::AbstractSolution, id, default) = get(s.solution, id, default)
Base.getindex(s::AbstractSolution, id) = getindex(s.solution, id)
Base.setindex!(s::AbstractSolution, val, id) = setindex!(s.solution, val, id)
# Iterating over a PrimalSolution or a DualSolution is similar to iterating over
# ColunaBase.Solution
Base.iterate(s::AbstractSolution) = iterate(s.solution)
Base.iterate(s::AbstractSolution, state) = iterate(s.solution, state)
function contains(sol::AbstractSolution, f::Function)
for (elemid, _) in sol
f(elemid) && return true
end
return false
end
function _sols_from_same_model(sols::NTuple{N, S}) where {N,S<:AbstractSolution}
for i in 2:length(sols)
getmodel(sols[i-1]) != getmodel(sols[i]) && return false
end
return true
end
# To check if a solution is part of solutions from the pool.
Base.:(==)(v1::DynamicMatrixColView, v2::AbstractSolution) = v1 == v2.solution
# To allocate an array with size equals to the number of non-zero elements when using
# "generation" syntax.
Base.length(gen::Base.Generator{<:AbstractSolution}) = nnz(gen.iter.solution)
############################################################################################
# Primal Solution
############################################################################################
struct PrimalSolution{M} <: AbstractSolution
solution::Solution{M,VarId,Float64}
custom_data::Union{Nothing, BlockDecomposition.AbstractCustomVarData}
end
"""
PrimalSolution(
form::AbstractFormulation,
varids::Vector{VarId},
varvals::Vector{Float64},
cost::Float64,
status::SolutionStatus;
custom_data::Union{Nothing, BlockDecomposition.AbstractCustomVarData} = nothing
)
Create a primal solution to the formulation `form` of cost `cost` and status `status`.
The representations of the soslution is `varids` the set of the ids of the variables
and `varvals` the values of the variables (`varvals[i]` is value of variable `varids[i]`).
The user can also attach to the primal solution a customized representation
`custom_data`.
"""
function PrimalSolution(
form::M, varids, varvals, cost, status; custom_data = nothing
) where {M<:AbstractFormulation}
@assert length(varids) == length(varvals)
sol = Solution{M,VarId,Float64}(form, varids, varvals, cost, status)
return PrimalSolution{M}(sol, custom_data)
end
function Base.:(==)(a::PrimalSolution, b::PrimalSolution)
return a.solution == b.solution && a.custom_data == b.custom_data
end
function Base.copy(s::P) where {P<:PrimalSolution}
custom_data = isnothing(s.custom_data) ? nothing : copy(s.custom_data)
return P(copy(s.solution), custom_data)
end
function Base.isinteger(sol::PrimalSolution)
for (vc_id, val) in sol
if getperenkind(getmodel(sol), vc_id) !== Continuous && abs(round(val) - val) > Coluna.DEF_OPTIMALITY_ATOL
return false
end
end
return true
end
function Base.isless(s1::PrimalSolution, s2::PrimalSolution)
getobjsense(getmodel(s1)) == MinSense && return s1.solution.bound > s2.solution.bound
return s1.solution.bound < s2.solution.bound
end
# Method `cat` is not implemented for a set of DualSolutions because @guimarqu don't know
# how to concatenate var red cost of a variable if both bounds are active in different
# solutions and because we don't need it for now.
function Base.cat(sols::PrimalSolution...)
if !_sols_from_same_model(sols)
error("Cannot concatenate solutions not attached to the same model.")
end
ids = VarId[]
vals = Float64[]
for sol in sols, (id, value) in sol
push!(ids, id)
push!(vals, value)
end
return PrimalSolution(
getmodel(sols[1]), ids, vals, sum(getvalue.(sols)), getstatus(sols[1])
)
end
############################################################################################
# Dual Solution
############################################################################################
# Indicate whether the active bound of a variable is the lower or the upper one.
@enum ActiveBound LOWER UPPER
struct DualSolution{M} <: AbstractSolution
solution::Solution{M,ConstrId,Float64}
var_redcosts::Dict{VarId, Tuple{Float64,ActiveBound}}
custom_data::Union{Nothing, BlockDecomposition.AbstractCustomConstrData}
end
"""
DualSolution(
form::AbstractFormulation,
constrids::Vector{ConstrId},
constrvals::Vector{Float64},
varids::Vector{VarId},
varvals::Vector{Float64},
varactivebounds::Vector{ActiveBound},
cost::Float64,
status::SolutionStatus;
custom_data::Union{Nothing, BlockDecomposition.AbstractColumnData} = nothing
)
Create a dual solution to the formulation `form` of cost `cost` and status `status`.
It contains `constrids` the set of ids of the constraints and `constrvals` the values
of the constraints (`constrvals[i]` is dual value of `constrids[i]`).
It also contains `varvals[i]` the dual values of the bound constraint `varactivebounds[i]` of the variables `varids`
(also known as the reduced cost).
The user can attach to the dual solution a customized representation
`custom_data`.
"""
function DualSolution(
form::M, constrids, constrvals, varids, varvals, varactivebounds, cost, status;
custom_data = nothing
) where {M<:AbstractFormulation}
@assert length(constrids) == length(constrvals)
@assert length(varids) == length(varvals) == length(varactivebounds)
var_redcosts = Dict{VarId, Tuple{Float64,ActiveBound}}()
for i in 1:length(varids)
var_redcosts[varids[i]] = (varvals[i],varactivebounds[i])
end
sol = Solution{M,ConstrId,Float64}(form, constrids, constrvals, cost, status)
return DualSolution{M}(sol, var_redcosts, custom_data)
end
function Base.:(==)(a::DualSolution, b::DualSolution)
return a.solution == b.solution && a.var_redcosts == b.var_redcosts &&
a.custom_data == b.custom_data
end
Base.copy(s::D) where {D<:DualSolution} = D(copy(s.solution), copy(s.var_redcosts), copy(s.custom_data))
get_var_redcosts(s::DualSolution) = s.var_redcosts
function Base.isless(s1::DualSolution, s2::DualSolution)
getobjsense(getmodel(s1)) == MinSense && return s1.solution.bound < s2.solution.bound
return s1.solution.bound > s2.solution.bound
end
function Base.show(io::IO, solution::DualSolution{M}) where {M}
println(io, "Dual solution")
for (constrid, value) in solution
println(io, "| ", getname(getmodel(solution), constrid), " = ", value)
end
for (varid, redcost) in solution.var_redcosts
println(io, "| ", getname(getmodel(solution), varid), " = ", redcost[1], " (", redcost[2], ")")
end
Printf.@printf(io, "└ value = %.2f \n", getvalue(solution))
end
function Base.show(io::IO, solution::PrimalSolution{M}) where {M}
model = getmodel(solution)
user_only = get(io, :user_only, false) && model isa Formulation
println(io, "Primal solution")
for (varid, value) in solution
if user_only && isaNonUserDefinedDuty(getduty(varid))
if getduty(varid) <= MasterCol
print(io, "| ", getname(model, varid), " = [")
origin_form_uid = getoriginformuid(varid)
spform = get_dw_pricing_sps(getparent(model))[origin_form_uid]
spsol = @view get_primal_sol_pool(spform).solutions[varid, :]
for (sp_var_id, sp_value) in spsol
isaNonUserDefinedDuty(getduty(sp_var_id)) && continue
print(io, getname(spform, sp_var_id), " = ", sp_value, " ")
end
println(io, "] = ", value)
end
else
println(io, "| ", getname(model, varid), " = ", value)
end
end
Printf.@printf(io, "└ value = %.2f \n", getvalue(solution))
end
############################################################################################
# Linear Algebra
############################################################################################
# op(::S, ::S) has return type `S` for op ∈ (:+, :-) and S <: AbstractSolution
_math_op_constructor(::Type{S}, form::F, varids, varvals, cost) where {S<:PrimalSolution,F} =
PrimalSolution(form, varids, varvals, cost, ClB.UNKNOWN_SOLUTION_STATUS)
_math_op_constructor(::Type{<:S}, form::F, constrids, constrvals, cost) where {S<:DualSolution,F} =
DualSolution(form, constrids, constrvals, [], [], [], cost, ClB.UNKNOWN_SOLUTION_STATUS)
_math_op_cost(::Type{<:S}, form, varids, varvals) where {S<:PrimalSolution} =
mapreduce(((id,val),) -> getcurcost(form, id) * val, +, Iterators.zip(varids, varvals); init = 0.0)
_math_op_cost(::Type{<:S}, form, constrids, constrvals) where {S<:DualSolution} =
mapreduce(((id, val),) -> getcurrhs(form, id) * val, +, Iterators.zip(constrids, constrvals); init = 0.0)
function Base.:(*)(a::Real, s::S) where {S<:AbstractSolution}
ids, vals = findnz(a * s.solution.sol)
cost = _math_op_cost(S, getmodel(s), ids, vals)
return _math_op_constructor(S, getmodel(s), ids, vals, cost)
end
for op in (:+, :-)
@eval begin
function Base.$op(s1::S, s2::S) where {S<:AbstractSolution}
@assert getmodel(s1) == getmodel(s2)
ids, vals = findnz(ColunaBase._sol_custom_binarymap($op, s1.solution, s2.solution))
cost = _math_op_cost(S, getmodel(s1), ids, vals)
return _math_op_constructor(S, getmodel(s1), ids, vals, cost)
end
end
end
# transpose
struct Transposed{S<:AbstractSolution}
sol::S
end
Base.transpose(s::AbstractSolution) = Transposed(s)
Base.:(*)(s1::Transposed{S}, s2::S) where {S<:AbstractSolution} =
transpose(s1.sol.solution.sol) * s2.solution.sol
function Base.:(*)(s::Transposed{<:AbstractSolution}, vec::SparseVector)
# We multiply two sparse vectors that may have different sizes.
sol_vec = s.sol.solution.sol
len = Coluna.MAX_NB_ELEMS
vec1 = sparsevec(findnz(sol_vec)..., len)
vec2 = sparsevec(findnz(vec)..., len)
return transpose(vec1) * vec2
end
# *(::M, ::S) has return type `SparseVector` for:
# - M <: DynamicSparseMatrix
# - S <: AbstractSolution
# We don't support operation with classic sparse matrix because row and col ids
# must be of the same type.
# In Coluna, we use VarId to index the cols and
# ConstrId to index the rows.
Base.:(*)(m::DynamicSparseMatrix, s::AbstractSolution) = m * s.solution.sol
Base.:(*)(m::DynamicSparseArrays.Transposed{<:DynamicSparseMatrix}, s::AbstractSolution) = m * s.solution.sol
LinearAlgebra.norm(s::AbstractSolution) = norm(s.solution.sol)
############################################################################################
# Infeasibility certificate
############################################################################################
@enum PrimalOrDualInfeasibility PRIMAL_INFEASIBILITY DUAL_INFEASIBILITY
struct InfeasibilityCertificate{M} <: AbstractSolution
infeasibility::PrimalOrDualInfeasibility
vars::Solution{M,VarId,Float64}
constrs::Solution{M,ConstrId,Float64}
end
function PrimalInfeasibilityCertificate(
form::M, constrids, constrvals, varids, varvals, cost;
) where {M<:AbstractFormulation}
@assert length(constrids) == length(constrvals)
@assert length(varids) == length(varvals)
status = INFEASIBLE_SOL
vars = Solution{M,VarId,Float64}(form, varids, varvals, cost, status)
constrs = Solution{M,ConstrId,Float64}(form, constrids, constrvals, cost, status)
return InfeasibilityCertificate{M}(PRIMAL_INFEASIBILITY, vars, constrs)
end
function DualInfeasibilityCertificate(
form::M, constrids, constrvals, varids, varvals, cost;
) where {M<:AbstractFormulation}
@assert length(constrids) == length(constrvals)
@assert length(varids) == length(varvals)
status = INFEASIBLE_SOL
vars = Solution{M,VarId,Float64}(form, varids, varvals, cost, status)
constrs = Solution{M,ConstrId,Float64}(form, constrids, constrvals, cost, status)
return InfeasibilityCertificate{M}(DUAL_INFEASIBILITY, vars, constrs)
end
| Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 4355 | abstract type AbstractVarConstr end
abstract type AbstractVcData end
abstract type AbstractOptimizer end
# Interface (src/interface.jl)
struct MinSense <: Coluna.AbstractMinSense end
struct MaxSense <: Coluna.AbstractMaxSense end
# Duties for variables and constraints
"""
Duty{Variable}
Duties of a variable are tree-structured values wrapped in `Duty{Variable}` instances.
Leaves are concret duties of a variable, intermediate nodes are duties representing
families of duties, and the root node is a `Duty{Variable}` with value `1`.
Duty{Constraint}
It works like `Duty{Variable}`.
# Examples
If a duty `Duty1` inherits from `Duty2`, then
```example
julia> Duty1 <= Duty2
true
```
"""
struct Duty{VC <: AbstractVarConstr} <: NestedEnum
value::UInt
end
# Source : https://discourse.julialang.org/t/export-enum/5396
macro exported_enum(name, args...)
esc(quote
@enum($name, $(args...))
export $name
$([:(export $arg) for arg in args]...)
end)
end
@exported_enum VarSense Positive Negative Free
@exported_enum VarKind Continuous Binary Integ
@exported_enum ConstrKind Essential Facultative SubSystem
@exported_enum ConstrSense Greater Less Equal
# TODO remove following exported_enum
@exported_enum FormulationPhase HybridPhase PurePhase1 PurePhase2 # TODO : remove from Benders
const FormId = Int16
############################################################################
######################## MathOptInterface shortcuts ########################
############################################################################
# Objective function
const MoiObjective = MOI.ObjectiveFunction{MOI.ScalarAffineFunction{Float64}}
# Constraint
const MoiConstrIndex = MOI.ConstraintIndex
MoiConstrIndex{F,S}() where {F,S} = MOI.ConstraintIndex{F,S}(-1)
MoiConstrIndex() = MOI.ConstraintIndex{
MOI.ScalarAffineFunction{Float64},MOI.LessThan{Float64}
}()
# Variable
const MoiVarIndex = MOI.VariableIndex
MoiVarIndex() = MOI.VariableIndex(-1)
# Bounds on variables
const MoiVarLowerBound = MOI.ConstraintIndex{MOI.VariableIndex,MOI.GreaterThan{Float64}}
const MoiVarUpperBound = MOI.ConstraintIndex{MOI.VariableIndex,MOI.LessThan{Float64}}
# Variable kinds
const MoiInteger = MOI.ConstraintIndex{MOI.VariableIndex,MOI.Integer}
const MoiBinary = MOI.ConstraintIndex{MOI.VariableIndex,MOI.ZeroOne}
const MoiVarKind = Union{MoiInteger,MoiBinary}
MoiVarKind() = MoiInteger(-1)
# Helper functions to transform MOI types in Coluna types
convert_moi_sense_to_coluna(::MOI.LessThan{T}) where {T} = Less
convert_moi_sense_to_coluna(::MOI.GreaterThan{T}) where {T} = Greater
convert_moi_sense_to_coluna(::MOI.EqualTo{T}) where {T} = Equal
convert_moi_rhs_to_coluna(set::MOI.LessThan{T}) where {T} = set.upper
convert_moi_rhs_to_coluna(set::MOI.GreaterThan{T}) where {T} = set.lower
convert_moi_rhs_to_coluna(set::MOI.EqualTo{T}) where {T} = set.value
convert_moi_kind_to_coluna(::MOI.ZeroOne) = Binary
convert_moi_kind_to_coluna(::MOI.Integer) = Integ
convert_moi_bounds_to_coluna(set::MOI.LessThan{T}) where {T} = (-Inf, set.upper)
convert_moi_bounds_to_coluna(set::MOI.GreaterThan{T}) where {T} = (set.lower, Inf)
convert_moi_bounds_to_coluna(set::MOI.EqualTo{T}) where {T} = (set.value, set.value)
convert_moi_bounds_to_coluna(set::MOI.Interval{T}) where {T} = (set.lower, set.upper)
function convert_coluna_sense_to_moi(constr_set::ConstrSense)
constr_set == Less && return MOI.LessThan{Float64}
constr_set == Greater && return MOI.GreaterThan{Float64}
@assert constr_set == Equal
return MOI.EqualTo{Float64}
end
function convert_coluna_kind_to_moi(var_kind::VarKind)
var_kind == Binary && return MOI.ZeroOne
var_kind == Integ && return MOI.Integer
@assert var_kind == Continuous
return nothing
end
############################################################################
"""
AbstractFormulation
Formulation is a mathematical representation of a problem
(model of a problem). A problem may have different formulations.
We may rename "formulation" to "model" after.
Different algorithms may be applied to a formulation.
A formulation should contain a dictionary of storage units
used by algorithms. A formulation contains one storage unit
per storage unit type used by algorithms.
"""
abstract type AbstractFormulation <: AbstractModel end
| Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 30121 |
# There are two levels of data for each element of a formulation (i.e. variables and
# constraints).
# The first level is called "peren" (for perennial). It contains data that won't change for
# almost all the optimisation (e.g. the original cost of a variable, the original sense of
# constraint...). Coluna provides methods to set these data because it can ease the setup
# of a formulation. Algorithm designers are free to use these method at their own risk.
# The second level is called "cur" (for current). It describes the current state of each
# element of the formulation.
getid(vc::AbstractVarConstr) = vc.id
getoriginformuid(vc::AbstractVarConstr) = getoriginformuid(getid(vc))
# no moi record for a single variable constraint
getmoirecord(vc::Variable)::MoiVarRecord = vc.moirecord
getmoirecord(vc::Constraint)::MoiConstrRecord = vc.moirecord
# Variables
## Cost
"""
getperencost(formulation, variable)
getperencost(formulation, varid)
Return the cost as defined by the user of a variable in a formulation.
"""
function getperencost(form::Formulation, varid::VarId)
var = getvar(form, varid)
@assert !isnothing(var)
return getperencost(form, var)
end
getperencost(::Formulation, var::Variable) = var.perendata.cost
"""
getcurcost(formulation, variable)
getcurcost(formulation, varid)
Return the current cost of the variable in the formulation.
"""
function getcurcost(form::Formulation, varid::VarId)
var = getvar(form, varid)
@assert !isnothing(var)
return getcurcost(form, var)
end
getcurcost(::Formulation, var::Variable) = var.curdata.cost
"""
setperencost!(formulation, variable, cost)
setperencost!(formulation, varid, cost)
Set the perennial cost of a variable and then propagate change to the current cost of the
variable.
"""
function setperencost!(form::Formulation, var::Variable, cost)
var.perendata.cost = cost
return setcurcost!(form, var, cost)
end
function setperencost!(form::Formulation, varid::VarId, cost)
var = getvar(form, varid)
@assert !isnothing(var)
return setperencost!(form, var, cost)
end
"""
setcurcost!(formulation, varid, cost::Float64)
setcurcost!(formulation, variable, cost::Float64)
Set the current cost of variable in the formulation.
If the variable is active and explicit, this change is buffered before application to the
subsolver.
"""
function setcurcost!(form::Formulation, var::Variable, cost)
var.curdata.cost = cost
if isexplicit(form, var) && iscuractive(form, var)
change_cost!(form.buffer, getid(var))
end
return
end
function setcurcost!(form::Formulation, varid::VarId, cost)
var = getvar(form, varid)
@assert !isnothing(var)
return setcurcost!(form, var, cost)
end
## Lower bound
"""
setperenlb!(formulation, var, rhs)
Set the perennial lower bound of a variable in a formulation.
Change is propagated to the current lower bound of the variable.
"""
function setperenlb!(form::Formulation, var::Variable, lb)
var.perendata.lb = lb
_setperenbounds_wrt_perenkind!(form, var, getperenkind(form, var))
return setcurlb!(form, var, lb)
end
"""
getperenlb(formulation, varid)
getperenlb(formulation, var)
Return the lower bound as defined by the user of a variable in a formulation.
"""
function getperenlb(form::Formulation, varid::VarId)
var = getvar(form, varid)
@assert !isnothing(var)
return getperenlb(form, var)
end
getperenlb(::Formulation, var::Variable) = var.perendata.lb
"""
getcurlb(formulation, varid)
getcurlb(formulation, var)
Return the current lower bound of a variable in a formulation.
"""
function getcurlb(form::Formulation, varid::VarId)
var = getvar(form, varid)
@assert !isnothing(var)
return getcurlb(form, var)
end
getcurlb(::Formulation, var::Variable) = var.curdata.lb
"""
setcurlb!(formulation, varid, lb::Float64)
setcurlb!(formulation, var, lb::Float64)
Set the current lower bound of a variable in a formulation.
If the variable is active and explicit, change is buffered before application to the
subsolver.
If the variable had fixed value, it unfixes the variable.
"""
function setcurlb!(form::Formulation, var::Variable, lb)
# if in_partial_sol(form, var) && !(getduty(getid(var)) <= MasterCol)
# @warn "Changing lower bound of fixed variable."
# end
var.curdata.lb = lb
if isexplicit(form, var) && iscuractive(form, var)
change_bound!(form.buffer, getid(var))
end
_setcurbounds_wrt_curkind!(form, var, getcurkind(form, var))
return
end
setcurlb!(form::Formulation, varid::VarId, lb) = setcurlb!(form, getvar(form, varid), lb)
## Upper bound
"""
setperenub!(formulation, var, rhs)
Set the perennial upper bound of a variable in a formulation.
Change is propagated to the current upper bound of the variable.
"""
function setperenub!(form::Formulation, var::Variable, ub)
var.perendata.ub = ub
_setperenbounds_wrt_perenkind!(form, var, getperenkind(form, var))
return setcurub!(form, var, ub)
end
"""
getperenub(formulation, varid)
getperenub(formulation, var)
Return the upper bound as defined by the user of a variable in a formulation.
"""
function getperenub(form::Formulation, varid::VarId)
var = getvar(form, varid)
@assert !isnothing(var)
return getperenub(form, var)
end
getperenub(::Formulation, var::Variable) = var.perendata.ub
"""
getcurub(formulation, varid)
getcurub(formulation, var)
Return the current upper bound of a variable in a formulation.
"""
function getcurub(form::Formulation, varid::VarId)
var = getvar(form, varid)
@assert !isnothing(var)
return getcurub(form, var)
end
getcurub(::Formulation, var::Variable) = var.curdata.ub
"""
setcurub!(formulation, varid, ub::Float64)
setcurub!(formulation, var, ub::Float64)
Set the current upper bound of a variable in a formulation.
If the variable is active and explicit, change is buffered before application to the
subsolver.
If the variable had fixed value, it unfixes the variable.
"""
function setcurub!(form::Formulation, var::Variable, ub)
# if in_partial_sol(form, var)
# @warn "Changing upper bound of fixed variable."
# end
var.curdata.ub = ub
if isexplicit(form, var) && iscuractive(form, var)
change_bound!(form.buffer, getid(var))
end
_setcurbounds_wrt_curkind!(form, var, getcurkind(form, var))
return
end
function setcurub!(form::Formulation, varid::VarId, ub)
var = getvar(form, varid)
@assert !isnothing(var)
return setcurub!(form, var, ub)
end
function _propagate_partial_value_bounds!(form, var, cumulative_value)
peren_lb = getperenlb(form, var)
peren_ub = getperenub(form, var)
if cumulative_value < - Coluna.TOL
setcurlb!(form, var, peren_lb - cumulative_value)
setcurub!(form, var, min(peren_ub, 0.0))
elseif cumulative_value > Coluna.TOL
setcurlb!(form, var, max(peren_lb, 0.0))
setcurub!(form, var, peren_ub - cumulative_value)
else
setcurlb!(form, var, peren_lb)
setcurub!(form, var, peren_ub)
end
return
end
"""
add_to_partial_solution!(formulation, varid, value)
Set the minimal value that the variable with id `varid` takes into the optimal solution.
If the variable is already in the partial solution, the value cumulates with the current.
If the cumulative value is 0, the variable is removed from the partial solution.
**Warning**: by default, there is no propagation, no change on variable bounds,
you must call the presolve algorithm.
"""
function add_to_partial_solution!(form::Formulation, varid::VarId, value, propagation = false)
var = getvar(form, varid)
@assert !isnothing(var)
return add_to_partial_solution!(form, var, value, propagation)
end
function add_to_partial_solution!(form::Formulation, var::Variable, value, propagation = false)
if isexplicit(form, var)
cumulative_val = _add_partial_value!(form.manager, var, value)
if propagation
_propagate_partial_value_bounds!(form, var, cumulative_val)
end
return true
end
name = getname(form, var)
@warn "Cannot add variable $name to partial solution because it is non-explicit."
return false
end
function set_value_in_partial_solution!(form::Formulation, varid::VarId, value)
var = getvar(form, varid)
@assert !isnothing(var)
return set_value_in_partial_solution!(form, var, value)
end
function set_value_in_partial_solution!(form::Formulation, var::Variable, value)
if isexplicit(form, var)
_set_partial_value!(form.manager, var, value)
return true
end
name = getname(form, var)
@warn "Cannot set variable $name to partial solution because it is non-explicit."
return false
end
"""
in_partial_sol(form, varid)
in_partial_sol(form, variable)
Return `true` if the variable is in the partial solution; `false` otherwise.
"""
in_partial_sol(form::Formulation, varid::VarId) = in_partial_sol(form, getvar(form, varid))
in_partial_sol(::Formulation, var::Variable) = var.curdata.is_in_partial_sol
"""
get_value_in_partial_sol(formulation, varid)
get_value_in_partial_sol(formulation, variable)
Return the value of the variable in the partial solution.
"""
get_value_in_partial_sol(form::Formulation, varid::VarId) = get_value_in_partial_sol(form, getvar(form, varid))
function get_value_in_partial_sol(form::Formulation, var::Variable)
!in_partial_sol(form, var) && return 0
return get(form.manager.partial_solution, getid(var), 0)
end
"""
getpartialsol(formulation) -> Dict{VarId,Float64}
Returns the partial solution to the formulation.
"""
getpartialsol(form::Formulation) = _partial_sol(form.manager)
"""
getpartialsolvalue(formulation) -> Float64
Returns the partial solution value.
"""
function getpartialsolvalue(form::Formulation)
partial_sol_val = 0.0
for (varid, val) in getpartialsol(form)
partial_sol_val += getcurcost(form, varid) * val
end
return partial_sol_val
end
# Constraint
## rhs
"""
getperenrhs(formulation, constraint)
getperenrhs(formulation, constrid)
Return the right-hand side as defined by the user of a constraint in a formulation.
"""
function getperenrhs(form::Formulation, constrid::ConstrId)
constr = getconstr(form, constrid)
@assert !isnothing(constr)
return getperenrhs(form, constr)
end
getperenrhs(::Formulation, constr::Constraint) = constr.perendata.rhs
"""
getcurrhs(formulation, constraint)
getcurrhs(formulation, constrid)
Return the current right-hand side of a constraint in a formulation.
"""
function getcurrhs(form::Formulation, constrid::ConstrId)
constr = getconstr(form, constrid)
@assert !isnothing(constr)
return getcurrhs(form, constr)
end
getcurrhs(::Formulation, constr::Constraint) = constr.curdata.rhs
"""
setperenrhs!(formulation, constr, rhs)
setperenrhs!(formulation, constrid, rhs)
Set the perennial rhs of a constraint in a formulation.
Change is propagated to the current rhs of the constraint.
"""
function setperenrhs!(form::Formulation, constr::Constraint, rhs)
constr.perendata.rhs = rhs
return setcurrhs!(form, constr, rhs)
end
function setperenrhs!(form::Formulation, constrid::ConstrId, rhs)
constr = getconstr(form, constrid)
@assert !isnothing(constr)
return setperenrhs!(form, constr, rhs)
end
"""
setcurrhs(formulation, constraint, rhs::Float64)
setcurrhs(formulation, constrid, rhs::Float64)
Set the current right-hand side of a constraint in a formulation.
If the constraint is active and explicit, this change is buffered before application to the
subsolver.
**Warning** : if you change the rhs of a single variable constraint, make sure that you
perform bound propagation before calling the subsolver of the formulation.
"""
function setcurrhs!(form::Formulation, constr::Constraint, rhs::Float64)
constr.curdata.rhs = rhs
if isexplicit(form, constr) && iscuractive(form, constr)
change_rhs!(form.buffer, getid(constr))
end
return
end
function setcurrhs!(form::Formulation, constrid::ConstrId, rhs::Float64)
constr = getconstr(form, constrid)
@assert !isnothing(constr)
return setcurrhs!(form, constr, rhs)
end
# Variable & Constraints
## kind
"""
getperenkind(formulation, varconstr)
getperenkind(formulation, varconstrid)
Return the kind as defined by the user of a variable or a constraint in a formulation.
Kinds of variable (`enum VarKind`) are `Continuous`, `Binary`, or `Integ`.
Kinds of a constraint (`enum ConstrKind`) are :
- `Essential` when the constraint structures the problem
- `Facultative` when the constraint does not structure the problem
- `SubSystem` (to do)
The kind of a constraint cannot change.
"""
function getperenkind(form::Formulation, varid::VarId)
var = getvar(form, varid)
@assert !isnothing(var)
return getperenkind(form, var)
end
getperenkind(::Formulation, var::Variable) = var.perendata.kind
function getperenkind(form::Formulation, constrid::ConstrId)
constr = getconstr(form, constrid)
@assert !isnothing(constr)
return getperenkind(form, constr)
end
getperenkind(::Formulation, constr::Constraint) = constr.perendata.kind
"""
getcurkind(formulation, variable)
getcurkind(formulation, varid)
Return the current kind of a variable in a formulation.
"""
function getcurkind(form::Formulation, varid::VarId)
var = getvar(form, varid)
@assert !isnothing(var)
return getcurkind(form, var)
end
getcurkind(::Formulation, var::Variable) = var.curdata.kind
function _setperenbounds_wrt_perenkind!(form::Formulation, var::Variable, kind::VarKind)
if kind == Binary
if getperenlb(form, var) < 0
setperenlb!(form, var, 0.0)
end
if getperenub(form, var) > 1
setperenub!(form, var, 1.0)
end
elseif kind == Integer
setperenlb!(form, var, ceil(getperenlb(form, var)))
setperenub!(form, var, floor(getperenub(form, var)))
end
end
"""
setperenkind!(formulation, variable, kind)
setperenkind!(formulation, varid, kind)
Set the perennial kind of a variable in a formulation.
This change is then propagated to the current kind of the variable.
"""
function setperenkind!(form::Formulation, var::Variable, kind::VarKind)
var.perendata.kind = kind
_setperenbounds_wrt_perenkind!(form, var, kind)
return setcurkind!(form, var, kind)
end
setperenkind!(form::Formulation, varid::VarId, kind::VarKind) = setperenkind!(form, getvar(form, varid), kind)
function _setcurbounds_wrt_curkind!(form::Formulation, var::Variable, kind::VarKind)
if kind == Binary
if getcurlb(form, var) < 0
setcurlb!(form, var, 0.0)
end
if getcurub(form, var) > 1
setcurub!(form, var, 1.0)
end
elseif kind == Integer
setcurlb!(form, var, ceil(getcurlb(form, var)))
setcurub!(form, var, floor(getcurub(form, var)))
end
end
"""
setcurkind!(formulation, variable, kind::VarKind)
setcurkind!(formulation, varid, kind::VarKind)
Set the current kind of a variable in a formulation.
If the variable is active and explicit, this change is buffered before
application to the subsolver
"""
function setcurkind!(form::Formulation, var::Variable, kind::VarKind)
var.curdata.kind = kind
_setcurbounds_wrt_curkind!(form, var, kind)
if isexplicit(form, var) && iscuractive(form, var)
change_kind!(form.buffer, getid(var))
end
return
end
setcurkind!(form::Formulation, varid::VarId, kind::VarKind) = setcurkind!(form, getvar(form, varid), kind)
## sense
function _senseofvar(lb::Float64, ub::Float64)
lb >= 0 && return Positive
ub <= 0 && return Negative
return Free
end
"""
getperensense(formulation, varconstr)
getperensense(formulation, varconstrid)
Return the sense as defined by the user of a variable or a constraint in a formulation.
Senses or a variable are (`enum VarSense`) `Positive`, `Negative`, and `Free`.
Senses or a constraint are (`enum ConstrSense`) `Greater`, `Less`, and `Equal`.
The perennial sense of a variable depends on its perennial bounds.
"""
function getperensense(form::Formulation, varid::VarId)
var = getvar(form, varid)
@assert !isnothing(var)
return getperensense(form, var)
end
getperensense(form::Formulation, var::Variable) = _senseofvar(getperenlb(form, var), getperenub(form, var))
function getperensense(form::Formulation, constrid::ConstrId)
constr = getconstr(form, constrid)
@assert !isnothing(constr)
return getperensense(form, constr)
end
getperensense(::Formulation, constr::Constraint) = constr.perendata.sense
"""
getcursense(formulation, varconstr)
getcursense(formulation, varconstrid)
Return the current sense of a variable or a constraint in a formulation.
The current sense of a variable depends on its current bounds.
"""
function getcursense(form::Formulation, varid::VarId)
var = getvar(form, varid)
@assert !isnothing(var)
return getcursense(form, var)
end
getcursense(form::Formulation, var::Variable) = _senseofvar(getcurlb(form, var), getcurub(form, var))
function getcursense(form::Formulation, constrid::ConstrId)
constr = getconstr(form, constrid)
@assert !isnothing(constr)
return getcursense(form, constr)
end
getcursense(::Formulation, constr::Constraint) = constr.curdata.sense
"""
setperensense!(form, constr, sense)
setperensense!(form, constrid, sense)
Set the perennial sense of a constraint in a formulation.
Change is propagated to the current sense of the constraint.
**Warning** : if you set the sense of a single var constraint, make sure you perform bound
propagation before calling the subsolver of the formulation.
"""
function setperensense!(form::Formulation, constr::Constraint, sense::ConstrSense)
constr.perendata.sense = sense
return setcursense!(form, constr, sense)
end
function setperensense!(form::Formulation, constrid::ConstrId, sense::ConstrSense)
constr = getconstr(form, constrid)
@assert !isnothing(constr)
return setperensense!(form, constr, sense)
end
"""
setcursense!(formulation, constr, sense::ConstrSense)
setcursense!(formulation, constrid, sense::ConstrSense)
Set the current sense of a constraint in a formulation.
This method is not applicable to variables because the sense of a variable depends on its
bounds.
**Warning** : if you set the sense of a single var constraint, make sure you perform bound
propagation before calling the subsolver of the formulation.
"""
function setcursense!(form::Formulation, constr::Constraint, sense::ConstrSense)
constr.curdata.sense = sense
if isexplicit(form, constr)
change_rhs!(form.buffer, getid(constr)) # it's sense & rhs
end
return
end
function setcursense!(form::Formulation, constrid::ConstrId, sense::ConstrSense)
constr = getconstr(form, constrid)
@assert !isnothing(constr)
return setcursense!(form, constr, sense)
end
## inc_val
"""
getperenincval(formulation, varconstrid)
getperenincval(formulation, varconstr)
Return the incumbent value as defined by the user of a variable or a constraint in a formulation.
The incumbent value is the primal value associated to a variable or the dual value associated to
a constraint.
"""
function getperenincval(form::Formulation, varid::VarId)
var = getvar(form, varid)
@assert !isnothing(var)
return getperenincval(form, var)
end
getperenincval(::Formulation, var::Variable) = var.perendata.inc_val
function getperenincval(form::Formulation, constrid::ConstrId)
constr = getconstr(form, constrid)
@assert !isnothing(constr)
return getperenincval(form, constr)
end
getperenincval(::Formulation, constr::Constraint) = constr.perendata.inc_val
"""
getcurincval(formulation, varconstrid)
getcurincval(formulation, varconstr)
Return the current incumbent value of a variable or a constraint in a formulation.
"""
function getcurincval(form::Formulation, varid::VarId)
var = getvar(form, varid)
@assert !isnothing(var)
return getcurincval(form, var)
end
getcurincval(::Formulation, var::Variable) = var.curdata.inc_val
function getcurincval(form::Formulation, constrid::ConstrId)
constr = getconstr(form, constrid)
@assert !isnothing(constr)
return getcurincval(form, constr)
end
getcurincval(::Formulation, constr::Constraint) = constr.curdata.inc_val
"""
setcurincval!(formulation, varconstrid, value::Real)
Set the current incumbent value of a variable or a constraint in a formulation.
"""
setcurincval!(::Formulation, var::Variable, inc_val::Real) =
var.curdata.inc_val = inc_val
function setcurincval!(form::Formulation, varid::VarId, inc_val)
var = getvar(form, varid)
@assert !isnothing(var)
return setcurincval!(form, var, inc_val)
end
setcurincval!(::Formulation, constr::Constraint, inc_val::Real) =
constr.curdata.inc_val = inc_val
function setcurincval!(form::Formulation, constrid::ConstrId, inc_val)
constr = getconstr(form, constrid)
@assert !isnothing(constr)
return setcurincval!(form, constr, inc_val)
end
## active
"""
isperenactive(formulation, varconstrid)
isperenactive(formulation, varconstr)
Return `true` if the variable or the constraint is active in the formulation; `false` otherwise.
A variable (or a constraint) is active if it is used in the formulation. You can fake the
deletion of the variable by deativate it. This allows you to keep the variable if you want
to reactivate it later.
"""
function isperenactive(form::Formulation, varid::VarId)
var = getvar(form, varid)
@assert !isnothing(var)
return isperenactive(form, var)
end
isperenactive(::Formulation, var::Variable) = var.perendata.is_active
function isperenactive(form::Formulation, constrid::ConstrId)
constr = getconstr(form, constrid)
@assert !isnothing(constr)
isperenactive(form, constr)
end
isperenactive(::Formulation, constr::Constraint) = constr.perendata.is_active
"""
iscuractive(formulation, varconstrid)
iscuractive(formulation, varconstr)
Return `true` if the variable or the constraint is currently active; `false` otherwise.
"""
function iscuractive(form::Formulation, varid::VarId)
var = getvar(form, varid)
@assert !isnothing(var)
return iscuractive(form, var)
end
iscuractive(::Formulation, var::Variable) = var.curdata.is_active
function iscuractive(form::Formulation, constrid::ConstrId)
constr = getconstr(form, constrid)
@assert !isnothing(constr)
return iscuractive(form, constr)
end
iscuractive(::Formulation, constr::Constraint) = constr.curdata.is_active
## activate!
function _activate!(form::Formulation, varconstr::AbstractVarConstr)
if isexplicit(form, varconstr) && !iscuractive(form, varconstr)
add!(form.buffer, getid(varconstr))
end
varconstr.curdata.is_active = true
return
end
"""
activate!(formulation, varconstrid)
activate!(formulation, varconstr)
Activate a variable or a constraint in a formulation.
activate!(formulation, function)
It is also possible to activate variables and constraints of a formulation such that
`function(varconstrid)` returns `true`.
"""
function activate!(form::Formulation, constr::Constraint)
_activate!(form, constr)
for varid in constr.art_var_ids
_activate!(form, getvar(form, varid))
end
return
end
function activate!(form::Formulation, var::Variable)
_activate!(form, var)
return
end
function activate!(form::Formulation, varconstrid::Id{VC}) where {VC <: AbstractVarConstr}
elem = getelem(form, varconstrid)
@assert !isnothing(elem)
return activate!(form, elem)
end
function activate!(form::Formulation, f::Function)
for (varid, var) in getvars(form)
if !iscuractive(form, varid) && f(varid)
activate!(form, var)
end
end
for (constrid, constr) in getconstrs(form)
if !iscuractive(form, constrid) && f(constrid)
activate!(form, constr)
end
end
return
end
## deactivate!
function _deactivate!(form::Formulation, varconstr::AbstractVarConstr)
if isexplicit(form, varconstr) && iscuractive(form, varconstr)
remove!(form.buffer, getid(varconstr))
end
varconstr.curdata.is_active = false
return
end
"""
deactivate!(formulation, varconstrid)
deactivate!(formulation, varconstr)
Deactivate a variable or a constraint in a formulation.
deactivate!(formulation, function)
It is also possible to deactivate variables and constraints such that
`function(varconstrid)` returns `true`.
"""
function deactivate!(form::Formulation, constr::Constraint)
_deactivate!(form, constr)
for varid in constr.art_var_ids
_deactivate!(form, getvar(form, varid))
end
return
end
deactivate!(form::Formulation, var::Variable) = _deactivate!(form, var)
function deactivate!(form::Formulation, varconstrid::Id{VC}) where {VC<:AbstractVarConstr}
elem = getelem(form, varconstrid)
@assert !isnothing(elem)
return deactivate!(form, elem)
end
function deactivate!(form::Formulation, f::Function)
for (varid, var) in getvars(form)
if iscuractive(form, var) && f(varid)
deactivate!(form, var)
end
end
for (constrid, constr) in getconstrs(form)
if iscuractive(form, constr) && f(constrid)
deactivate!(form, constr)
end
end
return
end
## delete
"""
delete!(formulation, varconstr)
delete!(formulation, varconstrid)
Delete a variable or a constraint from a formulation.
"""
function Base.delete!(form::Formulation, var::Variable)
varid = getid(var)
definitive_deletion!(form.buffer, var)
delete!(form.manager.vars, varid)
return
end
function Base.delete!(form::Formulation, id::VarId)
var = getvar(form, id)
@assert !isnothing(var)
return delete!(form, var)
end
function Base.delete!(form::Formulation, constr::Constraint)
definitive_deletion!(form.buffer, constr)
constrid = getid(constr)
coefmatrix = getcoefmatrix(form)
varids = VarId[]
for (varid, _) in @view coefmatrix[constrid, :]
push!(varids, varid)
end
for varid in varids
coefmatrix[constrid, varid] = 0.0
end
delete!(form.manager.constrs, constrid)
return
end
function Base.delete!(form::Formulation, id::ConstrId)
constr = getconstr(form, id)
@assert !isnothing(constr)
return delete!(form, constr)
end
## explicit
"""
isexplicit(formulation, varconstr)
isexplicit(formulation, varconstrid)
Return `true` if a variable or a constraint is explicit in a formulation; `false` otherwise.
"""
function isexplicit(form::Formulation, varid::VarId)
var = getvar(form, varid)
@assert !isnothing(var)
return isexplicit(form, var)
end
isexplicit(::Formulation, var::Variable) = var.perendata.is_explicit
function isexplicit(form::Formulation, constrid::ConstrId)
constr = getconstr(form, constrid)
@assert !isnothing(constr)
return isexplicit(form, constr)
end
isexplicit(::Formulation, constr::Constraint) = constr.perendata.is_explicit
## name
"""
getname(formulation, varconstr)
getname(formulation, varconstrid)
Return the name of a variable or a constraint in a formulation.
"""
function getname(form::Formulation, varid::VarId)
var = getvar(form, varid)
@assert !isnothing(var)
return var.name
end
getname(::Formulation, var::Variable) = var.name
function getname(form::Formulation, constrid::ConstrId)
constr = getconstr(form, constrid)
@assert !isnothing(constr)
return constr.name
end
getname(::Formulation, constr::Constraint) = constr.name
## branching_priority
"""
getbranchingpriority(formulation, var)
getbranchingpriority(formulation, varid)
Return the branching priority of a variable
"""
function getbranchingpriority(form::Formulation, varid::VarId)
var = getvar(form, varid)
@assert !isnothing(var)
return getbranchingpriority(form, var)
end
getbranchingpriority(::Formulation, var::Variable) = var.branching_priority
"""
getcustomdata(formulation, var)
getcustomdata(formulation, varid)
getcustomdata(formulation, constr)
getcustomdata(formulation, constrid)
Return the custom data of a variable or a constraint in a formulation.
"""
function getcustomdata(form::Formulation, varid::VarId)
var = getvar(form, varid)
@assert !isnothing(var)
return getcustomdata(form, var)
end
getcustomdata(::Formulation, var::Variable) = var.custom_data
function getcustomdata(form::Formulation, constrid::ConstrId)
constr = getconstr(form, constrid)
@assert !isnothing(constr)
return getcustomdata(form, constr)
end
getcustomdata(::Formulation, constr::Constraint) = constr.custom_data
# Reset (this method is used only in tests... @guimarqu doesn't know if we should keep it)
"""
reset!(form, var)
reset!(form, varid)
reset!(form, constr)
reset!(form, constraint)
doc todo
"""
function reset!(form::Formulation, var::Variable)
setcurcost!(form, var, getperencost(form, var))
setcurlb!(form, var, getperenlb(form, var))
setcurub!(form, var, getperenub(form, var))
setcurkind!(form, var, getperenkind(form, var))
setcurincval!(form, var, getperenincval(form, var))
if isperenactive(form, var)
activate!(form, var)
else
deactivate!(form, var)
end
return
end
reset!(form::Formulation, varid::VarId) = reset!(form, getvar(form, varid))
function reset!(form::Formulation, constr::Constraint)
setcurrhs!(form, constr, getperenrhs(form, constr))
setcursense!(form, constr, getperensense(form, constr))
setcurincval!(form, constr , getperenincval(form, constr))
if isperenactive(form, constr)
activate!(form, constr)
else
deactivate!(form, constr)
end
return
end
reset!(form::Formulation, constrid::ConstrId) = reset!(form, getconstr(form,constrid))
| Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 2458 | abstract type AbstractVarData <: AbstractVcData end
mutable struct VarData <: AbstractVcData
cost::Float64
lb::Float64
ub::Float64
kind::VarKind
inc_val::Float64
is_active::Bool
is_explicit::Bool
is_in_partial_sol::Bool
end
"""
VarData
Information that defines a state of a variable.
"""
function VarData(
;cost::Float64 = 0.0, lb::Float64 = 0.0, ub::Float64 = Inf, kind::VarKind = Continuous,
inc_val::Float64 = -1.0, is_active::Bool = true, is_explicit::Bool = true
)
vc = VarData(cost, lb, ub, kind, inc_val, is_active, is_explicit, false)
return vc
end
VarData(vd::VarData) = VarData(
vd.cost, vd.lb, vd.ub, vd.kind, vd.inc_val, vd.is_active, vd.is_explicit, vd.is_in_partial_sol
)
"""
MoiVarRecord
Structure to hold the pointers to the MOI representation of a Coluna Variable.
"""
mutable struct MoiVarRecord
index::MoiVarIndex
lower_bound::Union{Nothing, MoiVarLowerBound}
upper_bound::Union{Nothing, MoiVarUpperBound}
kind::MoiVarKind
end
function MoiVarRecord(;index::MoiVarIndex = MoiVarIndex())
return MoiVarRecord(index, MoiVarLowerBound(), MoiVarUpperBound(), MoiVarKind())
end
getmoiindex(record::MoiVarRecord)::MoiVarIndex = record.index
getlowerbound(record::MoiVarRecord) = record.lower_bound
getupperbound(record::MoiVarRecord) = record.upper_bound
getkind(record::MoiVarRecord) = record.kind
setmoiindex!(record::MoiVarRecord, index::MoiVarIndex) = record.index = index
setlowerbound!(record::MoiVarRecord, bound::MoiVarLowerBound) = record.lower_bound = bound
setupperbound!(record::MoiVarRecord, bound::MoiVarUpperBound) = record.upper_bound = bound
setkind!(record::MoiVarRecord, kind::MoiVarKind) = record.kind = kind
"""
Variable
Representation of a variable in Coluna.
"""
mutable struct Variable <: AbstractVarConstr
id::Id{Variable}
name::String
perendata::VarData
curdata::VarData
branching_priority::Float64
moirecord::MoiVarRecord
custom_data::Union{Nothing, BD.AbstractCustomVarData}
end
const VarId = Id{Variable}
getid(var::Variable) = var.id
function Variable(
id::VarId, name::String; var_data = VarData(), moi_index::MoiVarIndex = MoiVarIndex(),
custom_data::Union{Nothing, BD.AbstractCustomVarData} = nothing, branching_priority = 1.0
)
return Variable(
id, name, var_data, VarData(var_data), branching_priority,
MoiVarRecord(index = moi_index), custom_data
)
end
| Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 4492 | """
Coluna identifier of a `Variable` or a `Constraint`.
The identifier is a subtype of `Integer` so we can use it as index of sparse arrays.
It behaves like an integer (field `uid`) with additional information (other fields).
It is composed by the following ids:
1. `uid`: unique id that is global to the Coluna instance (the integer)
2. `origin_form_uid`: unique id of the formulation where it was generated
3. `assigned_form_uid`: unique id of the formulation where it is assigned in the reformulation process
For a JuMP variable/constraint the `origin_form_uid` is the original formulation while the
`assigned_form_uid` is the subproblem formulation for a pure subproblem variable/constraint
and the master for a pure master variable/constraint.
For a variable/constraint generated during optimization, the `origin_form_uid` is
the id of the formulation where it was created.
For instance, the origin formulation of a master column is the subproblem for which the
column is a solution and its assigned formulation is the master.
"""
struct Id{VC <: AbstractVarConstr} <: Integer
duty::Duty{VC}
uid::Int
origin_form_uid::FormId
assigned_form_uid::FormId
custom_family_id::Int8
end
function Id{VC}(
duty::Duty{VC}, uid::Integer, origin_form_uid::Integer;
assigned_form_uid::Integer = origin_form_uid,
custom_family_id::Integer = -1
) where {VC}
return Id{VC}(duty, uid, origin_form_uid, assigned_form_uid, custom_family_id)
end
function Id{VC}(
orig_id::Id{VC};
duty::Union{Nothing, Duty{VC}} = nothing,
origin_form_uid::Union{Nothing, Integer} = nothing,
assigned_form_uid::Union{Nothing, Integer} = nothing,
custom_family_id::Union{Nothing, Integer} = nothing,
) where {VC}
duty = isnothing(duty) ? orig_id.duty : duty
origin_form_uid = isnothing(origin_form_uid) ? orig_id.origin_form_uid : origin_form_uid
assigned_form_uid = isnothing(assigned_form_uid) ? orig_id.assigned_form_uid : assigned_form_uid
custom_family_id = isnothing(custom_family_id) ? orig_id.custom_family_id : custom_family_id
return Id{VC}(duty, orig_id.uid, origin_form_uid, assigned_form_uid, custom_family_id)
end
# Use of this method should be avoided as much as possible.
# If you face a `VarId` or a `ConstrId` without any additional information, it can mean:
# - the id does not exist but an integer of type Id was needed (e.g. size of sparse vector);
# - information have been lost because of chain of converts (e.g. Id with info -> Int -> Id without info)
Id{VC}(uid::Integer) where VC = Id{VC}(Duty{VC}(0), uid, -1, -1, -1)
Base.hash(a::Id, h::UInt) = hash(a.uid, h)
Base.zero(I::Type{Id{VC}}) where {VC} = I(0)
Base.zero(::Id{VC}) where {VC} = Id{VC}(0)
Base.one(I::Type{Id{VC}}) where {VC} = I(1)
Base.typemax(I::Type{Id{VC}}) where {VC} = I(Coluna.MAX_NB_ELEMS)
Base.isequal(a::Id{VC}, b::Id{VC}) where {VC} = isequal(a.uid, b.uid)
Base.promote_rule(::Type{T}, ::Type{<:Id}) where {T<:Integer} = T
Base.promote_rule(::Type{<:Id}, ::Type{T}) where {T<:Integer} = T
Base.promote_rule(::Type{<:Id}, ::Type{<:Id}) = Int
# Promotion mechanism will never call the following rule:
# Base.promote_rule(::Type{I}, ::Type{I}) where {I<:Id} = Int32
#
# The problem is that an Id is an integer with additional information and we
# cannot generate additional information of a new id from the operation of two
# existing ids.
# As we want that all operations on ids results on operations on the uid,
# we redefine the promotion mechanism for Ids so that operations on Ids return integer:
Base.promote_type(::Type{I}, ::Type{I}) where {I<:Id} = Int
Base.convert(::Type{Int}, id::I) where {I<:Id} = Int(id.uid)
Base.convert(::Type{Int32}, id::I) where {I<:Id} = id.uid
Base.:(<)(a::Id{VC}, b::Id{VC}) where {VC} = a.uid < b.uid
Base.:(<=)(a::Id{VC}, b::Id{VC}) where {VC} = a.uid <= b.uid
Base.:(==)(a::Id{VC}, b::Id{VC}) where {VC} = a.uid == b.uid
Base.:(>)(a::Id{VC}, b::Id{VC}) where {VC} = a.uid > b.uid
Base.:(>=)(a::Id{VC}, b::Id{VC}) where {VC} = a.uid >= b.uid
ClB.getuid(id::Id) = id.uid # TODO: change name
getduty(vcid::Id{VC}) where {VC} = vcid.duty
getoriginformuid(id::Id) = id.origin_form_uid
getassignedformuid(id::Id) = id.assigned_form_uid
getsortuid(id::Id) = getuid(id)
function Base.show(io::IO, id::Id{T}) where {T}
print(io, T, "u", id.uid)
end
# Methods that Id needs to implement (otherwise error):
Base.sub_with_overflow(a::I, b::I) where {I<:Id} = Base.sub_with_overflow(a.uid, b.uid) | Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 2560 | """
Exposes `@mustimplement` macro to help developers identifying API definitions.
"""
module MustImplement
using Random
"""
IncompleteInterfaceError <: Exception
Exception to be thrown when an interface function is called without default implementation.
"""
struct IncompleteInterfaceError <: Exception
trait::String # Like the name of the interface
func_signature::String
end
function Base.showerror(io::IO, e::IncompleteInterfaceError)
msg = """
Incomplete implementation of interface $(e.trait).
$(e.func_signature) not implemented.
"""
println(io, msg)
return
end
"""
@mustimplement "Interface name" f(a,b,c) = nothing
Converts into a fallback for function `f(a,b,c)` that throws a `IncompleteInterfaceError`.
"""
macro mustimplement(interface_name, sig)
if !(sig.head == :(=) && sig.args[1].head == :call && sig.args[2].head == :block)
err_msg = """
Cannot generate fallback for function $(string(sig)).
Got:
- sig.head = $(sig.head) instead of :(=)
- sig.args[1].head = $(sig.args[1].head) instead of :call
- sig.args[2].head = $(sig.args[2].head) instead of :block
"""
error(err_msg)
end
sig = sig.args[1] # we only consider the call.
str_interface_name = string(interface_name)
fname = string(sig.args[1])
args = reduce(sig.args[2:end]; init = Union{String,Expr}[]) do collection, arg
varname = if isa(arg, Symbol) # arg without type
arg
elseif isa(arg, Expr) && arg.head == :(::) # variable with its type
if length(arg.args) == 1 # :(::Type) case
varname = Symbol(randstring('a':'z', 24))
vartype = arg.args[1]
arg.args = [varname, vartype] # change signature of the method
varname
elseif length(arg.args) == 2 # :(var::Type) case
arg.args[1]
else
nothing
end
else
nothing
end
if !isnothing(varname)
push!(collection, "::", :(typeof($(esc(varname)))), ", ")
end
return collection
end
if length(args) > 0
pop!(args)
end
type_of_args_expr = Expr(:tuple, args...)
return quote
$(esc(sig)) = throw(
IncompleteInterfaceError(
$str_interface_name,
string($fname, "(", $type_of_args_expr..., ")")
)
)
end
end
export @mustimplement, IncompleteInterfaceError
end | Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 48 | module Tests
include("Parser/Parser.jl")
end | Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 29941 | module Parser
using Coluna, DynamicSparseArrays
const CL = Coluna
const ClMP = Coluna.MathProg
const ClB = Coluna.ColunaBase
const _KW_HEADER = Val{:header}()
const _KW_MASTER = Val{:master}()
const _KW_SUBPROBLEM = Val{:subproblem}()
const _KW_SEPARATION = Val{:separation}()
const _KW_BOUNDS = Val{:bounds}()
const _KW_GLOBAL_BOUNDS = Val{:global_bounds}()
const _KW_CONSTRAINTS = Val{:constraints}()
const _KW_ORIGIN = Val{:origin}()
const _KW_SP_SOLUTIONS = Val{:sp_solutions}()
const _KW_SECTION = Dict(
# _KW_MASTER
"master" => _KW_MASTER,
# _KW_SUBPROBLEM
"dw_sp" => _KW_SUBPROBLEM,
"sp" => _KW_SUBPROBLEM,
# _KW_SEPARATION
"benders_sp" => _KW_SEPARATION,
# Integ
"int" => ClMP.Integ,
"integer" => ClMP.Integ,
"integers" => ClMP.Integ,
# Continuous
"cont" => ClMP.Continuous,
"continuous" => ClMP.Continuous,
# Binary
"bin" => ClMP.Binary,
"binary" => ClMP.Binary,
"binaries" => ClMP.Binary,
# _KW_BOUNDS
"bound" => _KW_BOUNDS,
"bounds" => _KW_BOUNDS,
# _KW_GLOBAL_BOUNDS
"global_bound" => _KW_GLOBAL_BOUNDS,
"global_bounds" => _KW_GLOBAL_BOUNDS,
)
const _KW_SUBSECTION = Dict(
# MaxSense
"max" => CL.MaxSense,
"maximize" => CL.MaxSense,
"maximise" => CL.MaxSense,
"maximum" => CL.MaxSense,
# MinSense
"min" => CL.MinSense,
"minimize" => CL.MinSense,
"minimise" => CL.MinSense,
"minimum" => CL.MinSense,
# _KW_CONSTRAINTS
"subject to" => _KW_CONSTRAINTS,
"such that" => _KW_CONSTRAINTS,
"st" => _KW_CONSTRAINTS,
"s.t." => _KW_CONSTRAINTS,
"solutions" => _KW_SP_SOLUTIONS,
# Origin of variables
"origin" => _KW_ORIGIN,
# MasterPureVar
"pure" => ClMP.MasterPureVar,
"pures" => ClMP.MasterPureVar,
# MasterRepPricingVar
"representative" => ClMP.MasterRepPricingVar,
"representatives" => ClMP.MasterRepPricingVar,
# DwSpPricingVar
"pricing" => ClMP.DwSpPricingVar,
# MasterArtVar
"artificial" => ClMP.MasterArtVar,
"artificials" => ClMP.MasterArtVar,
# MasterColumns
"columns" => ClMP.MasterCol,
# MasterRepPricingSetupVar
"pricing_setup" => ClMP.MasterRepPricingSetupVar,
# Benders first stage variable
"first_stage" => ClMP.MasterPureVar,
"second_stage_cost" => ClMP.MasterBendSecondStageCostVar,
# Benders second stage variable
"second_stage" => ClMP.BendSpSepVar,
"second_stage_artificial" => ClMP.BendSpSecondStageArtVar
)
const _KW_CONSTR_DUTIES = Dict(
"MasterConvexityConstr" => ClMP.MasterConvexityConstr,
"BendTechConstr" => ClMP.BendSpTechnologicalConstr,
)
const coeff_re = "\\d+(\\.\\d+)?"
struct UndefObjectiveParserError <: Exception end
export UndefObjectiveParserError
struct UndefVarParserError <: Exception
msg::String
end
export UndefVarParserError
mutable struct ExprCache
vars::Dict{String, Float64}
constant::Float64
end
mutable struct VarCache
kind::ClMP.VarKind
duty::ClMP.Duty
lb::Float64
ub::Float64
global_lb::Float64
global_ub::Float64
end
mutable struct ConstrCache
lhs::ExprCache
sense::ClMP.ConstrSense
rhs::Float64
duty::Union{Nothing,ClMP.Duty}
end
mutable struct SolutionCache
lhs::ExprCache
col_name::String
end
mutable struct ProblemCache
sense::Type{<:ClB.AbstractSense}
objective::ExprCache
constraints::Vector{ConstrCache}
origin::Set{String} # names of variables.
solutions::Vector{SolutionCache}
generated_formulation::Union{Coluna.MathProg.Formulation,Nothing}
end
mutable struct ReadCache
benders_sp_type::Bool
dw_sp_type::Bool
master::ProblemCache
subproblems::Dict{Int64,ProblemCache}
variables::Dict{String,VarCache}
end
function Base.showerror(io::IO, ::UndefObjectiveParserError)
msg = "No objective function provided"
println(io, msg)
end
function Base.showerror(io::IO, e::UndefVarParserError)
println(io, e.msg)
return
end
function ReadCache()
return ReadCache(
false, false,
ProblemCache(
CL.MinSense,
ExprCache(
Dict{String, Float64}(), 0.0
),
ConstrCache[],
Set{String}(),
SolutionCache[],
nothing
),
Dict{Int64,ProblemCache}(),
Dict{String,VarCache}()
)
end
function _strip_identation(l::AbstractString)
m = match(r"^(\s+)(.+)", l)
if !isnothing(m)
return m[2]
end
return l
end
function _strip_line(l::AbstractString)
new_line = ""
for m in eachmatch(r"[^\s]+", l)
new_line = string(new_line, m.match)
end
return new_line
end
function _get_vars_list(l::AbstractString)
vars = String[]
for m in eachmatch(r"(\w+)", l)
push!(vars, String(m[1]))
end
return vars
end
function _read_expression(l::AbstractString)
line = _strip_line(l)
vars = Dict{String, Float64}()
constant = 0.0
first_m = match(Regex("^([+-])?($coeff_re)?\\*?([a-zA-Z]+\\w*)?(.*)"), line) # first element of expr
if !isnothing(first_m)
sign = isnothing(first_m[1]) ? "+" : first_m[1] # has a sign
coeff = isnothing(first_m[2]) ? "1" : first_m[2] # has a coefficient
cost = parse(Float64, string(sign, coeff))
vars[String(first_m[4])] = cost
for m in eachmatch(Regex("([+-])($coeff_re)?\\*?([a-zA-Z]+\\w*)?"), first_m[5]) # rest of the elements
coeff = isnothing(m[2]) ? "1" : m[2]
cost = parse(Float64, string(m[1], coeff))
if isnothing(m[4])
constant += cost
else
vars[String(m[4])] = cost
end
end
end
return ExprCache(vars, constant)
end
function _read_constraint(l::AbstractString)
line = _strip_line(l)
m = match(Regex("(.+)(>=|<=|==)(-?$coeff_re)(\\{([a-zA-Z]+)\\})?"), line)
if !isnothing(m)
lhs = _read_expression(m[1])
sense = if m[2] == ">="
ClMP.Greater
else
if m[2] == "<="
ClMP.Less
else
ClMP.Equal
end
end
rhs = parse(Float64, m[3])
duty = isnothing(m[6]) ? nothing : _KW_CONSTR_DUTIES[m[6]]
return ConstrCache(lhs, sense, rhs, duty)
end
return nothing
end
function _read_solution(l::AbstractString)
line = _strip_line(l)
m = match(Regex("(.+)\\{([a-zA-Z_][a-zA-Z_0-9]*)\\}?"), line)
if !isnothing(m)
lhs = _read_expression(m[1])
col_name = m[2]
return SolutionCache(lhs, col_name)
end
return nothing
end
function _read_bounds(l::AbstractString, r::Regex)
line = _strip_line(l)
vars = String[]
bound1, bound2 = ("","")
m = match(r, line)
if !isnothing(m)
vars = _get_vars_list(m[4]) # separate variables as "x_1, x_2" into a list [x_1, x_2]
if !isnothing(m[1]) # has lower bound (nb <= var) or upper bound (nb >= var)
bound1 = String(m[2])
end
if !isnothing(m[5]) # has upper bound (var <= nb) or lower bound (var >= nb)
bound2 = String(m[6])
end
end
return vars, bound1, bound2
end
function read_master!(sense::Type{<:ClB.AbstractSense}, cache::ReadCache, line::AbstractString)
obj = _read_expression(line)
cache.master.sense = sense
cache.master.objective = obj
end
function read_master!(::Val{:constraints}, cache::ReadCache, line::AbstractString)
constr = _read_constraint(line)
if !isnothing(constr)
push!(cache.master.constraints, constr)
end
end
read_master!(::Any, cache::ReadCache, line::AbstractString) = nothing
function read_subproblem!(sense::Type{<:ClB.AbstractSense}, cache::ReadCache, line::AbstractString, nb_sp::Int64)
obj = _read_expression(line)
if haskey(cache.subproblems, nb_sp)
cache.subproblems[nb_sp].sense = sense
cache.subproblems[nb_sp].obj = obj
else
cache.subproblems[nb_sp] = ProblemCache(sense, obj, [], Set{String}(), [], nothing)
end
end
function read_subproblem!(::Val{:constraints}, cache::ReadCache, line::AbstractString, nb_sp::Int64)
constr = _read_constraint(line)
if !isnothing(constr)
if haskey(cache.subproblems, nb_sp)
push!(cache.subproblems[nb_sp].constraints, constr)
end
end
end
function read_subproblem!(::Val{:origin}, cache::ReadCache, line::AbstractString, nb_sp::Int64)
vars = _get_vars_list(line)
for var in vars
push!(cache.subproblems[nb_sp].origin, var)
end
return
end
function read_subproblem!(::Val{:sp_solutions}, cache::ReadCache, line::AbstractString, nb_sp::Int64)
solution = _read_solution(line)
if !isnothing(solution)
push!(cache.subproblems[nb_sp].solutions, solution)
end
return
end
function read_bounds!(cache::ReadCache, line::AbstractString)
vars = String[]
if occursin("<=", line)
less_r = Regex("(($coeff_re)<=)?([\\w,]+)(<=($coeff_re))?")
vars, lb, ub = _read_bounds(line, less_r)
end
if occursin(">=", line)
greater_r = Regex("(($coeff_re)>=)?([\\w,]+)(>=($coeff_re))?")
vars, ub, lb = _read_bounds(line, greater_r)
end
for v in vars
if haskey(cache.variables, v)
if lb != ""
cache.variables[v].lb = parse(Float64, lb)
end
if ub != ""
cache.variables[v].ub = parse(Float64, ub)
end
end
end
end
function read_global_bounds!(cache::ReadCache, line::AbstractString)
vars = String[]
if occursin("<=", line)
less_r = Regex("(($coeff_re)<=)?([\\w,]+)(<=($coeff_re))?")
vars, lb, ub = _read_bounds(line, less_r)
end
if occursin(">=", line)
greater_r = Regex("(($coeff_re)>=)?([\\w,]+)(>=($coeff_re))?")
vars, ub, lb = _read_bounds(line, greater_r)
end
for v in vars
if haskey(cache.variables, v)
if lb != ""
cache.variables[v].global_lb = parse(Float64, lb)
end
if ub != ""
cache.variables[v].global_ub = parse(Float64, ub)
end
end
end
end
function read_variables!(kind::ClMP.VarKind, duty::ClMP.Duty, cache::ReadCache, line::AbstractString)
vars = _get_vars_list(line)
for v in vars
cache.variables[v] = VarCache(kind, duty, -Inf, Inf, -Inf, Inf)
end
end
read_variables!(::Any, ::Any, ::ReadCache, ::AbstractString) = nothing
function create_subproblems!(::Val{:subproblem}, env::Env{ClMP.VarId}, cache::ReadCache, ::Nothing)
i = 1
constraints = ClMP.Constraint[]
subproblems = ClMP.Formulation{ClMP.DwSp}[]
all_spvars = Dict{String, Tuple{ClMP.Variable, ClMP.Formulation{ClMP.DwSp}}}()
for (_, sp) in cache.subproblems
spform = nothing
for (varid, cost) in sp.objective.vars
if haskey(cache.variables, varid)
var = cache.variables[varid]
if var.duty <= ClMP.DwSpPricingVar || var.duty <= ClMP.MasterRepPricingVar || var.duty <= ClMP.MasterRepPricingSetupVar
if isnothing(spform)
spform = ClMP.create_formulation!(
env,
ClMP.DwSp(nothing, nothing, nothing, ClMP.Integ);
obj_sense = sp.sense
)
sp.generated_formulation = spform
end
duty = ClMP.DwSpPricingVar
if var.duty <= ClMP.MasterRepPricingSetupVar
duty = ClMP.DwSpSetupVar
end
v = ClMP.setvar!(spform, varid, duty; lb = var.lb, ub = var.ub, kind = var.kind)
if var.duty <= ClMP.DwSpSetupVar
spform.duty_data.setup_var = ClMP.getid(v)
end
ClMP.setperencost!(spform, v, cost)
all_spvars[varid] = (v, spform)
end
else
throw(UndefVarParserError("Variable $varid duty and/or kind not defined"))
end
end
for constr in sp.constraints
members = Dict{Coluna.MathProg.VarId,Float64}()
for (varid, coeff) in constr.lhs.vars
if !iszero(coeff)
members[ClMP.getid(all_spvars[varid][1])] = coeff
end
end
c = ClMP.setconstr!(spform, "sp_c$i", ClMP.DwSpPureConstr; rhs = constr.rhs, sense = constr.sense, members = members)
push!(constraints, c)
i += 1
end
push!(subproblems, spform)
end
return subproblems, all_spvars, constraints
end
function create_subproblems!(::Val{:separation}, env::Env{ClMP.VarId}, cache::ReadCache, master, mastervars)
i = 1
constraints = ClMP.Constraint[]
subproblems = ClMP.Formulation{ClMP.BendersSp}[]
all_spvars = Dict{String, Tuple{ClMP.Variable, ClMP.Formulation{ClMP.BendersSp}}}()
for (_, sp) in cache.subproblems
spform = ClMP.create_formulation!(
env,
ClMP.BendersSp();
obj_sense = sp.sense
)
for (varid, cost) in sp.objective.vars
if haskey(cache.variables, varid)
var = cache.variables[varid]
if var.duty <= ClMP.BendSpSecondStageArtVar || var.duty <= ClMP.BendSpSepVar
explicit = true
duty = var.duty
v = ClMP.setvar!(spform, varid, duty; lb = var.lb, ub = var.ub, kind = var.kind, is_explicit = explicit)
ClMP.setperencost!(spform, v, cost)
all_spvars[varid] = (v, spform)
end
if var.duty <= ClMP.MasterPureVar || var.duty <= ClMP.MasterBendSecondStageCostVar
if var.duty <= ClMP.MasterPureVar
duty = ClMP.BendSpFirstStageRepVar
explicit = false
end
if var.duty <= ClMP.MasterBendSecondStageCostVar
duty = ClMP.BendSpCostRepVar
explicit = false
end
master_var = mastervars[varid]
v = ClMP.clonevar!(master, spform, master, master_var, duty; cost = ClMP.getcurcost(master, master_var), is_explicit = false)
all_spvars[varid] = (v, spform)
if var.duty <= ClMP.MasterBendSecondStageCostVar
spform.duty_data.second_stage_cost_var = ClMP.getid(v)
end
end
else
throw(UndefVarParserError("Variable $varid duty and/or kind not defined"))
end
end
for constr in sp.constraints
duty = ClMP.BendSpPureConstr
if !isnothing(constr.duty)
duty = constr.duty
@assert duty <= ClMP.BendSpTechnologicalConstr
end
members = Dict{Coluna.MathProg.VarId,Float64}()
for (varid, coeff) in constr.lhs.vars
if !iszero(coeff)
members[ClMP.getid(all_spvars[varid][1])] = coeff
end
end
c = ClMP.setconstr!(spform, "sp_c$i", duty; rhs = constr.rhs, sense = constr.sense, members = members)
push!(constraints, c)
i += 1
end
push!(subproblems, spform)
end
return subproblems, all_spvars, constraints
end
function _get_orig_spid_of_col(cache::ReadCache, varname::String)
for (spid, sp) in cache.subproblems
if varname ∈ sp.origin
return spid
end
end
return nothing
end
function _get_orig_sp_of_col(cache::ReadCache, varname::String, default)
# find the subproblem th
id = _get_orig_spid_of_col(cache, varname)
if !isnothing(id)
return cache.subproblems[id].generated_formulation
end
return default
end
function add_dw_master_vars!(master::ClMP.Formulation, master_duty, all_spvars::Dict, cache::ReadCache)
mastervars = Dict{String, ClMP.Variable}()
for (varid, cost) in cache.master.objective.vars
if haskey(cache.variables, varid)
var_cache = cache.variables[varid]
if var_cache.duty <= ClMP.AbstractOriginMasterVar ||
var_cache.duty <= ClMP.AbstractAddedMasterVar
if var_cache.duty <= ClMP.MasterCol
origin_sp = _get_orig_sp_of_col(cache, varid, master)
v = ClMP.setvar!(
master,
varid,
var_cache.duty;
lb = var_cache.lb,
ub = var_cache.ub,
kind = ClMP.Integ,
is_explicit = true,
origin = origin_sp
)
else
is_explicit = !(var_cache.duty <= ClMP.AbstractImplicitMasterVar)
v = ClMP.setvar!(
master,
varid,
var_cache.duty;
lb = var_cache.lb,
ub = var_cache.ub,
kind = var_cache.kind,
is_explicit = is_explicit
)
end
else
if haskey(all_spvars, varid)
var, sp = all_spvars[varid]
duty = ClMP.MasterRepPricingVar
explicit = false
if ClMP.getduty(ClMP.getid(var)) <= ClMP.DwSpSetupVar
duty = ClMP.MasterRepPricingSetupVar
elseif ClMP.getduty(ClMP.getid(var)) <= ClMP.BendSpFirstStageRepVar
duty = ClMP.MasterPureVar
explicit = true
end
lb, ub, kind = if duty == ClMP.MasterRepPricingVar
# the representative of a binary variable in the master is integer in general
mast_kind = ClMP.getperenkind(sp, var) ==
ClMP.Continuous ? ClMP.Continuous : ClMP.Integ
var_cache.global_lb, var_cache.global_ub, mast_kind
else
ClMP.getperenlb(sp, var),
ClMP.getperenub(sp, var),
ClMP.getperenkind(sp, var)
end
v = ClMP.clonevar!(
sp,
master,
sp,
var,
duty;
cost = ClMP.getcurcost(sp, var),
is_explicit = explicit,
lb = lb,
ub = ub,
kind = kind
)
else
throw(UndefVarParserError("Variable $varid not present in any subproblem"))
end
end
ClMP.setperencost!(master, v, cost)
mastervars[varid] = v
else
throw(UndefVarParserError("Variable $varid duty and/or kind not defined"))
end
end
return mastervars
end
function add_master_columns!(master::ClMP.Formulation, all_spvars::Dict, cache::ReadCache)
for (_, sp) in cache.subproblems
#pool = ClMP.get_primal_sol_pool(spform)
for cache_solution in sp.solutions
isempty(cache_solution.lhs.vars) && continue
vars = ClMP.VarId[]
vals = Float64[]
for (varid, coeff) in cache_solution.lhs.vars
if !iszero(coeff)
push!(vars, ClMP.getid(all_spvars[varid][1]))
push!(vals, coeff)
end
end
spform = sp.generated_formulation
sp_sol = ClMP.PrimalSolution(spform, vars, vals, 0.0, ClMP.FEASIBLE_SOL)
ClMP.insert_column!(master, sp_sol, cache_solution.col_name; id_as_name_suffix=false)
end
end
end
function add_bend_master_vars!(master::ClMP.Formulation, master_duty, cache::ReadCache)
mastervars = Dict{String, ClMP.Variable}()
for (varid, cost) in cache.master.objective.vars
if haskey(cache.variables, varid)
var = cache.variables[varid]
v = ClMP.setvar!(master, varid, var.duty; lb = var.lb, ub = var.ub, kind = var.kind, is_explicit = true)
ClMP.setperencost!(master, v, cost)
mastervars[varid] = v
else
throw(UndefVarParserError("Variable $varid duty and/or kind not defined"))
end
end
return mastervars
end
function add_master_constraints!(subproblems, master::ClMP.Formulation, mastervars::Dict{String, ClMP.Variable}, constraints::Vector{ClMP.Constraint}, cache::ReadCache)
#create master constraints
i = 1
for constr in cache.master.constraints
members = Dict{ClMP.VarId, Float64}()
constr_duty = ClMP.MasterPureConstr
if !isnothing(constr.duty)
constr_duty = constr.duty
end
for (varid, coeff) in constr.lhs.vars
if haskey(cache.variables, varid)
var = cache.variables[varid]
if var.duty <= ClMP.DwSpPricingVar || var.duty <= ClMP.MasterRepPricingVar # check if should be a MasterMixedConstr
constr_duty = ClMP.MasterMixedConstr
end
if haskey(mastervars, varid)
if !iszero(coeff)
push!(members, ClMP.getid(mastervars[varid]) => coeff)
end
else
throw(UndefVarParserError("Variable $varid not present in objective function"))
end
else
throw(UndefVarParserError("Variable $varid duty and/or kind not defined"))
end
end
c = ClMP.setconstr!(master, "c$i", constr_duty; rhs = constr.rhs, sense = constr.sense, members = members)
if constr_duty <= ClMP.MasterConvexityConstr
setup_var_id = collect(keys(filter(x -> ClMP.getduty(x[1]) <= ClMP.MasterRepPricingSetupVar, members)))[1]
spform = collect(values(filter(sp -> haskey(sp, setup_var_id), subproblems)))[1] # dw pricing sps
if constr.sense == ClMP.Less
spform.duty_data.upper_multiplicity_constr_id = ClMP.getid(c)
elseif constr.sense == ClMP.Greater
spform.duty_data.lower_multiplicity_constr_id = ClMP.getid(c)
else
throw(UndefConstraintParserError("Convexity constraint $c must be <= or >="))
end
end
push!(constraints, c)
i += 1
end
end
function reformfromcache(cache::ReadCache)
if isempty(cache.master.objective.vars)
throw(UndefObjectiveParserError())
end
if isempty(cache.variables)
throw(UndefVarParserError("No variable duty and kind defined"))
end
env = Env{ClMP.VarId}(CL.Params())
dec = cache.benders_sp_type ? Val(:separation) : Val(:subproblem)
master_duty = cache.benders_sp_type ? ClMP.BendersMaster() : ClMP.DwMaster()
dw_sps = Dict{ClMP.FormId, ClMP.Formulation{ClMP.DwSp}}()
benders_sps = Dict{ClMP.FormId, ClMP.Formulation{ClMP.BendersSp}}()
origform = ClMP.create_formulation!(
env,
ClMP.Original();
obj_sense = cache.master.sense,
)
# Create master first.
master = ClMP.create_formulation!(
env,
master_duty;
obj_sense = cache.master.sense,
)
# ugly trick here.
dw_sps = Dict{ClMP.FormId, ClMP.Formulation{ClMP.DwSp}}()
benders_sps = Dict{ClMP.FormId, ClMP.Formulation{ClMP.BendersSp}}()
reform = ClMP.Reformulation(env, origform, master, dw_sps, benders_sps)
master.parent_formulation = reform
# Populate master & create subproblems then.
if cache.benders_sp_type
mastervars = add_bend_master_vars!(master, master_duty, cache)
ClMP.setobjconst!(master, cache.master.objective.constant)
subproblems, all_spvars, constraints = create_subproblems!(dec, env, cache, master, mastervars)
for sp in subproblems
reform.benders_sep_subprs[ClMP.getuid(sp)] = sp
end
add_master_constraints!(subproblems, master, mastervars, constraints, cache)
else
subproblems, all_spvars, constraints = create_subproblems!(dec, env, cache, nothing)
for sp in subproblems
reform.dw_pricing_subprs[ClMP.getuid(sp)] = sp
end
mastervars = add_dw_master_vars!(master, master_duty, all_spvars, cache)
ClMP.setobjconst!(master, cache.master.objective.constant)
add_master_constraints!(subproblems, master, mastervars, constraints, cache)
end
for sp in subproblems
sp.parent_formulation = master
closefillmode!(ClMP.getcoefmatrix(sp))
end
closefillmode!(ClMP.getcoefmatrix(master))
if !cache.benders_sp_type
add_master_columns!(master, all_spvars, cache)
end
return env, master, subproblems, constraints, reform
end
function reformfromstring(s::String)
lines = split(s, "\n", keepempty=false)
cache = ReadCache()
nb_subproblems = 0
nb_separations = 0
section = _KW_HEADER
sub_section = _KW_HEADER
for l in lines
line = _strip_identation(l)
lower_line = lowercase(line)
if haskey(_KW_SECTION, lower_line)
section = _KW_SECTION[lower_line]
if section == _KW_SUBPROBLEM || section == _KW_SEPARATION
nb_subproblems += 1
end
if section == _KW_SUBPROBLEM
cache.dw_sp_type = true
@assert !cache.benders_sp_type
end
if section == _KW_SEPARATION
cache.benders_sp_type = true
@assert !cache.dw_sp_type
end
continue
end
if haskey(_KW_SUBSECTION, lower_line)
sub_section = _KW_SUBSECTION[lower_line]
continue
end
if section == _KW_MASTER
read_master!(sub_section, cache, line)
continue
end
if section == _KW_SUBPROBLEM || section == _KW_SEPARATION
read_subproblem!(sub_section, cache, line, nb_subproblems)
continue
end
if section == _KW_BOUNDS
read_bounds!(cache, line)
continue
end
if section == _KW_GLOBAL_BOUNDS
read_global_bounds!(cache, line)
continue
end
read_variables!(section, sub_section, cache, line)
end
env, master, subproblems, constraints, reform = reformfromcache(cache)
return env, master, subproblems, constraints, reform
end
export reformfromstring
end | Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 2790 | # This module provide an interface to implement tree search algorithms and default
# implementations of the tree search algorithm for some explore strategies.
module TreeSearch
using DataStructures
!true && include("../MustImplement/MustImplement.jl") # linter
using ..MustImplement
!true && include("../interface.jl") # linter
using ..AlgoAPI
# Interface to implement a tree search algorithm.
"""
Contains the definition of the problem tackled by the tree search algorithm and how the
nodes and transitions of the tree search space will be explored.
"""
abstract type AbstractSearchSpace end
"Algorithm that chooses next node to evaluated in the tree search algorithm."
abstract type AbstractExploreStrategy end
"A subspace obtained by successive divisions of the search space."
abstract type AbstractNode end
# The definition of a tree search algorithm is based on three concepts.
"Returns the type of search space depending on the tree-search algorithm and its parameters."
@mustimplement "TreeSearch" search_space_type(::AlgoAPI.AbstractAlgorithm) = nothing
"Creates and returns the search space of a tree search algorithm, its model, and its input."
@mustimplement "TreeSearch" new_space(::Type{<:AbstractSearchSpace}, alg, model, input) = nothing
"Creates and returns the root node of a search space."
@mustimplement "TreeSearch" new_root(::AbstractSearchSpace, input) = nothing
"Returns the parent of a node; `nothing` if the node is the root."
@mustimplement "Node" get_parent(::AbstractNode) = nothing
"Returns the priority of the node depending on the explore strategy."
@mustimplement "Node" get_priority(::AbstractExploreStrategy, ::AbstractNode) = nothing
"Returns the conquer output if the conquer was already run for this node, otherwise returns nothing"
get_conquer_output(::AbstractNode) = nothing
##### Additional methods for the node interface (needed by conquer)
## TODO: move outside TreeSearch module.
@mustimplement "Node" set_records!(::AbstractNode, records) = nothing
"Returns a `String` to display the branching constraint."
@mustimplement "Node" get_branch_description(::AbstractNode) = nothing # printer
"Returns `true` is the node is root; `false` otherwise."
@mustimplement "Node" isroot(::AbstractNode) = nothing # BaB implementation
"Evaluate and generate children. This method has a specific implementation for Coluna."
@mustimplement "TreeSearch" children(sp, n, env) = nothing
"Returns true if stopping criteria are met; false otherwise."
@mustimplement "TreeSearch" stop(::AbstractSearchSpace, untreated_nodes) = nothing
"Returns the output of the tree search algorithm."
@mustimplement "TreeSearch" tree_search_output(::AbstractSearchSpace) = nothing
# Default implementations for some explore strategies.
include("explore.jl")
end | Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 1703 | """
Explore the tree search space with a depth-first strategy.
The next visited node is the last one pushed in the stack of unexplored nodes.
"""
struct DepthFirstStrategy <: AbstractExploreStrategy end
abstract type AbstractBestFirstSearch <: AbstractExploreStrategy end
"""
Explore the tree search space with a best-first strategy.
The next visited node is the one with the highest local dual bound.
"""
struct BestDualBoundStrategy <: AbstractBestFirstSearch end
"Generic implementation of the tree search algorithm for a given explore strategy."
@mustimplement "TreeSearch" tree_search(s::AbstractExploreStrategy, space, env, input) = nothing
function tree_search(::DepthFirstStrategy, space, env, input)
root_node = new_root(space, input)
stack = Stack{typeof(root_node)}()
push!(stack, root_node)
# it is important to call `stop()` function first, as it may update `space`
while !stop(space, stack) && !isempty(stack)
current = pop!(stack)
for child in children(space, current, env)
push!(stack, child)
end
end
return TreeSearch.tree_search_output(space)
end
function tree_search(strategy::AbstractBestFirstSearch, space, env, input)
root_node = new_root(space, input)
pq = PriorityQueue{typeof(root_node), Float64}()
enqueue!(pq, root_node, get_priority(strategy, root_node))
# it is important to call `stop()` function first, as it may update `space`
while !stop(space, pq) && !isempty(pq)
current = dequeue!(pq)
for child in children(space, current, env)
enqueue!(pq, child, get_priority(strategy, child))
end
end
return TreeSearch.tree_search_output(space)
end | Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 3046 | module ColunaTests
using Base.CoreLogging: error
using DynamicSparseArrays, SparseArrays, Coluna, TOML
using ReTest, GLPK, ColunaDemos, JuMP, BlockDecomposition, Random, MathOptInterface, MathOptInterface.Utilities, Base.CoreLogging, Logging
global_logger(ConsoleLogger(stderr, LogLevel(0)))
const MOI = MathOptInterface
const MOIU = MOI.Utilities
const MOIT = MOI.Test
const MOIB = MOI.Bridges
const CleverDicts = MOI.Utilities.CleverDicts
const CL = Coluna
const ClD = ColunaDemos
const BD = BlockDecomposition
const ClB = Coluna.ColunaBase
const ClMP = Coluna.MathProg
const ClA = Coluna.Algorithm
rng = MersenneTwister(1234123)
include("parser.jl")
@testset "Version" begin
coluna_ver = Coluna.version()
toml_ver = VersionNumber(
TOML.parsefile(joinpath(@__DIR__, "..", "Project.toml"))["version"]
)
@test coluna_ver == toml_ver
end
########################################################################################
# Unit tests
########################################################################################
for submodule in ["MustImplement", "ColunaBase", "MathProg", "Algorithm"]
dirpath = joinpath(@__DIR__, "unit", submodule)
for filename in readdir(dirpath)
include(joinpath(dirpath, filename))
end
end
include(joinpath(@__DIR__, "unit", "parser.jl"))
########################################################################################
# Integration tests
########################################################################################
dirpath = joinpath(@__DIR__, "integration")
for filename in readdir(dirpath)
include(joinpath(dirpath, filename))
end
# ########################################################################################
# # MOI integration tests
# ########################################################################################
@testset "MOI integration" begin
include("MathOptInterface/MOI_wrapper.jl")
end
########################################################################################
# E2E tests
########################################################################################
dirpath = joinpath(@__DIR__, "e2e")
for filename in readdir(dirpath)
include(joinpath(dirpath, filename))
end
# ########################################################################################
# # Bugfixes tests
# ########################################################################################
include("bugfixes.jl")
########################################################################################
# Other tests
########################################################################################
dirpath = joinpath(@__DIR__, "old")
for filename in readdir(dirpath)
include(joinpath(dirpath, filename))
end
end | Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 18164 | @testset "Bug fixes" begin
@testset "Issue 425" begin
# Issue #425
# When the user does not provide decomposition, Coluna should optimize the
# original formulation.
# NOTE: this test could be deleted because in MOI integration tests, Coluna
# optimizes the original formulation when there is no decomposition.
coluna = JuMP.optimizer_with_attributes(
Coluna.Optimizer,
"params" => CL.Params(solver=ClA.SolveIpForm()),
"default_optimizer" => GLPK.Optimizer
)
model = BlockModel(coluna, direct_model=true)
@variable(model, x)
@constraint(model, x <= 1)
@objective(model, Max, x)
optimize!(model)
@test JuMP.objective_value(model) == 1.0
@test JuMP.termination_status(model) == MOI.OPTIMAL
end
@testset "empty! empties the Problem" begin
coluna = JuMP.optimizer_with_attributes(
Coluna.Optimizer,
"params" => CL.Params(solver=ClA.SolveIpForm()),
"default_optimizer" => GLPK.Optimizer
)
model = BlockModel(coluna, direct_model=true)
@variable(model, x)
@constraint(model, x <= 1)
@objective(model, Max, x)
optimize!(model)
@test JuMP.objective_value(model) == 1.0
@test JuMP.termination_status(model) == MOI.OPTIMAL
empty!(model)
@variable(model, y)
@constraint(model, y <= 2)
@objective(model, Max, y)
optimize!(model)
@test JuMP.objective_value(model) == 2.0
@test JuMP.termination_status(model) == MOI.OPTIMAL
end
@testset "Decomposition with constant in objective" begin
nb_machines = 4
nb_jobs = 30
c = [12.7 22.5 8.9 20.8 13.6 12.4 24.8 19.1 11.5 17.4 24.7 6.8 21.7 14.3 10.5 15.2 14.3 12.6 9.2 20.8 11.7 17.3 9.2 20.3 11.4 6.2 13.8 10.0 20.9 20.6; 19.1 24.8 24.4 23.6 16.1 20.6 15.0 9.5 7.9 11.3 22.6 8.0 21.5 14.7 23.2 19.7 19.5 7.2 6.4 23.2 8.1 13.6 24.6 15.6 22.3 8.8 19.1 18.4 22.9 8.0; 18.6 14.1 22.7 9.9 24.2 24.5 20.8 12.9 17.7 11.9 18.7 10.1 9.1 8.9 7.7 16.6 8.3 15.9 24.3 18.6 21.1 7.5 16.8 20.9 8.9 15.2 15.7 12.7 20.8 10.4; 13.1 16.2 16.8 16.7 9.0 16.9 17.9 12.1 17.5 22.0 19.9 14.6 18.2 19.6 24.2 12.9 11.3 7.5 6.5 11.3 7.8 13.8 20.7 16.8 23.6 19.1 16.8 19.3 12.5 11.0]
w = [61 70 57 82 51 74 98 64 86 80 69 79 60 76 78 71 50 99 92 83 53 91 68 61 63 97 91 77 68 80; 50 57 61 83 81 79 63 99 82 59 83 91 59 99 91 75 66 100 69 60 87 98 78 62 90 89 67 87 65 100; 91 81 66 63 59 81 87 90 65 55 57 68 92 91 86 74 80 89 95 57 55 96 77 60 55 57 56 67 81 52; 62 79 73 60 75 66 68 99 69 60 56 100 67 68 54 66 50 56 70 56 72 62 85 70 100 57 96 69 65 50]
Q = [1020 1460 1530 1190]
coluna = optimizer_with_attributes(
Coluna.Optimizer,
"params" => Coluna.Params(
solver=Coluna.Algorithm.TreeSearchAlgorithm() # default BCP
),
"default_optimizer" => GLPK.Optimizer # GLPK for the master & the subproblems
)
@axis(M, 1:nb_machines)
J = 1:nb_jobs
model = BlockModel(coluna)
@variable(model, x[m in M, j in J], Bin)
@constraint(model, cov[j in J], sum(x[m, j] for m in M) >= 1)
@constraint(model, knp[m in M], sum(w[m, j] * x[m, j] for j in J) <= Q[m])
@objective(model, Min, sum(c[m, j] * x[m, j] for m in M, j in J) + 2)
@dantzig_wolfe_decomposition(model, decomposition, M)
optimize!(model)
@test objective_value(model) ≈ 307.5 + 2
end
@testset "Issue 424 - solve empty model." begin
# Issue #424
# - If you try to solve an empty model with Coluna using a SolveIpForm or SolveLpForm
# as top solver, the objective value will be 0.
# - If you try to solve an empty model using TreeSearchAlgorithm, then Coluna will
# throw an error because since there is no decomposition, there is no reformulation
# and TreeSearchAlgorithm must be run on a reformulation.
coluna = JuMP.optimizer_with_attributes(
Coluna.Optimizer,
"params" => CL.Params(solver=ClA.SolveIpForm()),
"default_optimizer" => GLPK.Optimizer
)
model = BlockModel(coluna)
optimize!(model)
@test JuMP.objective_value(model) == 0
coluna = JuMP.optimizer_with_attributes(
Coluna.Optimizer,
"params" => CL.Params(solver=ClA.SolveLpForm(get_ip_primal_sol=true)),
"default_optimizer" => GLPK.Optimizer
)
model = BlockModel(coluna)
optimize!(model)
@test JuMP.objective_value(model) == 0
coluna = optimizer_with_attributes(
Coluna.Optimizer,
"params" => Coluna.Params(
solver=Coluna.Algorithm.TreeSearchAlgorithm()
),
"default_optimizer" => GLPK.Optimizer
)
model = BlockModel(coluna)
@test_throws ClB.IncompleteInterfaceError optimize!(model)
end
@testset "Optimize twice (no reformulation + direct model)" begin
# no reformulation + direct model
coluna = JuMP.optimizer_with_attributes(
Coluna.Optimizer,
"params" => CL.Params(solver=ClA.SolveIpForm()),
"default_optimizer" => GLPK.Optimizer
)
model = BlockModel(coluna, direct_model=true)
@variable(model, x)
@constraint(model, x <= 1)
@objective(model, Max, x)
optimize!(model)
@test JuMP.objective_value(model) == 1
optimize!(model)
@test JuMP.objective_value(model) == 1
end
@testset "Optimize twice (no reformulation + no direct model)" begin
coluna = JuMP.optimizer_with_attributes(
Coluna.Optimizer,
"params" => CL.Params(solver=ClA.SolveIpForm()),
"default_optimizer" => GLPK.Optimizer
)
model = BlockModel(coluna)
@variable(model, x)
@constraint(model, x <= 1)
@objective(model, Max, x)
optimize!(model)
@test JuMP.objective_value(model) == 1
optimize!(model)
@test JuMP.objective_value(model) == 1
end
@testset "Optimize twice (reformulation + direct model)" begin
data = ClD.GeneralizedAssignment.data("play2.txt")
coluna = JuMP.optimizer_with_attributes(
Coluna.Optimizer,
"params" => CL.Params(solver=ClA.TreeSearchAlgorithm()),
"default_optimizer" => GLPK.Optimizer
)
model, x, dec = ClD.GeneralizedAssignment.model(data, coluna)
BD.objectiveprimalbound!(model, 100)
BD.objectivedualbound!(model, 0)
optimize!(model)
@test JuMP.objective_value(model) ≈ 75.0
optimize!(model)
@test JuMP.objective_value(model) ≈ 75.0
end
@testset "Optimize twice (reformulation + no direct model)" begin
coluna = JuMP.optimizer_with_attributes(
Coluna.Optimizer,
"params" => CL.Params(solver=ClA.TreeSearchAlgorithm()),
"default_optimizer" => GLPK.Optimizer
)
model = BlockModel(coluna)
data = ClD.GeneralizedAssignment.data("play2.txt")
@axis(M, data.machines)
@variable(model, x[m in M, j in data.jobs], Bin)
@constraint(model, cov[j in data.jobs], sum(x[m,j] for m in M) >= 1)
@constraint(model, knp[m in M], sum(data.weight[j,m] * x[m,j] for j in data.jobs) <= data.capacity[m])
@objective(model, Min, sum(data.cost[j,m] * x[m,j] for m in M, j in data.jobs))
@dantzig_wolfe_decomposition(model, dec, M)
subproblems = BlockDecomposition.getsubproblems(dec)
specify!.(subproblems, lower_multiplicity=0)
BD.objectiveprimalbound!(model, 100)
BD.objectivedualbound!(model, 0)
optimize!(model)
@test JuMP.objective_value(model) ≈ 75.0
optimize!(model)
@test JuMP.objective_value(model) ≈ 75.0
end
@testset "Use column generation as solver" begin
data = ClD.GeneralizedAssignment.data("play2.txt")
coluna = JuMP.optimizer_with_attributes(
Coluna.Optimizer,
"params" => CL.Params(solver=ClA.TreeSearchAlgorithm(
maxnumnodes=1,
)),
"default_optimizer" => GLPK.Optimizer
)
treesearch, x, dec = ClD.GeneralizedAssignment.model_with_penalties(data, coluna)
optimize!(treesearch)
coluna = JuMP.optimizer_with_attributes(
Coluna.Optimizer,
"params" => Coluna.Params(solver=ClA.ColumnGeneration()),
"default_optimizer" => GLPK.Optimizer
)
colgen, x, dec = ClD.GeneralizedAssignment.model_with_penalties(data, coluna)
optimize!(colgen)
@test MOI.get(treesearch, MOI.ObjectiveBound()) ≈ MOI.get(colgen, MOI.ObjectiveBound())
end
@testset "Branching file completion" begin
function get_number_of_nodes_in_branching_tree_file(filename::String)
filepath = string(@__DIR__, "/", filename)
existing_nodes = Set()
open(filepath) do file
for line in eachline(file)
for pieceofdata in split(line)
regex_match = match(r"n\d+", pieceofdata)
if regex_match !== nothing
regex_match = regex_match.match
push!(existing_nodes, parse(Int, regex_match[2:length(regex_match)]))
end
end
end
end
return length(existing_nodes)
end
data = ClD.GeneralizedAssignment.data("play2.txt")
coluna = JuMP.optimizer_with_attributes(
Coluna.Optimizer,
"params" => CL.Params(solver=ClA.TreeSearchAlgorithm(
branchingtreefile="playgap.dot"
)),
"default_optimizer" => GLPK.Optimizer
)
model, x, dec = ClD.GeneralizedAssignment.model(data, coluna)
BD.objectiveprimalbound!(model, 100)
BD.objectivedualbound!(model, 0)
JuMP.optimize!(model)
@test_broken MOI.get(model, MOI.NodeCount()) == get_number_of_nodes_in_branching_tree_file("playgap.dot")
@test JuMP.objective_value(model) ≈ 75.0
@test JuMP.termination_status(model) == MOI.OPTIMAL
end
@testset "Issue 550 - continuous variables in subproblem" begin
# Simple min cost flow problem
#
# n1 ------ f[1] -------> n3
# \ ^
# \ /
# -f[2]-> n2 --f[3]--
#
# n1: demand = -10.1
# n2: demand = 0
# n3: demand = 10.1
# f[1]: cost = 0, capacity = 8.5, in mip model only integer flow allowed
# f[2]: cost = 50, (capacity = 5 can be activated by removing comment at constraint, line 93)
# f[3]: cost = 50
#
# Correct solution for non-integer f[1]
# f[1] = 8.5, f[2] = f[3] = 1.6, cost = 8.5*0 + 1.6*2*50 = 160
# Correct solution for integer f[1]
# f[1] = 8, f[2] = f[3] = 2.1, cost = 8.5*0 + 2.1*2*50 = 210
#
function solve_flow_model(f1_integer, coluna)
@axis(M, 1:1)
model = BlockDecomposition.BlockModel(coluna, direct_model=true)
@variable(model, f[1:3, m in M] >= 0)
if f1_integer
JuMP.set_integer(f[1, 1])
end
@constraint(model, n1[m in M], f[1,m] + f[2,m] == 10.1)
@constraint(model, n2[m in M], f[2,m] == f[3,m])
@constraint(model, n3[m in M], f[1,m] + f[3,m] == 10.1)
@constraint(model, cap1, sum(f[1,m] for m in M) <= 8.5)
#@JuMP.constraint(model, cap2, sum(f[2,m] for m in M) <= 5)
@objective(model, Min, 50 * f[2,1] + 50 * f[3,1])
@dantzig_wolfe_decomposition(model, decomposition, M)
subproblems = BlockDecomposition.getsubproblems(decomposition)
BlockDecomposition.specify!.(subproblems, lower_multiplicity=1, upper_multiplicity=1)
optimize!(model)
if f1_integer
@test termination_status(model) == MOI.OPTIMAL
@test primal_status(model) == MOI.FEASIBLE_POINT
@test objective_value(model) ≈ 210
@test value(f[1,1]) ≈ 8
@test value(f[2,1]) ≈ 2.1
@test value(f[3,1]) ≈ 2.1
else
@test termination_status(model) == MOI.OPTIMAL
@test primal_status(model) == MOI.FEASIBLE_POINT
@test objective_value(model) ≈ 160
@test value(f[1,1]) ≈ 8.5
@test value(f[2,1]) ≈ 1.6
@test value(f[3,1]) ≈ 1.6
end
end
coluna = JuMP.optimizer_with_attributes(
Coluna.Optimizer,
"params" => Coluna.Params(
solver=Coluna.Algorithm.TreeSearchAlgorithm(),
),
"default_optimizer" => GLPK.Optimizer
);
solve_flow_model(false, coluna)
solve_flow_model(true, coluna)
end
@testset "Issue 553 - unsupported anonymous variables and constraints" begin
coluna = JuMP.optimizer_with_attributes(
Coluna.Optimizer,
"params" => CL.Params(solver=ClA.TreeSearchAlgorithm()),
"default_optimizer" => GLPK.Optimizer
)
function anonymous_var_model!(m)
y = @variable(m, binary = true)
@variable(m, 0 <= x[D] <= 1)
@constraint(m, sp[d in D], x[d] <= 0.85)
@objective(m, Min, sum(x) + y)
@dantzig_wolfe_decomposition(m, dec, D)
end
function anonymous_constr_model!(m)
@variable(m, 0 <= x[D] <= 1)
sp = @constraint(m, [d in D], x[d] <= 0.85)
@objective(m, Min, sum(x))
@dantzig_wolfe_decomposition(m, dec, D)
end
@axis(D, 1:5)
m = BlockModel(coluna, direct_model=true)
anonymous_var_model!(m)
@test_throws ErrorException optimize!(m)
m = BlockModel(coluna)
anonymous_var_model!(m)
# The variable is annotated in the master.
# @test_throws ErrorException optimize!(m)
m = BlockModel(coluna, direct_model=true)
anonymous_constr_model!(m)
@test_throws ErrorException optimize!(m)
m = BlockModel(coluna)
anonymous_constr_model!(m)
@test_throws ErrorException optimize!(m)
end
@testset "Issue 554 - Simple Benders" begin
# Test in Min sense
coluna = optimizer_with_attributes(
Coluna.Optimizer,
"params" => Coluna.Params(
solver = Coluna.Algorithm.BendersCutGeneration()
),
"default_optimizer" => GLPK.Optimizer
)
model = BlockModel(coluna, direct_model=true)
@axis(S, 1:2)
@variable(model, x, Bin)
@variable(model, y[i in S], Bin)
@constraint(model, purefirststage, x <= 1)
@constraint(model, tech1[S[1]], y[S[1]] <= x)
@constraint(model, tech2[S[2]], y[S[2]] <= 1-x)
@constraint(model, puresecondstage[s in S], y[s] <= 1)
@objective(model, Min, -sum(y))
@benders_decomposition(model, decomposition, S)
optimize!(model)
@test objective_value(model) == -1.0
# Test in Max sense
coluna = optimizer_with_attributes(
Coluna.Optimizer,
"params" => Coluna.Params(
solver = Coluna.Algorithm.BendersCutGeneration()
),
"default_optimizer" => GLPK.Optimizer
)
model = BlockModel(coluna, direct_model=true)
@axis(S, 1:2)
@variable(model, x, Bin)
@variable(model, y[i in S], Bin)
@constraint(model, purefirststage, x <= 1)
@constraint(model, tech1[S[1]], y[S[1]] <= x)
@constraint(model, tech2[S[2]], y[S[2]] <= 1-x)
@constraint(model, puresecondstage[s in S], y[s] <= 1)
@objective(model, Max, +sum(y))
@benders_decomposition(model, decomposition, S)
optimize!(model)
@test_broken objective_value(model) == 1.0
end
@testset "Issue 591 - get dual of generated cuts" begin
coluna = JuMP.optimizer_with_attributes(
Coluna.Optimizer,
"params" => Coluna.Params(
solver=Coluna.Algorithm.TreeSearchAlgorithm(),
),
"default_optimizer" => GLPK.Optimizer
);
model = BlockModel(coluna, direct_model=true)
@axis(I, 1:7)
@variable(model, 0<= x[i in I] <= 1) # subproblem variables & constraints
@variable(model, y[1:2] >= 0) # master
@variable(model, u >=0) # master
@constraint(model, xCon, sum(x[i] for i = I) <= 1)
@constraint(model, yCon, sum(y[i] for i = 1:2) == 1)
@constraint(model, initCon1, u >= 0.9*y[1] + y[2] - x[1] - x[2] - x[3])
@constraint(model, initCon2, u >= y[1] + y[2] - x[7])
@objective(model, Min, u)
callback_called = false
constrid = nothing
function my_callback_function(cbdata)
if !callback_called
con = @build_constraint(u >= y[1] + 0.9*y[2] - x[5] - x[6])
constrid = MOI.submit(model, MOI.LazyConstraint(cbdata), con)
callback_called = true
end
return
end
MOI.set(model, MOI.LazyConstraintCallback(), my_callback_function)
@dantzig_wolfe_decomposition(model, dec, I)
optimize!(model)
@test objective_value(model) ≈ 0.63333333
@test MOI.get(JuMP.unsafe_backend(model), MOI.ConstraintDual(), constrid) ≈ 0.33333333
end
end
| Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 181 | using Coluna, ReTest
include("ColunaTests.jl")
# Run a specific test:
# retest(ColunaTests, "Improve relaxation callback")
# retest(Coluna, ColunaTests)
include("unit/run.jl")
| Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 2661 | # return all julia files in a subdirectory (and its subdirectories) of the current directory
function _alljlfiles(basefolder::String)
allfiles = [
joinpath(folder, file) for
(folder, _, files) in walkdir(joinpath(@__DIR__, basefolder)) for file in files
]
return filter(f -> endswith(f, ".jl"), allfiles)
end
typical_test_dirs = [
joinpath("unit", "ColunaBase"),
joinpath("unit", "MathProg"),
joinpath("unit", "MustImplement"),
joinpath("unit", "ColGen"),
joinpath("unit", "Benders"),
joinpath("unit", "Parser"),
joinpath("unit", "TreeSearch"),
joinpath("unit", "Presolve"),
joinpath("integration", "custom_data"),
joinpath("integration", "parser"),
joinpath("integration", "pricing_callback"),
joinpath("integration", "MOI"),
joinpath("e2e", "gap"),
joinpath("e2e_extra", "advanced_colgen"),
joinpath("e2e_extra", "gap")
]
tracked_dirs = filter(isdir, typical_test_dirs)
all_test_files = Iterators.flatten( # get all julia files in the given subdirectories
_alljlfiles(folder) for folder in tracked_dirs
)
revise_status_lockfile = ".222-revise-exit-code"
function listen_to_tests(funcs)
recovering = false
while true
try
entr(all_test_files, [MODULES...]; postpone = recovering) do
run(`clear`) # clear terminal
unit_tests = Registry()
map(funcs) do f
f()
end
end
catch e
recovering = true
if isa(e, InterruptException)
if isfile(revise_status_lockfile)
rm(revise_status_lockfile)
end
return nothing
elseif isa(e, Revise.ReviseEvalException)
# needs to reload julia for revise to work again
open(revise_status_lockfile, "w") do file
write(file, "222")
end
exit(222)
elseif !isa(e, TestSetException) &&
!isa(e, TaskFailedException) &&
(
!isa(e, CompositeException) ||
!any(ie -> isa(ie, TaskFailedException), e.exceptions)
)
@warn "Caught Exception" exception = (e, catch_backtrace())
end
end
end
end
# include and track all test files
for file in all_test_files
includet(file)
end
include("unit/run.jl")
include("integration/run.jl")
include("e2e/run.jl")
include("e2e_extra/run.jl")
listen_to_tests([
run_unit_tests,
run_integration_tests,
run_e2e_tests,
run_e2e_extra_tests
]) | Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 1714 | using Revise
using Base.CoreLogging: error
using DynamicSparseArrays, SparseArrays, Coluna, TOML, JET
using Test, GLPK, ColunaDemos, JuMP, BlockDecomposition, Random, MathOptInterface, MathOptInterface.Utilities, Base.CoreLogging, Logging
global_logger(ConsoleLogger(stderr, LogLevel(0)))
const MOI = MathOptInterface
const MOIU = MOI.Utilities
const MOIT = MOI.Test
const MOIB = MOI.Bridges
const CleverDicts = MOI.Utilities.CleverDicts
const CL = Coluna
const ClD = ColunaDemos
const BD = BlockDecomposition
const ClB = Coluna.ColunaBase
const ClMP = Coluna.MathProg
const ClA = Coluna.Algorithm
using Coluna.ColunaBase, Coluna.MathProg, Coluna.ColGen, Coluna.Branching
include("TestRegistry/TestRegistry.jl")
using .TestRegistry
using Coluna.Tests.Parser
unit_tests = Registry()
integration_tests = Registry()
e2e_tests = Registry()
e2e_extra_tests = Registry()
const MODULES = [
Coluna,
Coluna.ColunaBase,
Coluna.MustImplement,
Coluna.MathProg,
Coluna.Algorithm,
Coluna.ColGen,
Coluna.Branching,
Parser
]
rng = MersenneTwister(1234123)
if !isempty(ARGS)
# assume that the call is coming from revise.sh
include("revise.jl")
else
include("unit/run.jl")
include("integration/run.jl")
include("e2e/run.jl")
include("e2e_extra/run.jl")
run_unit_tests()
run_integration_tests()
@testset "MOI integration" begin
include("MathOptInterface/MOI_wrapper.jl")
end
run_e2e_tests()
run_e2e_extra_tests()
end
@testset "Version" begin
coluna_ver = Coluna.version()
toml_ver = VersionNumber(
TOML.parsefile(joinpath(@__DIR__, "..", "Project.toml"))["version"]
)
@test coluna_ver == toml_ver
end
| Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 3750 |
# ============================ /test/MOI_wrapper.jl ============================
module TestColuna
import Coluna
using MathOptInterface
using Test
using HiGHS
const MOI = MathOptInterface
const BRIDGED = MOI.instantiate(
MOI.OptimizerWithAttributes(
Coluna.Optimizer,
MOI.RawOptimizerAttribute("default_optimizer") => HiGHS.Optimizer,
MOI.RawOptimizerAttribute("params") => Coluna.Params(
solver = Coluna.Algorithm.SolveIpForm(
moi_params = Coluna.Algorithm.MoiOptimize(get_dual_solution = true)
)
)
),
with_bridge_type = Float64,
)
# See the docstring of MOI.Test.Config for other arguments.
const CONFIG = MOI.Test.Config(
# Modify tolerances as necessary.
atol = 1e-6,
rtol = 1e-6,
# Use MOI.LOCALLY_SOLVED for local solvers.
optimal_status = MOI.OPTIMAL,
# Pass attributes or MOI functions to `exclude` to skip tests that
# rely on this functionality.
exclude = Any[MOI.VariableName, MOI.delete],
)
"""
runtests()
This function runs all functions in the this Module starting with `test_`.
"""
function runtests()
for name in names(@__MODULE__; all = true)
if startswith("$(name)", "test_")
@testset "$(name)" begin
getfield(@__MODULE__, name)()
end
end
end
end
"""
test_runtests()
This function runs all the tests in MathOptInterface.Test.
Pass arguments to `exclude` to skip tests for functionality that is not
implemented or that your solver doesn't support.
"""
function test_runtests()
MOI.Test.runtests(
BRIDGED,
CONFIG,
exclude = [
"test_attribute_NumberOfThreads",
"test_quadratic_",
"test_conic_",
"test_nonlinear_",
"test_cpsat_",
# Unsupported attributes
"test_attribute_RawStatusString",
"test_attribute_SolveTimeSec",
# Following tests needs support of variable basis.
"test_linear_Interval_inactive",
"test_linear_add_constraints",
"test_linear_inactive_bounds",
"test_linear_integration_2",
"test_linear_integration_Interval",
"test_linear_integration_delete_variables",
"test_linear_transform",
# To see later if we need to support SOS2 integration
"test_linear_SOS2_integration",
# To see if we can support this tests, they fail because
# MethodError: no method matching _is_valid(::Type{MathOptInterface.Semicontinuous{Float64}}, ::Coluna._VarBound, ::Coluna._VarBound, ::Coluna._VarKind)
"test_basic_ScalarAffineFunction_Semicontinuous",
"test_basic_ScalarAffineFunction_Semiinteger",
"test_basic_VariableIndex_Semicontinuous",
"test_basic_VariableIndex_Semiinteger",
"test_linear_Semicontinuous_integration",
"test_linear_Semiinteger_integration"
],
# This argument is useful to prevent tests from failing on future
# releases of MOI that add new tests. Don't let this number get too far
# behind the current MOI release though! You should periodically check
# for new tests in order to fix bugs and implement new features.
exclude_tests_after = v"1.14.0",
)
return
end
"""
test_SolverName()
You can also write new tests for solver-specific functionality. Write each new
test as a function with a name beginning with `test_`.
"""
function test_SolverName()
@test MOI.get(Coluna.Optimizer(), MOI.SolverName()) == "Coluna"
return
end
end # module TestColuna
# This line at the end of the file runs all the tests!
TestColuna.runtests()
| Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 1807 | module TestRegistry
using Test
struct Registry
test_sets::Dict{String, Vector{Tuple{Bool, Bool, Function}}}
registered_func_names::Set{String}
Registry() = new(Dict{String, Vector{Tuple{Bool, Bool, Function}}}(), Set{String}())
end
"""
Register a test function `func` in test set `test_set_name`.
If you want to exclude the test, add kw arg `x = true`.
If you want to focus on the test (run only this test), add kw arg `f = true`.
"""
function register!(tests::Registry, test_set_name::String, func; x = false, f = false)
if !haskey(tests.test_sets, test_set_name)
tests.test_sets[test_set_name] = Function[]
end
if !in(tests.registered_func_names, String(Symbol(func)))
push!(tests.test_sets[test_set_name], (x, f, func))
push!(tests.registered_func_names, String(Symbol(func)))
else
error("Test \"$(String(Symbol(func)))\" already registered.")
end
return
end
function run_tests(tests::Registry)
focus_mode = false
for (_, test_set) in tests.test_sets
for (x, f, _) in test_set
if f
focus_mode = true
break
end
end
focus_mode && break
end
for (test_set_name, test_set) in tests.test_sets
@testset "$test_set_name" begin
for (x, f, test) in test_set
test_name = String(Symbol(test))
@testset "$test_name" begin
run = (!focus_mode || f) && !x
run && test()
end
end
end
end
end
export Registry, register!, run_tests
end | Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 620 | @testset "Capacitated Vehicle Routing" begin
@testset "toy instance" begin
data = ClD.CapacitatedVehicleRouting.data("A-n16-k3.vrp")
coluna = JuMP.optimizer_with_attributes(
Coluna.Optimizer,
"params" => CL.Params(solver = ClA.BranchCutAndPriceAlgorithm(
maxnumnodes = 10000,
branchingtreefile = "cvrp.dot"
)),
"default_optimizer" => GLPK.Optimizer
)
model, x, dec = ClD.CapacitatedVehicleRouting.model(data, coluna)
JuMP.optimize!(model)
@test objective_value(model) ≈ 504
end
end
| Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 503 | @testset "Cutting Stock" begin
@testset "toy instance" begin
data = ClD.CuttingStock.data("randomInstances/inst10-10")
coluna = JuMP.optimizer_with_attributes(
Coluna.Optimizer,
"params" => CL.Params(solver = ClA.BranchCutAndPriceAlgorithm()),
"default_optimizer" => GLPK.Optimizer
)
problem, x, y, dec = ClD.CuttingStock.model(data, coluna)
JuMP.optimize!(problem)
@test objective_value(problem) ≈ 4
end
end
| Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 1076 | @testset "Lot Sizing" begin
@testset "single mode multi items lot sizing" begin
data = ClD.SingleModeMultiItemsLotSizing.data("lotSizing-3-20-2.txt")
coluna = JuMP.optimizer_with_attributes(
Coluna.Optimizer,
"params" => CL.Params(
solver = ClA.BendersCutGeneration()
),
"default_optimizer" => GLPK.Optimizer
)
problem, x, y, dec = ClD.SingleModeMultiItemsLotSizing.model(data, coluna)
JuMP.optimize!(problem)
@test objective_value(problem) ≈ 600
end
@testset "capacitated lot sizing" begin
data = ClD.CapacitatedLotSizing.readData("testSmall")
coluna = JuMP.optimizer_with_attributes(
Coluna.Optimizer,
"params" => CL.Params(solver = ClA.BranchCutAndPriceAlgorithm()),
"default_optimizer" => GLPK.Optimizer
)
model, x, y, s, dec = ClD.CapacitatedLotSizing.model(data, coluna)
JuMP.optimize!(model)
@test JuMP.termination_status(model) == MOI.OPTIMAL
end
end | Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 205 | for dir in ["gap", "TreeSearch"]
dirpath = joinpath(@__DIR__, dir)
for filename in readdir(dirpath)
include(joinpath(dirpath, filename))
end
end
run_e2e_tests() = run_tests(e2e_tests)
| Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 2558 | # GAP instance with two machines and 4 jobs s.t. each machine has a capacity of 2, each job has weight 1
# One of the job is forced to be assigned 0.5 times to machine 1 s.t. the linear relaxation of the problem is feasible, but not the original MIP.
function test_treesearch_gap_1()
M = [1,2]
J = 1:4
c = [10 3 7 5;
3 6 4 12
]
coluna = optimizer_with_attributes(
Coluna.Optimizer,
"params" => Coluna.Params(
solver = Coluna.Algorithm.TreeSearchAlgorithm() # default branch-cut-and-price
),
"default_optimizer" => GLPK.Optimizer # GLPK for the master & the subproblems
)
@axis(M_axis, M)
model = BlockModel(coluna)
@variable(model, x[m in M_axis, j in J], Bin);
@constraint(model, cov[j in J], sum(x[m, j] for m in M_axis) >= 1)
@constraint(model, knp[m in M_axis], sum(1.0 * x[m, j] for j in J) <= 2.0)
@objective(model, Min, sum(c[m, j] * x[m, j] for m in M_axis, j in J))
#JuMP.relax_integrality(model)
JuMP.fix(x[1, 1], 0.5; force=true)
@dantzig_wolfe_decomposition(model, decomposition, M_axis)
optimize!(model)
@test_broken JuMP.termination_status(model) == MOI.INFEASIBLE
end
register!(e2e_tests, "treesearch", test_treesearch_gap_1)
# GAP instance with two machines and 4 jobs s.t. each machine has a capacity of 2, each job has weight 1
# One of the job is forced to be assigned 0.5 times (modification of the cov constraint) s.t. the linear relaxation of the problem is feasible, but not the original MIP.
function test_treesearch_gap_2()
M = [1,2]
J = 1:4
c = [10 3 7 5;
3 6 4 12
]
@axis(M_axis, M)
coluna = optimizer_with_attributes(
Coluna.Optimizer,
"params" => Coluna.Params(
solver = Coluna.Algorithm.TreeSearchAlgorithm() # default branch-cut-and-price
),
"default_optimizer" => GLPK.Optimizer # GLPK for the master & the subproblems
)
model = BlockModel(coluna)
@variable(model, x[m in M_axis, j in J], Bin);
@constraint(model, cov[j in J[2:end]], sum(x[m, j] for m in M_axis) >= 1)
@constraint(model, cov2[j in J[1]], sum(x[m, j] for m in M_axis) == 0.5)
@constraint(model, knp[m in M_axis], sum(1.0 * x[m, j] for j in J) <= 2.0)
@objective(model, Min, sum(c[m, j] * x[m, j] for m in M_axis, j in J))
@dantzig_wolfe_decomposition(model, decomposition, M_axis)
optimize!(model)
@test JuMP.termination_status(model) == MOI.INFEASIBLE
end
register!(e2e_tests, "treesearch", test_treesearch_gap_2) | Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 15395 | function gap_toy_instance()
data = ClD.GeneralizedAssignment.data("play2.txt")
coluna = JuMP.optimizer_with_attributes(
Coluna.Optimizer,
"params" => CL.Params(
solver = ClA.BranchCutAndPriceAlgorithm(
branchingtreefile = "playgap.dot",
colgen_strict_integrality_check = true, # only for testing purposes, not really needed here
run_presolve = true
),
local_art_var_cost=10000.0,
global_art_var_cost=100000.0),
"default_optimizer" => GLPK.Optimizer
)
model, x, dec = ClD.GeneralizedAssignment.model(data, coluna)
BD.objectiveprimalbound!(model, 100)
BD.objectivedualbound!(model, 0)
JuMP.optimize!(model)
@test JuMP.objective_value(model) ≈ 75.0
@test JuMP.termination_status(model) == MOI.OPTIMAL
@test JuMP.primal_status(model) == MOI.FEASIBLE_POINT
# @show JuMP.value.(x)
@test ClD.GeneralizedAssignment.print_and_check_sol(data, model, x)
@test MOI.get(model, MOI.NumberOfVariables()) == length(x)
@test MOI.get(model, MOI.SolverName()) == "Coluna"
end
register!(e2e_tests, "gap", gap_toy_instance)
function gap_toy_instance_2()
data = ClD.GeneralizedAssignment.data("play2.txt")
coluna = JuMP.optimizer_with_attributes(
Coluna.Optimizer,
"params" => CL.Params(solver=ClA.BranchCutAndPriceAlgorithm(
jsonfile="playgap.json",
), local_art_var_cost=10000.0,
global_art_var_cost=100000.0),
"default_optimizer" => GLPK.Optimizer
)
model, x, dec = ClD.GeneralizedAssignment.model(data, coluna)
BD.objectiveprimalbound!(model, 100)
BD.objectivedualbound!(model, 0)
JuMP.optimize!(model)
@test JuMP.objective_value(model) ≈ 75.0
@test JuMP.termination_status(model) == MOI.OPTIMAL
@test JuMP.primal_status(model) == MOI.FEASIBLE_POINT
# @show JuMP.value.(x)
@test ClD.GeneralizedAssignment.print_and_check_sol(data, model, x)
@test MOI.get(model, MOI.NumberOfVariables()) == length(x)
@test MOI.get(model, MOI.SolverName()) == "Coluna"
end
register!(e2e_tests, "gap", gap_toy_instance_2)
function gap_strong_branching()
data = ClD.GeneralizedAssignment.data("mediumgapcuts3.txt")
coluna = JuMP.optimizer_with_attributes(
CL.Optimizer,
"params" => CL.Params(
solver=ClA.BranchCutAndPriceAlgorithm(
maxnumnodes=300,
colgen_stabilization=1.0,
colgen_cleanup_threshold=150,
stbranch_phases_num_candidates=[10, 3, 1],
stbranch_intrmphase_stages=[(userstage=1, solverid=1, maxiters=2)]
)
),
"default_optimizer" => GLPK.Optimizer
)
model, x, dec = ClD.GeneralizedAssignment.model(data, coluna)
# we increase the branching priority of variables which assign jobs to the first two machines
for job in data.jobs
BD.branchingpriority!(x[1, job], 2)
end
for job in data.jobs
BD.branchingpriority!(x[2, job], 2.0)
end
BD.objectiveprimalbound!(model, 2000.0)
BD.objectivedualbound!(model, 0.0)
JuMP.optimize!(model)
@test JuMP.objective_value(model) ≈ 1553.0
@test JuMP.termination_status(model) == MOI.OPTIMAL
@test ClD.GeneralizedAssignment.print_and_check_sol(data, model, x)
end
register!(e2e_tests, "gap", gap_strong_branching)
# @testset "Generalized Assignment" begin
# @testset "small instance" begin
# data = ClD.GeneralizedAssignment.data("smallgap3.txt")
# coluna = JuMP.optimizer_with_attributes(
# Coluna.Optimizer,
# "params" => CL.Params(solver = ClA.BranchCutAndPriceAlgorithm()),
# "default_optimizer" => GLPK.Optimizer
# )
# model, x, dec = ClD.GeneralizedAssignment.model(data, coluna)
# BD.objectiveprimalbound!(model, 500.0)
# BD.objectivedualbound!(model, 0.0)
# JuMP.optimize!(model)
# @test JuMP.objective_value(model) ≈ 438.0
# @test JuMP.termination_status(model) == MOI.OPTIMAL
# @test ClD.GeneralizedAssignment.print_and_check_sol(data, model, x)
# end
# @testset "node limit" begin # TODO -> replace by unit test for tree search algorithm
# data = ClD.GeneralizedAssignment.data("mediumgapcuts3.txt")
# coluna = JuMP.optimizer_with_attributes(
# CL.Optimizer,
# "params" => CL.Params(
# solver = ClA.BranchCutAndPriceAlgorithm(
# maxnumnodes = 5
# )
# ),
# "default_optimizer" => GLPK.Optimizer
# )
# model, x, dec = ClD.GeneralizedAssignment.model(data, coluna)
# BD.objectiveprimalbound!(model, 2000.0)
# BD.objectivedualbound!(model, 0.0)
# JuMP.optimize!(model)
# @test JuMP.objective_bound(model) ≈ 1547.3889
# @test JuMP.termination_status(model) == MathOptInterface.OTHER_LIMIT
# return
# end
# @testset "ColGen max nb iterations" begin
# data = ClD.GeneralizedAssignment.data("smallgap3.txt")
# coluna = JuMP.optimizer_with_attributes(
# CL.Optimizer,
# "params" => CL.Params(
# solver = ClA.TreeSearchAlgorithm(
# conqueralg = ClA.ColCutGenConquer(
# stages = [ClA.ColumnGeneration(max_nb_iterations = 8)],
# )
# )
# ),
# "default_optimizer" => GLPK.Optimizer
# )
# problem, x, dec = ClD.GeneralizedAssignment.model(data, coluna)
# JuMP.optimize!(problem)
# @test abs(JuMP.objective_value(problem) - 438.0) <= 0.00001
# @test JuMP.termination_status(problem) == MOI.OPTIMAL # Problem with final dual bound ?
# @test ClD.GeneralizedAssignment.print_and_check_sol(data, problem, x)
# end
# @testset "pure master variables (GAP with f)" begin
# data = ClD.GeneralizedAssignment.data("smallgap3.txt")
# coluna = JuMP.optimizer_with_attributes(
# Coluna.Optimizer,
# "params" => CL.Params(solver = ClA.BranchCutAndPriceAlgorithm()),
# "default_optimizer" => GLPK.Optimizer
# )
# problem, x, y, dec = ClD.GeneralizedAssignment.model_with_f(data, coluna)
# JuMP.optimize!(problem)
# @test JuMP.termination_status(problem) == MOI.OPTIMAL
# @test abs(JuMP.objective_value(problem) - 416.4) <= 0.00001
# end
# @testset "maximisation objective function" begin
# data = ClD.GeneralizedAssignment.data("smallgap3.txt")
# coluna = JuMP.optimizer_with_attributes(
# Coluna.Optimizer,
# "params" => CL.Params(solver = ClA.BranchCutAndPriceAlgorithm()),
# "default_optimizer" => GLPK.Optimizer
# )
# problem, x, dec = ClD.GeneralizedAssignment.model_max(data, coluna)
# JuMP.optimize!(problem)
# @test JuMP.termination_status(problem) == MOI.OPTIMAL
# @test abs(JuMP.objective_value(problem) - 580.0) <= 0.00001
# end
# @testset "infeasible master" begin
# data = ClD.GeneralizedAssignment.data("master_infeas.txt")
# coluna = JuMP.optimizer_with_attributes(
# Coluna.Optimizer,
# "params" => CL.Params(solver = ClA.BranchCutAndPriceAlgorithm()),
# "default_optimizer" => GLPK.Optimizer
# )
# problem, x, dec = ClD.GeneralizedAssignment.model(data, coluna)
# JuMP.optimize!(problem)
# @test JuMP.termination_status(problem) == MOI.INFEASIBLE
# end
# # Issue 520 : https://github.com/atoptima/Coluna.jl/issues/520
# @testset "infeasible master 2" begin
# data = ClD.GeneralizedAssignment.data("master_infeas2.txt")
# coluna = JuMP.optimizer_with_attributes(
# Coluna.Optimizer,
# "params" => CL.Params(solver = ClA.BranchCutAndPriceAlgorithm()),
# "default_optimizer" => GLPK.Optimizer
# )
# problem, x, dec = ClD.GeneralizedAssignment.model(data, coluna)
# JuMP.optimize!(problem)
# @test JuMP.termination_status(problem) == MOI.INFEASIBLE
# end
# @testset "infeasible subproblem" begin
# data = ClD.GeneralizedAssignment.data("sp_infeas.txt")
# coluna = JuMP.optimizer_with_attributes(
# Coluna.Optimizer,
# "params" => CL.Params(solver = ClA.BranchCutAndPriceAlgorithm()),
# "default_optimizer" => GLPK.Optimizer
# )
# problem, x, dec = ClD.GeneralizedAssignment(data, coluna)
# JuMP.optimize!(problem)
# @test JuMP.termination_status(problem) == MOI.INFEASIBLE
# end
# @testset "gap with all phases in col.gen" begin # TODO: replace by unit tests for ColCutGenConquer.
# data = ClD.GeneralizedAssignment.data("mediumgapcuts1.txt")
# for m in M
# data.capacity[m] = floor(Int, data.capacity[m] * 0.5)
# end
# coluna = JuMP.optimizer_with_attributes(
# Coluna.Optimizer,
# "params" => CL.Params(solver = ClA.TreeSearchAlgorithm(
# conqueralg = ClA.ColCutGenConquer(
# stages = [ClA.ColumnGeneration(opt_rtol = 1e-4, smoothing_stabilization = 0.5)]
# )
# )),
# "default_optimizer" => GLPK.Optimizer
# )
# problem, x, y, dec = ClD.GeneralizedAssignment.model_with_penalty(data, coluna)
# JuMP.optimize!(problem)
# @test abs(JuMP.objective_value(problem) - 31895.0) <= 0.00001
# end
# @testset "gap with max. obj., pure mast. vars., and stabilization" begin
# data = ClD.GeneralizedAssignment.data("gapC-5-100.txt")
# coluna = JuMP.optimizer_with_attributes(
# CL.Optimizer,
# "params" => CL.Params(
# solver = ClA.BranchCutAndPriceAlgorithm(
# colgen_stabilization = 1.0,
# maxnumnodes = 300
# )
# ),
# "default_optimizer" => GLPK.Optimizer
# )
# model, x, y, dec = ClD.GeneralizedAssignment.max_model_with_subcontracts(data, coluna)
# JuMP.optimize!(model)
# @test JuMP.objective_value(model) ≈ 3520.1
# @test JuMP.termination_status(model) == MOI.OPTIMAL
# end
# @testset "toy instance with no solver" begin
# data = ClD.GeneralizedAssignment.data("play2.txt")
# coluna = JuMP.optimizer_with_attributes(
# Coluna.Optimizer,
# "params" => CL.Params(solver = ClA.BranchCutAndPriceAlgorithm())
# )
# problem, x, dec = ClD.GeneralizedAssignment.model(data, coluna)
# try
# JuMP.optimize!(problem)
# catch e
# @test e isa ErrorException
# end
# end
# # We solve the GAP but only one set-partionning constraint (for job 1) is
# # put in the formulation before starting optimization.
# # Other set-partionning constraints are added in the essential cut callback.
# @testset "toy instance with lazy cuts" begin
# data = ClD.GeneralizedAssignment.data("play2.txt")
# coluna = JuMP.optimizer_with_attributes(
# Coluna.Optimizer,
# "params" => CL.Params(solver = ClA.BranchCutAndPriceAlgorithm(
# max_nb_cut_rounds = 1000
# )),
# "default_optimizer" => GLPK.Optimizer
# )
# model = BlockModel(coluna, direct_model = true)
# @axis(M, M)
# @variable(model, x[m in M, j in J], Bin)
# @constraint(model, cov, sum(x[m,1] for m in M) == 1) # add only covering constraint of job 1
# @constraint(model, knp[m in M],
# sum(data.weight[j,m]*x[m,j] for j in J) <= data.capacity[m]
# )
# @objective(model, Min,
# sum(c[j,m]*x[m,j] for m in M, j in J)
# )
# @dantzig_wolfe_decomposition(model, dec, M)
# subproblems = BlockDecomposition.getsubproblems(dec)
# specify!.(subproblems, lower_multiplicity = 0)
# cur_j = 1
# # Lazy cut callback (add covering constraints on jobs on the fly)
# function my_callback_function(cb_data)
# for j in 1:cur_j
# @test sum(callback_value(cb_data, x[m,j]) for m in M) ≈ 1
# end
# if cur_j < length(J)
# cur_j += 1
# con = @build_constraint(sum(x[m,cur_j] for m in M) == 1)
# MOI.submit(model, MOI.LazyConstraint(cb_data), con)
# end
# end
# MOI.set(model, MOI.LazyConstraintCallback(), my_callback_function)
# optimize!(model)
# @test JuMP.objective_value(model) ≈ 75.0
# @test JuMP.termination_status(model) == MOI.OPTIMAL
# end
# @testset "toy instance with best dual bound" begin
# data = ClD.GeneralizedAssignment.data("play2.txt")
# coluna = JuMP.optimizer_with_attributes(
# CL.Optimizer,
# "params" => CL.Params(
# solver = Coluna.Algorithm.TreeSearchAlgorithm(
# explorestrategy = Coluna.Algorithm.BestDualBoundStrategy()
# )
# ),
# "default_optimizer" => GLPK.Optimizer
# )
# model, x, dec = ClD.GeneralizedAssignment.model(data, coluna)
# optimize!(model)
# @test JuMP.objective_value(model) ≈ 75.0
# @test JuMP.termination_status(model) == MOI.OPTIMAL
# end
# @testset "toy instance with objective constant" begin
# M = 1:3;
# J = 1:15;
# c = [12.7 22.5 8.9 20.8 13.6 12.4 24.8 19.1 11.5 17.4 24.7 6.8 21.7 14.3 10.5; 19.1 24.8 24.4 23.6 16.1 20.6 15.0 9.5 7.9 11.3 22.6 8.0 21.5 14.7 23.2; 18.6 14.1 22.7 9.9 24.2 24.5 20.8 12.9 17.7 11.9 18.7 10.1 9.1 8.9 7.7; 13.1 16.2 16.8 16.7 9.0 16.9 17.9 12.1 17.5 22.0 19.9 14.6 18.2 19.6 24.2];
# w = [61 70 57 82 51 74 98 64 86 80 69 79 60 76 78; 50 57 61 83 81 79 63 99 82 59 83 91 59 99 91;91 81 66 63 59 81 87 90 65 55 57 68 92 91 86; 62 79 73 60 75 66 68 99 69 60 56 100 67 68 54];
# Q = [1020 1460 1530];
# coluna = optimizer_with_attributes(
# Coluna.Optimizer,
# "params" => Coluna.Params(
# solver = Coluna.Algorithm.TreeSearchAlgorithm() # default branch-cut-and-price
# ),
# "default_optimizer" => GLPK.Optimizer # GLPK for the master & the subproblems
# );
# model = BlockModel(coluna)
# @axis(M_axis, M);
# @variable(model, x[m in M_axis, j in J], Bin);
# @constraint(model, cov[j in J], sum(x[m, j] for m in M_axis) >= 1);
# @constraint(model, knp[m in M_axis], sum(w[m, j] * x[m, j] for j in J) <= Q[m]);
# @objective(model, Min, sum(c[m, j] * x[m, j] for m in M_axis, j in J) + 250);
# @dantzig_wolfe_decomposition(model, decomposition, M_axis)
# subproblems = getsubproblems(decomposition)
# specify!.(subproblems, lower_multiplicity = 0, upper_multiplicity = 1)
# optimize!(model)
# @test JuMP.objective_value(model) ≈ 250 + 166.5
# return
# end
# end | Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 221 | for dir in ["advanced_colgen", "gap"]
dirpath = joinpath(@__DIR__, dir)
for filename in readdir(dirpath)
include(joinpath(dirpath, filename))
end
end
run_e2e_extra_tests() = run_tests(e2e_extra_tests) | Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 4545 | # In this test, we use the Martinelli's knapsack solver pkg (https://github.com/rafaelmartinelli/Knapsacks.jl)
# to test the interface of custom models/solvers.
using Knapsacks
mutable struct KnapsackLibModel <: Coluna.MathProg.AbstractFormulation
nbitems::Int
costs::Vector{Float64}
weights::Vector{Float64}
capacity::Float64
job_to_jumpvar::Dict{Int, JuMP.VariableRef}
#varids::Vector{Coluna.MathProg.VarId}
#map::Dict{Coluna.MathProg.VarId,Float64}
end
KnapsackLibModel(nbitems) = KnapsackLibModel(
nbitems, zeros(Float64, nbitems), zeros(Float64, nbitems), 0.0,
Dict{Int, JuMP.VariableRef}()
)
setcapacity!(model::KnapsackLibModel, cap) = model.capacity = cap
setweight!(model::KnapsackLibModel, j::Int, w) = model.weights[j] = w
setcost!(model::KnapsackLibModel, j::Int, c) = model.costs[j] = c
map!(model::KnapsackLibModel, j::Int, x::JuMP.VariableRef) = model.job_to_jumpvar[j] = x
mutable struct KnapsackLibOptimizer <: BlockDecomposition.AbstractCustomOptimizer
model::KnapsackLibModel
end
function Coluna.Algorithm.get_units_usage(opt::KnapsackLibOptimizer, form) # form is Coluna Formulation
units_usage = Tuple{Coluna.ColunaBase.AbstractModel, ClB.UnitType, ClB.UnitPermission}[]
# TODO : the abstract model is KnapsackLibModel (opt.model)
return units_usage
end
function _fixed_costs(model::KnapsackLibModel, form, env::Env)
costs = Float64[]
for j in 1:length(model.costs)
cost = Coluna.MathProg.getcurcost(form, _getvarid(model, form, env, j))
push!(costs, cost < 0 ? -cost : 0)
end
return costs
end
function _scale_to_int(vals...)
return map(x -> Integer(round(10000x)), vals)
end
_getvarid(model::KnapsackLibModel, form, env::Env, j::Int) = Coluna.MathProg.getid(Coluna.MathProg.getvar(form, env.varids[model.job_to_jumpvar[j].index]))
function Coluna.Algorithm.run!(
opt::KnapsackLibOptimizer, env::Coluna.Env, form::Coluna.MathProg.Formulation,
input::Coluna.Algorithm.OptimizationState; kw...
)
costs = _fixed_costs(opt.model, form, env)
ws = _scale_to_int(opt.model.capacity, opt.model.weights...)
cs = _scale_to_int(costs...)
data = Knapsack(ws[1], [ws[2:end]...], [cs...])
_, selected = solveKnapsack(data)
setup_var_id = form.duty_data.setup_var
cost = sum(-costs[j] for j in selected) + Coluna.MathProg.getcurcost(form, setup_var_id)
varids = Coluna.MathProg.VarId[]
varvals = Float64[]
for j in selected
if costs[j] > 0
push!(varids, _getvarid(opt.model, form, env, j))
push!(varvals, 1)
end
end
push!(varids, setup_var_id)
push!(varvals, 1)
sol = Coluna.MathProg.PrimalSolution(form, varids, varvals, cost, Coluna.MathProg.FEASIBLE_SOL)
result = Coluna.Algorithm.OptimizationState(form; termination_status = Coluna.MathProg.OPTIMAL)
Coluna.Algorithm.add_ip_primal_sol!(result, sol)
dual_bound = Coluna.getvalue(Coluna.Algorithm.get_ip_primal_bound(result))
Coluna.Algorithm.set_ip_dual_bound!(result, Coluna.DualBound(form, dual_bound))
return result
end
################################################################################
# User model
################################################################################
function knapsack_custom_model()
data = ClD.GeneralizedAssignment.data("play2.txt")
coluna = JuMP.optimizer_with_attributes(
Coluna.Optimizer,
"params" => CL.Params(solver = ClA.TreeSearchAlgorithm()),
"default_optimizer" => GLPK.Optimizer
)
model = BlockModel(coluna; direct_model = true)
@axis(M, data.machines)
@variable(model, x[m in M, j in data.jobs], Bin)
@constraint(model,
sp[j in data.jobs], sum(x[m,j] for m in data.machines) == 1
)
@objective(model, Min,
sum(data.cost[j,m]*x[m,j] for m in M, j in data.jobs)
)
@dantzig_wolfe_decomposition(model, dec, M)
sp = getsubproblems(dec)
for m in M
knp_model = KnapsackLibModel(length(data.jobs))
setcapacity!(knp_model, data.capacity[m])
for j in data.jobs
setweight!(knp_model, j, data.weight[j,m])
setcost!(knp_model, j, data.cost[j,m])
map!(knp_model, j, x[m,j])
end
knp_optimizer = KnapsackLibOptimizer(knp_model)
specify!(sp[m], solver = knp_optimizer) ##model = knp_model)
end
optimize!(model)
@test JuMP.objective_value(model) ≈ 75.0
end
register!(e2e_extra_tests, "custom_solver", knapsack_custom_model) | Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 8892 | # This file implements a toy bin packing model to test the before-cutgen-user algorithm.
# It solves an instance with three items where any two of them fits into a bin but the three
# together do not. Pricing is solved by inspection on the set of six possible solutions
# (three singletons and three pairs) which gives a fractional solution at the root node.
# Then a relaxation improvement function "improve_relaxation" is called to remove two of
# the pairs from the list of pricing solutions and from the master problem.
CL.@with_kw struct ImproveRelaxationAlgo <: ClA.AbstractOptimizationAlgorithm
userfunc::Function
end
struct VarData <: BD.AbstractCustomVarData
items::Vector{Int}
end
mutable struct ToyNodeInfoUnit <: ClB.AbstractRecordUnit
value::Int
end
ClB.storage_unit(::Type{ToyNodeInfoUnit}, _) = ToyNodeInfoUnit(111)
struct ToyNodeInfo <: ClB.AbstractRecord
value::Int
end
ClB.record_type(::Type{ToyNodeInfoUnit}) = ToyNodeInfo
ClB.storage_unit_type(::Type{ToyNodeInfo}) = ToyNodeInfoUnit
struct ToyNodeInfoKey <: ClA.AbstractStorageUnitKey end
ClA.key_from_storage_unit_type(::Type{ToyNodeInfoUnit}) = ToyNodeInfoKey()
ClA.record_type_from_key(::ToyNodeInfoKey) = ToyNodeInfo
function ClB.record(::Type{ToyNodeInfo}, id::Int, form::ClMP.Formulation, unit::ToyNodeInfoUnit)
return ToyNodeInfo(unit.value)
end
function ClB.restore_from_record!(form::ClMP.Formulation, unit::ToyNodeInfoUnit, record::ToyNodeInfo)
unit.value = record.value
return
end
function ClA.get_branching_candidate_units_usage(::ClA.SingleVarBranchingCandidate, reform)
units_to_restore = ClA.UnitsUsage()
push!(units_to_restore.units_used, (ClMP.getmaster(reform), ClA.MasterBranchConstrsUnit))
push!(units_to_restore.units_used, (ClMP.getmaster(reform), ToyNodeInfoUnit))
return units_to_restore
end
ClA.ismanager(::ClA.BeforeCutGenAlgo) = false
ClA.ismanager(::ImproveRelaxationAlgo) = false
# Don't need this because `ToyNodeInfo` is bits
# ClMP.copy_info(info::ToyNodeInfo) = ToyNodeInfo(info.value)
function ClA.run!(
algo::ImproveRelaxationAlgo, ::CL.Env, reform::ClMP.Reformulation, input::ClA.OptimizationState
)
masterform = ClMP.getmaster(reform)
_, spform = first(ClMP.get_dw_pricing_sps(reform))
cbdata = ClMP.PricingCallbackData(spform)
return algo.userfunc(masterform, cbdata)
end
function ClA.get_units_usage(algo::ImproveRelaxationAlgo, reform::ClMP.Reformulation)
units_usage = Tuple{ClMP.AbstractModel,ClB.UnitType,ClB.UnitPermission}[]
master = ClMP.getmaster(reform)
push!(units_usage, (master, ToyNodeInfoUnit, ClB.READ_AND_WRITE))
return units_usage
end
function ClA.get_child_algorithms(algo::ClA.BeforeCutGenAlgo, reform::ClMP.Reformulation)
child_algos = Tuple{Coluna.AlgoAPI.AbstractAlgorithm, ClMP.AbstractModel}[]
push!(child_algos, (algo.algorithm, reform))
return child_algos
end
function test_improve_relaxation(; do_improve::Bool)
function build_toy_model(optimizer)
toy = BlockModel(optimizer, direct_model = true)
I = [1, 2, 3]
@axis(B, [1])
@variable(toy, y[b in B] >= 0, Int)
@variable(toy, x[b in B, i in I], Bin)
@constraint(toy, sp[i in I], sum(x[b,i] for b in B) == 1)
@objective(toy, Min, sum(y[b] for b in B))
@dantzig_wolfe_decomposition(toy, dec, B)
customvars!(toy, VarData)
return toy, x, y, dec, B
end
call_improve_relaxation(masterform, cbdata) = improve_relaxation(masterform, cbdata)
coluna = JuMP.optimizer_with_attributes(
CL.Optimizer,
"default_optimizer" => GLPK.Optimizer,
"params" => CL.Params(
solver = ClA.TreeSearchAlgorithm(
conqueralg = ClA.ColCutGenConquer(
colgen = ClA.ColumnGeneration(
stages_pricing_solver_ids = [1]
),
primal_heuristics = [],
before_cutgen_user_algorithm = ClA.BeforeCutGenAlgo(
ImproveRelaxationAlgo(
userfunc = call_improve_relaxation
),
"Improve relaxation"
)
),
dividealg = ClA.ClassicBranching(),
maxnumnodes = do_improve ? 1 : 10
)
)
)
model, x, y, dec, B = build_toy_model(coluna)
max_info_val = 0
function enumerative_pricing(cbdata)
# Get the reduced costs of the original variables
I = [1, 2, 3]
b = BlockDecomposition.callback_spid(cbdata, model)
rc_y = BD.callback_reduced_cost(cbdata, y[b])
rc_x = [BD.callback_reduced_cost(cbdata, x[b, i]) for i in I]
# check all possible solutions
reform = cbdata.form.parent_formulation.parent_formulation
storage = ClMP.getstorage(ClMP.getmaster(reform))
unit = storage.units[ToyNodeInfoUnit].storage_unit # TODO: to improve
info_val = unit.value
max_info_val = max(max_info_val, info_val)
if info_val == 9999
sols = [[1], [2], [3], [2, 3]]
else
sols = [[1], [2], [3], [1, 2], [1, 3], [2, 3]]
end
best_s = Int[]
best_rc = Inf
for s in sols
rc_s = rc_y + sum(rc_x[i] for i in s)
if rc_s < best_rc
best_rc = rc_s
best_s = s
end
end
# build the best one and submit
solcost = best_rc
solvars = JuMP.VariableRef[]
solvarvals = Float64[]
for i in best_s
push!(solvars, x[b, i])
push!(solvarvals, 1.0)
end
push!(solvars, y[b])
push!(solvarvals, 1.0)
# Submit the solution
MOI.submit(
model, BD.PricingSolution(cbdata), solcost, solvars, solvarvals, VarData(best_s)
)
MOI.submit(model, BD.PricingDualBound(cbdata), solcost)
# increment the user info value for testing
if !do_improve
unit.value += 111
end
return
end
subproblems = BD.getsubproblems(dec)
BD.specify!.(
subproblems, lower_multiplicity = 0, upper_multiplicity = 3,
solver = enumerative_pricing
)
function improve_relaxation(masterform, cbdata)
if do_improve
# Get the reduced costs of the original variables
I = [1, 2, 3]
b = BlockDecomposition.callback_spid(cbdata, model)
rc_y = BD.callback_reduced_cost(cbdata, y[b])
rc_x = [BD.callback_reduced_cost(cbdata, x[b, i]) for i in I]
@test (rc_y, rc_x) == (1.0, [-0.5, -0.5, -0.5])
# deactivate the columns of solutions [1, 2] and [1, 3] from the master
changed = false
for (vid, var) in ClMP.getvars(masterform)
if ClMP.iscuractive(masterform, vid) && ClMP.getduty(vid) <= ClMP.MasterCol
varname = ClMP.getname(masterform, var)
if var.custom_data.items in [[1, 2], [1, 3]]
ClMP.deactivate!(masterform, vid)
changed = true
storage = ClMP.getstorage(masterform)
unit = storage.units[ToyNodeInfoUnit].storage_unit # TODO: to improve
unit.value = 9999
end
end
end
@info "improve_relaxation $(changed ? "changed" : "did not change")"
return changed
else
return false
end
end
JuMP.optimize!(model)
@test JuMP.objective_value(model) ≈ 2.0
@test JuMP.termination_status(model) == MOI.OPTIMAL
for b in B
sets = BD.getsolutions(model, b)
for s in sets
@test BD.value(s) == 1.0 # value of the master column variable
@test BD.customdata(s).items == [1] || BD.customdata(s).items == [2, 3] # either [1] or [2, 3]
@test BD.value(s, x[b, 1]) != BD.value(s, x[b, 2]) # only x[1,1] in its set
@test BD.value(s, x[b, 1]) != BD.value(s, x[b, 3]) # only x[1,1] in its set
@test BD.value(s, x[b, 2]) == BD.value(s, x[b, 3]) # x[1,2] and x[1,3] in the same set
end
end
@test do_improve || max_info_val == 888
end
function improve_relaxation_callback()
# Make two tests: one to improve the relaxation and solve at the root node and other to test
# the inheritance of the new user information (increment it in both children nodes and check
# but check if the ones received from parent are unchanged).
# Try to mimic MasterBranchConstrsUnit
test_improve_relaxation(do_improve = true)
test_improve_relaxation(do_improve = false)
end
register!(e2e_extra_tests, "improve_relax_callback", improve_relaxation_callback)
| Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 6451 | # This file implements a toy bin packing model for Node Finalizer. It solves an instance with
# three items where any two of them fits into a bin but the three together do not. Pricing is
# solved by inspection onn the set of six possible solutions (three singletons and three pairs)
# which gives a fractional solution at the root node. Then node finalizer function
# "enumerative_finalizer" is called to find the optimal solution still at the root node and
# avoid branching (which would fail because maxnumnodes is set to 1).
# If "heuristic_finalizer" is true, then it allows branching and assumes that the solution found
# is not necessarily optimal.
CL.@with_kw struct EnumerativeFinalizer <: ClA.AbstractOptimizationAlgorithm
optimizer::Function
end
function ClA.run!(
algo::EnumerativeFinalizer, env::CL.Env, reform::ClMP.Reformulation, input::ClA.OptimizationState
)
masterform = ClMP.getmaster(reform)
_, spform = first(ClMP.get_dw_pricing_sps(reform))
cbdata = ClMP.PricingCallbackData(spform)
isopt, primal_sol = algo.optimizer(masterform, cbdata)
result = ClA.OptimizationState(
masterform,
ip_primal_bound = ClA.get_ip_primal_bound(input),
termination_status = isopt ? CL.OPTIMAL : CL.OTHER_LIMIT
)
if primal_sol !== nothing
ClA.add_ip_primal_sol!(result, primal_sol)
end
return result
end
function test_node_finalizer(heuristic_finalizer)
function build_toy_model(optimizer)
toy = BlockModel(optimizer, direct_model = true)
I = [1, 2, 3]
@axis(B, [1])
@variable(toy, y[b in B] >= 0, Int)
@variable(toy, x[b in B, i in I], Bin)
@constraint(toy, sp[i in I], sum(x[b,i] for b in B) == 1)
@objective(toy, Min, sum(y[b] for b in B))
@dantzig_wolfe_decomposition(toy, dec, B)
return toy, x, y, dec, B
end
call_enumerative_finalizer(masterform, cbdata) = enumerative_finalizer(masterform, cbdata)
coluna = JuMP.optimizer_with_attributes(
CL.Optimizer,
"default_optimizer" => GLPK.Optimizer,
"params" => CL.Params(
solver = ClA.TreeSearchAlgorithm(
conqueralg = ClA.ColCutGenConquer(
colgen= ClA.ColumnGeneration(
stages_pricing_solver_ids = [1]
),
primal_heuristics = [],
node_finalizer = ClA.NodeFinalizer(
EnumerativeFinalizer(optimizer = call_enumerative_finalizer),
0, "Enumerative"
)
),
maxnumnodes = heuristic_finalizer ? 15 : 1
)
)
)
model, x, y, dec, B = build_toy_model(coluna)
function enumerative_pricing(cbdata)
# Get the reduced costs of the original variables
I = [1, 2, 3]
b = BlockDecomposition.callback_spid(cbdata, model)
rc_y = BD.callback_reduced_cost(cbdata, y[b])
rc_x = [BD.callback_reduced_cost(cbdata, x[b, i]) for i in I]
# check all possible solutions
sols = [[1], [2], [3], [1, 2], [1, 3], [2, 3]]
best_s = Int[]
best_rc = Inf
for s in sols
rc_s = rc_y + sum(rc_x[i] for i in s)
if rc_s < best_rc
best_rc = rc_s
best_s = s
end
end
# build the best one and submit
solcost = best_rc
solvars = JuMP.VariableRef[]
solvarvals = Float64[]
for i in best_s
push!(solvars, x[b, i])
push!(solvarvals, 1.0)
end
push!(solvars, y[b])
push!(solvarvals, 1.0)
# Submit the solution
MOI.submit(
model, BD.PricingSolution(cbdata), solcost, solvars, solvarvals
)
MOI.submit(model, BD.PricingDualBound(cbdata), solcost)
return
end
subproblems = BD.getsubproblems(dec)
BD.specify!.(
subproblems, lower_multiplicity = 0, upper_multiplicity = 3,
solver = enumerative_pricing
)
function enumerative_finalizer(masterform, cbdata)
# Get the reduced costs of the original variables
I = [1, 2, 3]
b = BlockDecomposition.callback_spid(cbdata, model)
rc_y = BD.callback_reduced_cost(cbdata, y[b])
rc_x = [BD.callback_reduced_cost(cbdata, x[b, i]) for i in I]
@test (rc_y, rc_x) == (1.0, [-0.5, -0.5, -0.5])
# Add the columns that are possibly missing for the solution [[1], [2,3]] in the master problem
# [1]
opt = JuMP.backend(model)
vars = [y[b], x[b, 1]]
varids = [CL._get_varid_of_origvar_in_form(opt.env, cbdata.form, v) for v in JuMP.index.(vars)]
push!(varids, cbdata.form.duty_data.setup_var)
sol = ClMP.PrimalSolution(cbdata.form, varids, [1.0, 1.0, 1.0], 1.0, CL.FEASIBLE_SOL)
col_id = ClMP.insert_column!(masterform, sol, "MC")
mc_1 = ClMP.getvar(masterform, col_id)
# [2, 3]
vars = [y[b], x[b, 2], x[b, 3]]
varids = [CL._get_varid_of_origvar_in_form(opt.env, cbdata.form, v) for v in JuMP.index.(vars)]
push!(varids, cbdata.form.duty_data.setup_var)
sol = ClMP.PrimalSolution(cbdata.form, varids, [1.0, 1.0, 1.0, 1.0], 1.0, CL.FEASIBLE_SOL)
col_id = ClMP.insert_column!(masterform, sol, "MC")
mc_2_3 = ClMP.getvar(masterform, col_id)
# add the solution to the master problem
varids = [ClMP.getid(mc_1), ClMP.getid(mc_2_3)]
primal_sol = ClMP.PrimalSolution(masterform, varids, [1.0, 1.0], 2.0, CL.FEASIBLE_SOL)
return !heuristic_finalizer, primal_sol
end
JuMP.optimize!(model)
@show JuMP.objective_value(model)
@test JuMP.termination_status(model) == MOI.OPTIMAL
for b in B
sets = BD.getsolutions(model, b)
for s in sets
@test BD.value(s) == 1.0 # value of the master column variable
@test BD.value(s, x[b, 1]) != BD.value(s, x[b, 2]) # only x[1,1] in its set
@test BD.value(s, x[b, 1]) != BD.value(s, x[b, 3]) # only x[1,1] in its set
@test BD.value(s, x[b, 2]) == BD.value(s, x[b, 3]) # x[1,2] and x[1,3] in the same set
end
end
end
function test_node_finalizer()
test_node_finalizer(false) # exact
test_node_finalizer(true) # heuristic
end
register!(e2e_extra_tests, "node_finalizer", test_node_finalizer) | Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 5280 | #=
Custom Variable and Cuts test
This test creates a Bin Packing instances with only 3 items such that any pair of items
fits into one bin but the 3 items not. The objective function is to minimize the number
of bins. Pricing is done by inspection over the 6 combinations of items (3 pairs and 3
singletons). The root relaxation has 1.5 bins, each 0.5 corresponding to a bin with one
of the possible pairs of items. Coluna is able to solve this instance by branching on the
number of bins but the limit one on the number of nodes prevents it to be solved without
cuts. Every subproblem solution s has a custom data with the number of items in the bin,
given by length(s). The custom cut used to cut the fractional solution is
sum(λ_s for s in sols if length(s) >= 2) <= 1.0
where sols is the set of possible combinations of items in a bin.
=#
struct MyCustomVarData <: BD.AbstractCustomVarData
nb_items::Int
end
BD.branchingpriority(::MyCustomVarData) = 0.5
struct MyCustomCutData <: BD.AbstractCustomConstrData
min_items::Int
end
function Coluna.MathProg.computecoeff(
var_custom_data::MyCustomVarData, constr_custom_data::MyCustomCutData
)
return (var_custom_data.nb_items >= constr_custom_data.min_items) ? 1.0 : 0.0
end
function build_toy_model(optimizer)
toy = BlockModel(optimizer)
I = [1, 2, 3]
@axis(B, [1])
@variable(toy, y[b in B] >= 0, Int)
@variable(toy, x[b in B, i in I], Bin)
@constraint(toy, sp[i in I], sum(x[b,i] for b in B) == 1)
@objective(toy, Min, sum(y[b] for b in B))
@dantzig_wolfe_decomposition(toy, dec, B)
return toy, x, y, dec
end
function test_non_robust_cuts()
coluna = JuMP.optimizer_with_attributes(
CL.Optimizer,
"default_optimizer" => GLPK.Optimizer,
"params" => CL.Params(
solver = ClA.TreeSearchAlgorithm(
conqueralg = ClA.ColCutGenConquer(
colgen = ClA.ColumnGeneration(
# pricing_prob_solve_alg = ClA.SolveIpForm(
# optimizer_id = 1
# )
)
),
maxnumnodes = 1
)
)
)
model, x, y, dec = build_toy_model(coluna)
BD.customvars!(model, MyCustomVarData)
BD.customconstrs!(model, MyCustomCutData)
function my_pricing_callback(cbdata)
# Get the reduced costs of the original variables
I = [1, 2, 3]
b = BD.callback_spid(cbdata, model)
rc_y = BD.callback_reduced_cost(cbdata, y[b])
rc_x = [BD.callback_reduced_cost(cbdata, x[b, i]) for i in I]
# Get the dual values of the custom cuts
custduals = Tuple{Int, Float64}[]
for (_, constr) in Coluna.MathProg.getconstrs(cbdata.form.parent_formulation)
if typeof(constr.custom_data) == MyCustomCutData
push!(custduals, (
constr.custom_data.min_items,
ClMP.getcurincval(cbdata.form.parent_formulation, constr)
))
end
end
# check all possible solutions
sols = [[1], [2], [3], [1, 2], [1, 3], [2, 3]]
best_s = Int[]
best_rc = Inf
for s in sols
rc_s = rc_y + sum(rc_x[i] for i in s)
if !isempty(custduals)
rc_s -= sum((length(s) >= minits) ? dual : 0.0 for (minits, dual) in custduals)
end
if rc_s < best_rc
best_rc = rc_s
best_s = s
end
end
# build the best one and submit
solcost = best_rc
solvars = JuMP.VariableRef[]
solvarvals = Float64[]
for i in best_s
push!(solvars, x[b, i])
push!(solvarvals, 1.0)
end
push!(solvars, y[b])
push!(solvarvals, 1.0)
# Submit the solution
MOI.submit(
model, BD.PricingSolution(cbdata), solcost, solvars, solvarvals,
MyCustomVarData(length(best_s))
)
MOI.submit(model, BD.PricingDualBound(cbdata), solcost)
return
end
subproblems = BD.getsubproblems(dec)
BD.specify!.(
subproblems, lower_multiplicity = 0, upper_multiplicity = 3,
solver = my_pricing_callback
)
function custom_cut_sep(cbdata)
# compute the constraint violation
viol = -1.0
for (varid, varval) in cbdata.orig_sol
var = ClMP.getvar(cbdata.form, varid)
if var.custom_data !== nothing
if var.custom_data.nb_items >= 2
viol += varval
end
end
end
# add the cut (at most one variable with 2 or more of the 3 items) if violated
if viol > 0.001
MOI.submit(
model, MOI.UserCut(cbdata),
JuMP.ScalarConstraint(JuMP.AffExpr(0.0), MOI.LessThan(1.0)), MyCustomCutData(2)
)
end
return
end
MOI.set(model, MOI.UserCutCallback(), custom_cut_sep)
JuMP.optimize!(model)
@test JuMP.termination_status(model) == MOI.OPTIMAL
end
register!(e2e_extra_tests, "non_robust_cuts", test_non_robust_cuts) | Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 4067 | function gap_with_pricing_callback_and_stages()
data = ClD.GeneralizedAssignment.data("play2.txt")
coluna = JuMP.optimizer_with_attributes(
CL.Optimizer,
"default_optimizer" => GLPK.Optimizer,
"params" => CL.Params(
solver = ClA.BranchCutAndPriceAlgorithm(
colgen_stages_pricing_solvers = [3, 2]
)
)
)
model, x, dec = ClD.GeneralizedAssignment.model_without_knp_constraints(data, coluna)
# Subproblem models are created once and for all
# One model for each machine.
sp_models = Dict{Int, Any}()
for m in data.machines
sp = JuMP.Model(GLPK.Optimizer)
@variable(sp, y[j in data.jobs], Bin)
@variable(sp, lb_y[j in data.jobs] >= 0)
@variable(sp, ub_y[j in data.jobs] >= 0)
@variable(sp, max_card >= 0) # this sets the maximum solution cardinality for heuristic pricing
@constraint(sp, card, sum(y[j] for j in data.jobs) <= max_card)
@constraint(sp, knp, sum(data.weight[j,m]*y[j] for j in data.jobs) <= data.capacity[m])
@constraint(sp, lbs[j in data.jobs], y[j] + lb_y[j] >= 0)
@constraint(sp, ubs[j in data.jobs], y[j] - ub_y[j] <= 0)
sp_models[m] = (sp, y, lb_y, ub_y, max_card)
end
nb_exact_calls = 0
function pricing_callback_stage2(cbdata)
machine_id = BD.callback_spid(cbdata, model)
_, _, _, _, max_card = sp_models[machine_id]
JuMP.fix(max_card, 3, force = true)
solcost, solvars, solvarvals = solve_pricing!(cbdata, machine_id)
MOI.submit(
model, BD.PricingSolution(cbdata), solcost, solvars, solvarvals
)
MOI.submit(model, BD.PricingDualBound(cbdata), -Inf)
end
function pricing_callback_stage1(cbdata)
machine_id = BD.callback_spid(cbdata, model)
_, _, _, _, max_card = sp_models[machine_id]
JuMP.fix(max_card, length(data.jobs), force = true)
nb_exact_calls += 1
solcost, solvars, solvarvals = solve_pricing!(cbdata, machine_id)
MOI.submit(
model, BD.PricingSolution(cbdata), solcost, solvars, solvarvals
)
MOI.submit(model, BD.PricingDualBound(cbdata), solcost)
end
function solve_pricing!(cbdata, machine_id)
sp, y, lb_y, ub_y, _ = sp_models[machine_id]
red_costs = [BD.callback_reduced_cost(cbdata, x[machine_id, j]) for j in data.jobs]
# Update the model
## Bounds on subproblem variables
for j in data.jobs
JuMP.fix(lb_y[j], BD.callback_lb(cbdata, x[machine_id, j]), force = true)
JuMP.fix(ub_y[j], BD.callback_ub(cbdata, x[machine_id, j]), force = true)
end
## Objective function
@objective(sp, Min, sum(red_costs[j]*y[j] for j in data.jobs))
JuMP.optimize!(sp)
# Retrieve the solution
solcost = JuMP.objective_value(sp)
solvars = JuMP.VariableRef[]
solvarvals = Float64[]
for j in data.jobs
val = JuMP.value(y[j])
if val ≈ 1
push!(solvars, x[machine_id, j])
push!(solvarvals, 1.0)
end
end
return solcost, solvars, solvarvals
end
subproblems = BD.getsubproblems(dec)
BD.specify!.(subproblems, lower_multiplicity = 0, solver = [GLPK.Optimizer, pricing_callback_stage2, pricing_callback_stage1])
JuMP.optimize!(model)
@test nb_exact_calls < 30 # WARNING: this test is necessary to properly test stage 2.
# Disabling stage 2 (uncommenting line 48) generates 40 exact
# calls, against 18 when it is enabled. These numbers may change
# a little bit with versions due to numerical errors.
@test JuMP.objective_value(model) ≈ 75.0
@test JuMP.termination_status(model) == MOI.OPTIMAL
@test ClD.GeneralizedAssignment.print_and_check_sol(data, model, x)
end
register!(e2e_extra_tests, "pricing_callback", gap_with_pricing_callback_and_stages) | Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 11026 | function gap_small_instance()
data = ClD.GeneralizedAssignment.data("smallgap3.txt")
coluna = JuMP.optimizer_with_attributes(
Coluna.Optimizer,
"params" => CL.Params(solver = ClA.BranchCutAndPriceAlgorithm()),
"default_optimizer" => GLPK.Optimizer
)
model, x, dec = ClD.GeneralizedAssignment.model(data, coluna)
BD.objectiveprimalbound!(model, 500.0)
BD.objectivedualbound!(model, 0.0)
JuMP.optimize!(model)
@test JuMP.objective_value(model) ≈ 438.0
@test JuMP.termination_status(model) == MOI.OPTIMAL
@test ClD.GeneralizedAssignment.print_and_check_sol(data, model, x)
end
register!(e2e_extra_tests, "gap", gap_small_instance)
function gap_node_limit()
data = ClD.GeneralizedAssignment.data("mediumgapcuts3.txt")
coluna = JuMP.optimizer_with_attributes(
CL.Optimizer,
"params" => CL.Params(
solver = ClA.BranchCutAndPriceAlgorithm(
maxnumnodes = 5
)
),
"default_optimizer" => GLPK.Optimizer
)
model, x, dec = ClD.GeneralizedAssignment.model(data, coluna)
BD.objectiveprimalbound!(model, 2000.0)
BD.objectivedualbound!(model, 0.0)
JuMP.optimize!(model)
@test JuMP.objective_bound(model) ≈ 1547.3889
@test JuMP.termination_status(model) == MathOptInterface.OTHER_LIMIT
end
register!(e2e_extra_tests, "gap", gap_node_limit)
function gap_colgen_max_nb_iterations()
data = ClD.GeneralizedAssignment.data("smallgap3.txt")
coluna = JuMP.optimizer_with_attributes(
CL.Optimizer,
"params" => CL.Params(
solver = ClA.TreeSearchAlgorithm(
conqueralg = ClA.ColCutGenConquer(
colgen = ClA.ColumnGeneration(max_nb_iterations = 8),
)
)
),
"default_optimizer" => GLPK.Optimizer
)
problem, x, dec = ClD.GeneralizedAssignment.model(data, coluna)
JuMP.optimize!(problem)
@test abs(JuMP.objective_value(problem) - 438.0) <= 0.00001
@test JuMP.termination_status(problem) == MOI.OTHER_LIMIT
@test ClD.GeneralizedAssignment.print_and_check_sol(data, problem, x)
end
register!(e2e_extra_tests, "gap", gap_colgen_max_nb_iterations)
function gap_pure_master_variables()
data = ClD.GeneralizedAssignment.data("smallgap3.txt")
coluna = JuMP.optimizer_with_attributes(
Coluna.Optimizer,
"params" => CL.Params(solver = ClA.BranchCutAndPriceAlgorithm()),
"default_optimizer" => GLPK.Optimizer
)
problem, x, y, dec = ClD.GeneralizedAssignment.model_with_penalties(data, coluna)
JuMP.optimize!(problem)
@test JuMP.termination_status(problem) == MOI.OPTIMAL
@test abs(JuMP.objective_value(problem) - 416.4) <= 0.00001
end
register!(e2e_extra_tests, "gap", gap_pure_master_variables)
function gap_maximisation_objective_function()
data = ClD.GeneralizedAssignment.data("smallgap3.txt")
coluna = JuMP.optimizer_with_attributes(
Coluna.Optimizer,
"params" => CL.Params(solver = ClA.BranchCutAndPriceAlgorithm()),
"default_optimizer" => GLPK.Optimizer
)
problem, x, dec = ClD.GeneralizedAssignment.model_max(data, coluna)
JuMP.optimize!(problem)
@test JuMP.termination_status(problem) == MOI.OPTIMAL
@test abs(JuMP.objective_value(problem) - 580.0) <= 0.00001
end
register!(e2e_extra_tests, "gap", gap_maximisation_objective_function)
function gap_infeasible_master()
data = ClD.GeneralizedAssignment.data("master_infeas.txt")
coluna = JuMP.optimizer_with_attributes(
Coluna.Optimizer,
"params" => CL.Params(solver = ClA.BranchCutAndPriceAlgorithm()),
"default_optimizer" => GLPK.Optimizer
)
problem, x, dec = ClD.GeneralizedAssignment.model(data, coluna)
JuMP.optimize!(problem)
@test JuMP.termination_status(problem) == MOI.INFEASIBLE
end
register!(e2e_extra_tests, "gap", gap_infeasible_master)
function gap_infeasible_master_2()
data = ClD.GeneralizedAssignment.data("master_infeas2.txt")
coluna = JuMP.optimizer_with_attributes(
Coluna.Optimizer,
"params" => CL.Params(solver = ClA.BranchCutAndPriceAlgorithm()),
"default_optimizer" => GLPK.Optimizer
)
problem, x, dec = ClD.GeneralizedAssignment.model(data, coluna)
JuMP.optimize!(problem)
@test JuMP.termination_status(problem) == MOI.INFEASIBLE
end
register!(e2e_extra_tests, "gap", gap_infeasible_master_2)
function gap_infeasible_subproblem()
data = ClD.GeneralizedAssignment.data("sp_infeas.txt")
coluna = JuMP.optimizer_with_attributes(
Coluna.Optimizer,
"params" => CL.Params(solver = ClA.BranchCutAndPriceAlgorithm()),
"default_optimizer" => GLPK.Optimizer
)
problem, x, dec = ClD.GeneralizedAssignment.model(data, coluna)
JuMP.optimize!(problem)
@test JuMP.termination_status(problem) == MOI.INFEASIBLE
end
register!(e2e_extra_tests, "gap", gap_infeasible_subproblem)
function gap_with_all_phases_in_colgen()
data = ClD.GeneralizedAssignment.data("mediumgapcuts1.txt")
for m in data.machines
data.capacity[m] = floor(Int, data.capacity[m] * 0.5)
end
coluna = JuMP.optimizer_with_attributes(
Coluna.Optimizer,
"params" => CL.Params(solver = ClA.TreeSearchAlgorithm(
conqueralg = ClA.ColCutGenConquer(
colgen = ClA.ColumnGeneration(opt_rtol = 1e-4, smoothing_stabilization = 0.5)
)
)),
"default_optimizer" => GLPK.Optimizer
)
problem, x, y, dec = ClD.GeneralizedAssignment.model_with_penalty(data, coluna)
JuMP.optimize!(problem)
@test abs(JuMP.objective_value(problem) - 31895.0) <= 0.00001
end
register!(e2e_extra_tests, "gap", gap_with_all_phases_in_colgen)
function gap_with_max_obj_pure_master_vars_and_stab()
data = ClD.GeneralizedAssignment.data("gapC-5-100.txt")
coluna = JuMP.optimizer_with_attributes(
CL.Optimizer,
"params" => CL.Params(
solver = ClA.BranchCutAndPriceAlgorithm(
colgen_stabilization = 1.0,
maxnumnodes = 300
)
),
"default_optimizer" => GLPK.Optimizer
)
model, x, y, dec = ClD.GeneralizedAssignment.max_model_with_subcontracts(data, coluna)
JuMP.optimize!(model)
@test JuMP.objective_value(model) ≈ 3520.1
@test JuMP.termination_status(model) == MOI.OPTIMAL
end
register!(e2e_extra_tests, "gap", gap_with_max_obj_pure_master_vars_and_stab)
function gap_with_no_solver()
data = ClD.GeneralizedAssignment.data("play2.txt")
coluna = JuMP.optimizer_with_attributes(
Coluna.Optimizer,
"params" => CL.Params(solver = ClA.BranchCutAndPriceAlgorithm())
)
problem, x, dec = ClD.GeneralizedAssignment.model(data, coluna)
try
JuMP.optimize!(problem)
catch e
@test e isa ErrorException
end
end
register!(e2e_extra_tests, "gap", gap_with_no_solver)
# We solve the GAP but only one set-partionning constraint (for job 1) is
# put in the formulation before starting optimization.
# Other set-partionning constraints are added in the essential cut callback.
function gap_with_lazy_cuts()
data = ClD.GeneralizedAssignment.data("play2.txt")
coluna = JuMP.optimizer_with_attributes(
Coluna.Optimizer,
"params" => CL.Params(solver = ClA.BranchCutAndPriceAlgorithm(
max_nb_cut_rounds = 1000
)),
"default_optimizer" => GLPK.Optimizer
)
model = BlockModel(coluna, direct_model = true)
@axis(M, data.machines)
@variable(model, x[m in M, j in data.jobs], Bin)
@constraint(model, cov, sum(x[m,1] for m in M) == 1) # add only covering constraint of job 1
@constraint(model, knp[m in M],
sum(data.weight[j,m]*x[m,j] for j in data.jobs) <= data.capacity[m]
)
@objective(model, Min,
sum(data.cost[j,m]*x[m,j] for m in M, j in data.jobs)
)
@dantzig_wolfe_decomposition(model, dec, M)
subproblems = BlockDecomposition.getsubproblems(dec)
specify!.(subproblems, lower_multiplicity = 0)
cur_j = 1
# Lazy cut callback (add covering constraints on jobs on the fly)
function my_callback_function(cb_data)
for j in 1:cur_j
@test sum(callback_value(cb_data, x[m,j]) for m in M) ≈ 1
end
if cur_j < length(data.jobs)
cur_j += 1
con = @build_constraint(sum(x[m,cur_j] for m in M) == 1)
MOI.submit(model, MOI.LazyConstraint(cb_data), con)
end
end
MOI.set(model, MOI.LazyConstraintCallback(), my_callback_function)
optimize!(model)
@test JuMP.objective_value(model) ≈ 75.0
@test JuMP.termination_status(model) == MOI.OPTIMAL
end
register!(e2e_extra_tests, "gap", gap_with_lazy_cuts)
function gap_with_best_dual_bound()
data = ClD.GeneralizedAssignment.data("play2.txt")
coluna = JuMP.optimizer_with_attributes(
CL.Optimizer,
"params" => CL.Params(
solver = Coluna.Algorithm.TreeSearchAlgorithm(
explorestrategy = Coluna.TreeSearch.BestDualBoundStrategy()
)
),
"default_optimizer" => GLPK.Optimizer
)
model, x, dec = ClD.GeneralizedAssignment.model(data, coluna)
optimize!(model)
@test JuMP.objective_value(model) ≈ 75.0
@test JuMP.termination_status(model) == MOI.OPTIMAL
end
register!(e2e_extra_tests, "gap", gap_with_best_dual_bound)
function gap_with_obj_const()
M = 1:3;
J = 1:15;
c = [12.7 22.5 8.9 20.8 13.6 12.4 24.8 19.1 11.5 17.4 24.7 6.8 21.7 14.3 10.5; 19.1 24.8 24.4 23.6 16.1 20.6 15.0 9.5 7.9 11.3 22.6 8.0 21.5 14.7 23.2; 18.6 14.1 22.7 9.9 24.2 24.5 20.8 12.9 17.7 11.9 18.7 10.1 9.1 8.9 7.7; 13.1 16.2 16.8 16.7 9.0 16.9 17.9 12.1 17.5 22.0 19.9 14.6 18.2 19.6 24.2];
w = [61 70 57 82 51 74 98 64 86 80 69 79 60 76 78; 50 57 61 83 81 79 63 99 82 59 83 91 59 99 91;91 81 66 63 59 81 87 90 65 55 57 68 92 91 86; 62 79 73 60 75 66 68 99 69 60 56 100 67 68 54];
Q = [1020 1460 1530];
coluna = optimizer_with_attributes(
Coluna.Optimizer,
"params" => Coluna.Params(
solver = Coluna.Algorithm.TreeSearchAlgorithm() # default branch-cut-and-price
),
"default_optimizer" => GLPK.Optimizer # GLPK for the master & the subproblems
);
model = BlockModel(coluna)
@axis(M_axis, M);
@variable(model, x[m in M_axis, j in J], Bin);
@constraint(model, cov[j in J], sum(x[m, j] for m in M_axis) >= 1);
@constraint(model, knp[m in M_axis], sum(w[m, j] * x[m, j] for j in J) <= Q[m]);
@objective(model, Min, sum(c[m, j] * x[m, j] for m in M_axis, j in J) + 250);
@dantzig_wolfe_decomposition(model, decomposition, M_axis)
subproblems = getsubproblems(decomposition)
specify!.(subproblems, lower_multiplicity = 0, upper_multiplicity = 1)
optimize!(model)
@test JuMP.objective_value(model) ≈ 250 + 166.5
return
end
register!(e2e_extra_tests, "gap", gap_with_obj_const)
| Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 2094 | @testset "Integration - initial columns callback" begin
function build_reformulation()
nb_variables = 4
form_string = """
master
min
1.0*x1 + 2.0*x2 + 3.0*x3 + 4.0*x4
s.t.
1.0*x1 + 2.0*x2 + 3.0*x3 + 4.0*x4 >= 0.0
dw_sp
min
1.0*x1 + 2.0*x2 + 3.0*x3 + 4.0*x4
continuous
representatives
x1, x2, x3, x4
"""
env, master, subproblems, constraints, _ = reformfromstring(form_string)
spform = subproblems[1]
spvarids = Dict(CL.getname(spform, var) => varid for (varid, var) in CL.getvars(spform))
# Fake JuMP model to simulate the user interacting with it in the callback.
fake_model = JuMP.Model()
@variable(fake_model, x[i in 1:nb_variables])
for name in ["x$i" for i in 1:nb_variables]
CleverDicts.add_item(env.varids, spvarids[name])
end
return env, master, spform, x, constraints[1]
end
# Create a formulation with 4 variables [x1 x2 x3 x4] and provide an initial column
# [1 0 2 0].
# Cost of the column in the master should be 7.
# Coefficient of the column in the constraint should be 7.
@testset "normal case" begin
env, master, spform, x, constr = build_reformulation()
function callback(cbdata)
variables = [x[1].index, x[3].index]
values = [1.0, 2.0]
custom_data = nothing
CL._submit_initial_solution(env, cbdata, variables, values, custom_data)
end
ClMP.initialize_solution_pool!(spform, callback)
# iMC_5 because 4 variables before this one
initcolid = findfirst(var -> ClMP.getname(master, var) == "iMC_5", ClMP.getvars(master))
@test initcolid !== nothing
@test ClMP.getperencost(master, initcolid) == 7
@test ClMP.iscuractive(master, initcolid)
@test ClMP.getcoefmatrix(master)[ClMP.getid(constr), initcolid] == 7
end
end | Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 5389 | @testset "Decomposition with representatives and single subproblem" begin
d = CvrpToyData(false)
model, x, cov, mast, sps, dec = cvrp_with_representatives(d)
JuMP.optimize!(model)
@test objective_value(model) ≈ 59
end
@testset "Decomposition with representatives and multiple subproblems" begin
d = CvrpToyData(true)
model, x, cov, mast, sps, dec = cvrp_with_representatives(d)
JuMP.optimize!(model)
@test objective_value(model) ≈ 69
# Test with all routes for the cheapest vehicle because it generated an error
d.nb_sols[1] = 13
model, x, cov, mast, sps, dec = cvrp_with_representatives(d)
JuMP.optimize!(model)
@test objective_value(model) ≈ 59
end
struct CvrpSol
travel_cost
edges
coeffs
end
struct CvrpData
vehicle_types
E
V
δ
edge_costs
fixed_costs # by vehicle type
nb_sols # by vehicle type
sp_sols
end
function CvrpToyData(is_hfvrp)
vehicle_types = is_hfvrp ? [1, 2] : [1]
E = [(1,2), (1,3), (1,4), (1,5), (2,3), (2,4), (2,5), (3,4), (3,5), (4,5)]
V = [1,2,3,4,5]
δ = Dict(
1 => [(1,2), (1,3), (1,4), (1,5)],
2 => [(1,2), (2,3), (2,4), (2,5)],
3 => [(1,3), (2,3), (3,4), (3,5)],
4 => [(1,4), (2,4), (3,4), (4,5)],
5 => [(1,5), (2,5), (3,5), (4,5)]
)
edge_costs = [10, 11, 13, 12, 4, 5, 6, 7, 8, 9]
fixed_costs = is_hfvrp ? [0, 10] : [0]
nb_sols = is_hfvrp ? [4, 13] : [13]
sp_sols = [
CvrpSol(20, [(1,2)], [2]),
CvrpSol(22, [(1,3)], [2]),
CvrpSol(26, [(1,4)], [2]),
CvrpSol(24, [(1,5)], [2]),
CvrpSol(10 + 4 + 11, [(1,2), (2,3), (1,3)], [1, 1, 1]),
CvrpSol(10 + 5 + 13, [(1,2), (2,4), (1,4)], [1, 1, 1]),
CvrpSol(10 + 6 + 12, [(1,2), (2,5), (1,5)], [1, 1, 1]),
CvrpSol(11 + 7 + 13, [(1,3), (3,4), (1,4)], [1, 1, 1]),
CvrpSol(11 + 8 + 12, [(1,3), (3,5), (1,5)], [1, 1, 1]),
CvrpSol(13 + 9 + 12, [(1,4), (4,5), (1,5)], [1, 1, 1]),
CvrpSol(11 + 7 + 9 + 12, [(1,3), (3,4), (4,5), (1,5)], [1, 1, 1, 1]),
CvrpSol(13 + 7 + 9 + 12, [(1,4), (3,4), (4,5), (1,5)], [1, 1, 1, 1]),
CvrpSol(11 + 8 + 9 + 13, [(1,3), (3,5), (4,5), (1,4)], [1, 1, 1, 1]),
]
return CvrpData(vehicle_types, E, V, δ, edge_costs, fixed_costs, nb_sols, sp_sols)
end
function cvrp_with_representatives(data::CvrpData)
V₊ = data.V[2:end]
edgeidx = Dict(
(1,2) => 1,
(1,3) => 2,
(1,4) => 3,
(1,5) => 4,
(2,3) => 5,
(2,4) => 6,
(2,5) => 7,
(3,4) => 8,
(3,5) => 9,
(4,5) => 10
)
rcost(sol, rcosts) = sum(
rcosts[edgeidx[e]] * sol.coeffs[i] for (i,e) in enumerate(sol.edges)
)
coluna = JuMP.optimizer_with_attributes(
Coluna.Optimizer,
"params" => CL.Params(solver = ClA.BranchCutAndPriceAlgorithm(
maxnumnodes = 10000,
branchingtreefile = "cvrp.dot"
)),
"default_optimizer" => GLPK.Optimizer
)
@axis(VehicleTypes, data.vehicle_types)
model = BlockModel(coluna)
@variable(model, 0 <= x[e in data.E] <= 2, Int)
if length(data.vehicle_types) > 1
@variable(model, y[vt in VehicleTypes] >= 0)
@objective(model, Min,
sum(data.fixed_costs[vt] * y[vt] for vt in VehicleTypes) +
sum(data.edge_costs[i] * x[e] for (i,e) in enumerate(data.E))
)
else
@objective(model, Min, sum(data.edge_costs[i] * x[e] for (i,e) in enumerate(data.E)))
end
@constraint(model, cov[v in V₊], sum(x[e] for e in data.δ[v]) == 2)
@dantzig_wolfe_decomposition(model, dec, VehicleTypes)
function route_pricing_callback(cbdata)
spid = BlockDecomposition.callback_spid(cbdata, model)
rcosts = [BlockDecomposition.callback_reduced_cost(cbdata, x[e]) for e in data.E]
bestsol = data.sp_sols[1]
bestrc = rcost(bestsol, rcosts)
for sol in data.sp_sols[2:data.nb_sols[spid]]
rc = rcost(sol, rcosts)
if rc < bestrc
bestrc = rc
bestsol = sol
end
end
if length(data.vehicle_types) > 1
bestrc += BlockDecomposition.callback_reduced_cost(cbdata, y[spid])
end
# Create the solution (send only variables with non-zero values)
solvars = JuMP.VariableRef[]
solvals = Float64[]
for (i,e) in enumerate(bestsol.edges)
push!(solvars, x[e])
push!(solvals, bestsol.coeffs[i])
end
if length(data.vehicle_types) > 1
push!(solvars, y[spid])
push!(solvals, 1.0)
end
# Submit the solution to the subproblem to Coluna
MOI.submit(model, BlockDecomposition.PricingSolution(cbdata), bestrc, solvars, solvals)
MOI.submit(model, BlockDecomposition.PricingDualBound(cbdata), bestrc)
end
master = BlockDecomposition.getmaster(dec)
subproblems = BlockDecomposition.getsubproblems(dec)
subproblemrepresentative.(x, Ref(subproblems))
sp_lm = (length(data.vehicle_types) == 1) ? 2 : 0
for vt in VehicleTypes
specify!(
subproblems[vt], lower_multiplicity = sp_lm, upper_multiplicity = 4,
solver = route_pricing_callback
)
end
return model, x, cov, master, subproblems, dec
end
| Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 282 | dirs = [
"custom_data",
"parser",
"pricing_callback",
"MOI"
]
for dir in dirs
dirpath = joinpath(@__DIR__, dir)
for filename in readdir(dirpath)
include(joinpath(dirpath, filename))
end
end
run_integration_tests() = run_tests(integration_tests) | Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 2720 | # # We want to make sure that when put variables in the partial solution, these variables are
# # removed from the subsolver and the solution returned contains the variables in the partial solution
# # variables and the cost of the partial solution.
function test_fixed_variables()
env = CL.Env{ClMP.VarId}(CL.Params())
# Create the following formulation:
# min x1 + 2x2 + 3x3
# st. x1 + 2x2 + 3x3 >= 16
# x1 >= 1
# x2 >= 2
# x3 >= 3
form = ClMP.create_formulation!(env, ClMP.DwMaster())
vars = Dict{String, ClMP.Variable}()
for i in 1:3
x = ClMP.setvar!(form, "x$i", ClMP.OriginalVar; cost = i, lb = i)
vars["x$i"] = x
end
members = Dict{ClMP.VarId,Float64}(
ClMP.getid(vars["x1"]) => 1,
ClMP.getid(vars["x2"]) => 2,
ClMP.getid(vars["x3"]) => 3
)
c = ClMP.setconstr!(form, "c", ClMP.OriginalConstr;
rhs = 16, sense = ClMP.Greater, members = members
)
ClMP.push_optimizer!(form, CL._optimizerbuilder(MOI._instantiate_and_check(GLPK.Optimizer)))
DynamicSparseArrays.closefillmode!(ClMP.getcoefmatrix(form))
output = ClA.run!(ClA.SolveLpForm(get_dual_sol = true), env, form, ClA.OptimizationState(form))
primal_sol = ClA.get_best_lp_primal_sol(output)
dual_sol = ClA.get_best_lp_dual_sol(output)
@test ClMP.getvalue(primal_sol) == 16
@test ClMP.getvalue(dual_sol) == 16
@test ClMP.getcurrhs(form, c) == 16
@test primal_sol[ClMP.getid(vars["x1"])] == 1
@test primal_sol[ClMP.getid(vars["x2"])] == 2
@test primal_sol[ClMP.getid(vars["x3"])] ≈ 3 + 2/3
# min x1' + 2x2' + 3x3'
# st. x1' + 2x2' + 3x3' >= 16 - 1 - 4 - 9 >= 2
# x1' >= 0
# x2' >= 0
# x3' >= 0
ClMP.add_to_partial_solution!(form, vars["x1"], 1)
ClMP.add_to_partial_solution!(form, vars["x2"], 2)
ClMP.add_to_partial_solution!(form, vars["x3"], 3)
# We perform propagation by hand (the preprocessing should do it)
ClMP.setcurrhs!(form, c, 2.0)
ClMP.setcurlb!(form, vars["x1"], 0.0)
ClMP.setcurlb!(form, vars["x2"], 0.0)
ClMP.setcurlb!(form, vars["x3"], 0.0)
output = ClA.run!(ClA.SolveLpForm(get_dual_sol = true), env, form, ClA.OptimizationState(form))
primal_sol = ClA.get_best_lp_primal_sol(output)
dual_sol = ClA.get_best_lp_dual_sol(output)
@test ClMP.getvalue(primal_sol) == 16
@test ClMP.getvalue(dual_sol) == 16
@test ClMP.getcurrhs(form, c) == 2
@test primal_sol[ClMP.getid(vars["x1"])] == 1
@test primal_sol[ClMP.getid(vars["x2"])] == 2
@test primal_sol[ClMP.getid(vars["x3"])] ≈ 3 + 2/3
end
register!(integration_tests, "MOI - fixed_variables", test_fixed_variables) | Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 1749 | function test_getprimal_getdual_case1()
# Create the following formulation:
# min x1 + 2x2 + 3x3
# st. x1 + 2x2 + 3x3 >= 16
# x1 == 2
# x2 == 3
# x3 >= 3
# Variable x1 and x2 are MOI.NONBASIC but get_dual (MOIinterface) was ignoring them.
# As a result, the value of the dual solution was not correct.
env = CL.Env{ClMP.VarId}(CL.Params())
form = ClMP.create_formulation!(env, ClMP.DwMaster())
vars = Dict{String, ClMP.Variable}()
for i in 1:3
x = ClMP.setvar!(form, "x$i", ClMP.OriginalVar; cost = i, lb = i)
vars["x$i"] = x
end
members = Dict{ClMP.VarId,Float64}(
ClMP.getid(vars["x1"]) => 1,
ClMP.getid(vars["x2"]) => 2,
ClMP.getid(vars["x3"]) => 3
)
c = ClMP.setconstr!(form, "c", ClMP.OriginalConstr;
rhs = 16, sense = ClMP.Greater, members = members
)
ClMP.setcurlb!(form, vars["x1"], 2)
ClMP.setcurlb!(form, vars["x2"], 3)
ClMP.setcurub!(form, vars["x1"], 2)
ClMP.setcurub!(form, vars["x2"], 3)
ClMP.push_optimizer!(form, CL._optimizerbuilder(MOI._instantiate_and_check(GLPK.Optimizer)))
DynamicSparseArrays.closefillmode!(ClMP.getcoefmatrix(form))
@test ClMP.getcurlb(form, vars["x1"]) == ClMP.getcurub(form, vars["x1"]) == 2
@test ClMP.getcurlb(form, vars["x2"]) == ClMP.getcurub(form, vars["x2"]) == 3
output = ClA.run!(ClA.SolveLpForm(get_dual_sol = true), env, form, ClA.OptimizationState(form))
primal_sol = ClA.get_best_lp_primal_sol(output)
dual_sol = ClA.get_best_lp_dual_sol(output)
@test ClMP.getvalue(primal_sol) == 17
@test ClMP.getvalue(dual_sol) == 17
end
register!(integration_tests, "MOI - solvelpform", test_getprimal_getdual_case1) | Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 1582 | struct TestAttachCustomDataAlgorithm end
struct CustomVarData <: BD.AbstractCustomVarData
var_value::Int
end
struct CustomConstrData <: BD.AbstractCustomConstrData
constr_value::Int
end
function Coluna.Algorithm.run!(::TestAttachCustomDataAlgorithm, _, form, _)
vars = Dict{String, Coluna.MathProg.Variable}()
for (_, var) in Coluna.MathProg.getvars(form)
vars[getname(form, var)] = var
end
constrs = Dict{String, Coluna.MathProg.Constraint}()
for (_, constr) in Coluna.MathProg.getconstrs(form)
constrs[getname(form, constr)] = constr
end
@test Coluna.MathProg.getcustomdata(form, vars["x[1]"]).var_value == 1
@test Coluna.MathProg.getcustomdata(form, vars["x[2]"]).var_value == 2
@test Coluna.MathProg.getcustomdata(form, constrs["c"]).constr_value == 3
return Coluna.Algorithm.OptimizationState(form)
end
function attach_custom_data()
coluna = JuMP.optimizer_with_attributes(
Coluna.Optimizer,
"params" => CL.Params(
solver = TestAttachCustomDataAlgorithm()
),
"default_optimizer" => GLPK.Optimizer,
)
model = BlockModel(coluna)
@variable(model, x[1:2], Bin)
@constraint(model, c, x[1] + x[2] <= 1)
@objective(model, Max, 2x[1] + 3x[2])
customvars!(model, CustomVarData)
customconstrs!(model, CustomConstrData)
customdata!(x[1], CustomVarData(1))
customdata!(x[2], CustomVarData(2))
customdata!(c, CustomConstrData(3))
optimize!(model)
end
register!(integration_tests, "attach_custom_data", attach_custom_data) | Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 20335 | struct AuxiliaryConstrInfo
coeffs::Vector{Tuple{String,Float64}}
duty::ClMP.Duty
sense::CL.ConstrSense
rhs::Float64
end
function get_vars_info(form::CL.Formulation)
names = String[]
kinds = ClMP.VarKind[]
duties = ClMP.Duty{ClMP.Variable}[]
costs = Float64[]
bounds = Tuple{Float64,Float64}[]
for (varid, var) in CL.getvars(form)
push!(names, CL.getname(form, var))
push!(kinds, CL.getperenkind(form, var))
push!(duties, CL.getduty(varid))
push!(costs, CL.getperencost(form, var))
push!(bounds, (CL.getperenlb(form, var), CL.getperenub(form, var)))
end
return names, kinds, duties, costs, bounds
end
function get_constrs_info(form::CL.Formulation)
infos = AuxiliaryConstrInfo[]
coeff_matrix = CL.getcoefmatrix(form)
for (constrid, constr) in CL.getconstrs(form)
coeffs = Tuple{String,Float64}[]
for (varid, coeff) in @view coeff_matrix[constrid, :]
push!(coeffs, (CL.getname(form, varid), coeff))
end
duty = CL.getduty(constrid)
sense = CL.getperensense(form, constr)
rhs = CL.getperenrhs(form, constr)
push!(infos, AuxiliaryConstrInfo(coeffs, duty, sense, rhs))
end
return infos
end
function no_objective_function1()
s = """
SP
Min
- 2y1 + y2
S.t.
- 6.3y1 + 3y2 == 5.9
Continuous
pricing
y1, y2
bounds
y1 >= 1
1 <= y2
"""
@test_throws UndefObjectiveParserError reformfromstring(s)
end
register!(integration_tests, "parser", no_objective_function1)
function no_objective_function2()
s = """
Master
max
such that
x + y1 <= 50.3
SP
max
- 2y1 + y2
such that
- 6.3y1 + 3y2 == 5.9
Continuous
pure
x
representative
y1
pricing
y2
bounds
y1 >= 1
1 <= y2
"""
@test_throws UndefObjectiveParserError reformfromstring(s)
end
register!(integration_tests, "parser", no_objective_function2)
function no_sp_vars_in_master()
# no sp variable present in master
s = """
master
maximize
x + 5*y
st
2x - y <= 25
Bin
pure
x
Int
pure
y
bounds
y <= 10
"""
env, master, subproblems, constraints, _ = reformfromstring(s)
@test CL.getobjsense(master) == CL.MaxSense
names, kinds, duties, costs, bounds = get_vars_info(master)
@test names == ["y", "x"]
@test kinds == [ClMP.Integ, ClMP.Binary]
@test duties == [ClMP.MasterPureVar, ClMP.MasterPureVar]
@test costs == [5.0, 1.0]
@test bounds == [(-Inf, 10.0), (0.0, 1.0)]
@test isempty(subproblems)
end
register!(integration_tests, "parser", no_sp_vars_in_master)
function rep_var_in_master_but_no_sp()
# representative variable present in master but no subproblem
s = """
master
maximise
x + 5*y - w
such that
2x - y + w <= 25
Bin
pure
x
Int
pure
y
representative
w
bounds
y <= 10
"""
@test_throws UndefVarParserError reformfromstring(s)
end
register!(integration_tests, "parser", rep_var_in_master_but_no_sp)
function rep_var_not_in_obj()
# representative variable not present in OF
s = """
master
maximum
3*x
such that
x - y1 <= 25
dw_sp
maximum
6y2 - 2.0*y1
such that
y1 - y2 >= 25
cont
pure
x
pricing
y2
representative
y1
bounds
x >= 10
"""
@test_throws UndefVarParserError reformfromstring(s)
end
register!(integration_tests, "parser", rep_var_not_in_obj)
function master_var_not_in_obj()
# master variable not present in OF
s = """
master
min
3*x
such that
x + y >= 25
integers
pures
x, y
bounds
x, y >= 5
"""
@test_throws UndefVarParserError reformfromstring(s)
end
register!(integration_tests, "parser", master_var_not_in_obj)
function var_in_obj_with_no_duty_and_kind()
# variable in OF with no duty and kind defined
s = """
master
min
3*x + 7w
st
x + w == 25
int
pure
x
bounds
2 <= x, w <= 10
"""
@test_throws UndefVarParserError reformfromstring(s)
end
register!(integration_tests, "parser", var_in_obj_with_no_duty_and_kind)
function var_in_constr_with_no_duty_and_kind()
# variable in constraint with no duty and kind defined
s = """
master
minimise
3*x + 7w
such that
x + w - z == 25
int
pure
x, w
bounds
2 <= x, w <= 10
"""
@test_throws UndefVarParserError reformfromstring(s)
end
register!(integration_tests, "parser", var_in_constr_with_no_duty_and_kind)
function subprob_var_with_no_duty_and_kind()
# subproblem variable with no duty and kind defined
s = """
master
min
3*x - w
such that
x + w == 25
dw_sp
min
y
such that
y >= 25
integer
pure
x, w
bound
2 <= x, w <= 10
"""
@test_throws UndefVarParserError reformfromstring(s)
end
register!(integration_tests, "parser", subprob_var_with_no_duty_and_kind)
function missing_duty_and_kind_section()
# no duty/kind section defined
s = """
master
minimum
3*x - y
such that
x + y == 25
bounds
2 <= x, y <= 10
"""
@test_throws UndefVarParserError reformfromstring(s)
end
register!(integration_tests, "parser", missing_duty_and_kind_section)
function minimize_no_bounds()
s = """
Master
Minimize
2*x + 4.5*y1
Subject To
x + y1 <= 10.5
SP
Min
y1 + y2
St
- 6.3y1 + 3y2 == 5.9
Continuous
pure
x
representative
y1
pricing
y2
"""
env, master, subproblems, constraints, _ = reformfromstring(s)
@test CL.getobjsense(master) == CL.MinSense
names, kinds, duties, costs, bounds = get_vars_info(master)
@test names == ["x", "y1"]
@test kinds == [ClMP.Continuous, ClMP.Continuous]
@test duties == [ClMP.MasterPureVar, ClMP.MasterRepPricingVar]
@test costs == [2.0, 4.5]
@test bounds == [(-Inf, Inf), (-Inf, Inf)]
constrs = get_constrs_info(master)
c1 = constrs[1] # x + y1 <= 10.5
@test c1.coeffs == [("y1", 1.0), ("x", 1.0)]
@test c1.duty == ClMP.MasterMixedConstr
@test c1.sense == CL.Less
@test c1.rhs == 10.5
sp1 = subproblems[1]
@test CL.getobjsense(sp1) == CL.MinSense
names, kinds, duties, costs, bounds = get_vars_info(sp1)
@test names == ["y2", "y1"]
@test kinds == [ClMP.Continuous, ClMP.Continuous]
@test duties == [ClMP.DwSpPricingVar, ClMP.DwSpPricingVar]
@test costs == [1.0, 1.0]
@test bounds == [(-Inf, Inf), (-Inf, Inf)]
constrs = get_constrs_info(sp1)
c1 = constrs[1] # - 6.3y1 + 3y2 == 5.9
@test c1.coeffs == [("y1", -6.3), ("y2", 3.0)]
@test c1.duty == ClMP.DwSpPureConstr
@test c1.sense == CL.Equal
@test c1.rhs == 5.9
end
register!(integration_tests, "parser", minimize_no_bounds)
function minimize_test1()
s = """
master
min
2*x - 5w + y1 + y2
s.t.
x - 3y1 + 8*y2 >= 20
x + w <= 9
dw_sp
min
4.5*y1 - 3*z_1 + z_2
s.t.
6.3y1 + z_1 == 5
z_1 - 5*z_2 >= 4.2
dw_sp
min
9*y2 + 2.2*z_3
s.t.
2*z_3 - 3y2 >= 3.8
integers
pures
x, w
binaries
representatives
y1, y2
continuous
pricing
z_1, z_2, z_3
global_bounds
0 <= y1 <= 1
bounds
20 >= x >= 0
0 <= y1 <= 1
z_1, z_2 >= 6.2
"""
env, master, subproblems, constraints, _ = reformfromstring(s)
@test CL.getobjsense(master) == CL.MinSense
names, kinds, duties, costs, bounds = get_vars_info(master)
@test names == ["w", "x", "y2", "y1"]
@test kinds == [ClMP.Integ, ClMP.Integ, ClMP.Integ, ClMP.Integ]
@test duties == [ClMP.MasterPureVar, ClMP.MasterPureVar, ClMP.MasterRepPricingVar, ClMP.MasterRepPricingVar]
@test costs == [-5.0, 2.0, 1.0, 1.0]
@test bounds == [(-Inf, Inf), (0.0, 20.0), (-Inf, Inf), (0.0, 1.0)]
constrs = get_constrs_info(master)
c1 = constrs[1] # x + w <= 9
@test c1.coeffs == [("w", 1.0), ("x", 1.0)]
@test c1.duty == ClMP.MasterPureConstr
@test c1.sense == CL.Less
@test c1.rhs == 9.0
c2 = constrs[2] # x - 3y1 + 8*y2 >= 20
@test c2.coeffs == [("y2", 8.0), ("y1", -3.0), ("x", 1.0)]
@test c2.duty == ClMP.MasterMixedConstr
@test c2.sense == CL.Greater
@test c2.rhs == 20.0
sp1 = subproblems[1]
@test CL.getobjsense(sp1) == CL.MinSense
names, kinds, duties, costs, bounds = get_vars_info(sp1)
@test names == ["y2", "z_3"]
@test kinds == [ClMP.Binary, ClMP.Continuous]
@test duties == [ClMP.DwSpPricingVar, ClMP.DwSpPricingVar]
@test costs == [9.0, 2.2]
@test bounds == [(0.0, 1.0), (-Inf, Inf)]
constrs = get_constrs_info(sp1)
c1 = constrs[1] # 2*z_3 - 3*y2 >= 3.8
@test c1.coeffs == [("z_3", 2.0), ("y2", -3.0)]
@test c1.duty == ClMP.DwSpPureConstr
@test c1.sense == CL.Greater
@test c1.rhs == 3.8
sp2 = subproblems[2]
@test CL.getobjsense(sp2) == CL.MinSense
names, kinds, duties, costs, bounds = get_vars_info(sp2)
@test names == ["z_1", "z_2", "y1"]
@test kinds == [ClMP.Continuous, ClMP.Continuous, ClMP.Binary]
@test duties == [ClMP.DwSpPricingVar, ClMP.DwSpPricingVar, ClMP.DwSpPricingVar]
@test costs == [-3.0, 1.0, 4.5]
@test bounds == [(6.2, Inf), (6.2, Inf), (0.0, 1.0)]
constrs = get_constrs_info(sp2)
c1 = constrs[1] # 6.3y1 + z_1 == 5
@test c1.coeffs == [("y1", 6.3), ("z_1", 1.0)]
@test c1.duty == ClMP.DwSpPureConstr
@test c1.sense == CL.Equal
@test c1.rhs == 5.0
c2 = constrs[2] # z_1 - 5*z_2 >= 4.2
@test c2.coeffs == [("z_2", -5.0), ("z_1", 1.0)]
@test c2.duty == ClMP.DwSpPureConstr
@test c2.sense == CL.Greater
@test c2.rhs == 4.2
end
register!(integration_tests, "parser", minimize_test1)
function minimize_test2()
s = """
master
min
3*y + 2*z
s.t.
y + z >= 1
continuous
pure
y
artificial
z
"""
env, master, subproblems, constraints, _ = reformfromstring(s)
names, kinds, duties, costs, bounds = get_vars_info(master)
@test names == ["y", "z"]
@test kinds == [ClMP.Continuous, ClMP.Continuous]
@test duties == [ClMP.MasterPureVar, ClMP.MasterArtVar]
@test costs == [3.0, 2.0]
@test bounds == [(-Inf, Inf), (-Inf, Inf)]
end
register!(integration_tests, "parser", minimize_test2)
function minimize_test3()
# Original formulation is the following:
# min
# x1 + 4x2 + 2y1 + 3y2
# s.t.
# x1 + x2 >= 0
# - x1 + 3x2 - y1 + 2y2 >= 2
# x1 + 3x2 + y1 + y2 >= 3
# y1 + y2 >= 0
s = """
master
min
x1 + 4x2 + z
s.t.
x1 + x2 >= 0
benders_sp
min
0x1 + 0x2 + 2y1 + 3y2 + z
s.t.
-x1 + 3x2 + 2y1 + 3y2 >= 2 {BendTechConstr}
x1 + 3x2 + y1 + y2 >= 3 {BendTechConstr}
y1 + y2 >= 0
integers
first_stage
x1, x2
continuous
second_stage_cost
z
second_stage
y1, y2
bounds
-Inf <= z <= Inf
x1 >= 0
x2 >= 0
y1 >= 0
y2 >= 0
a11 >= 0
a12 >= 0
a21 >= 0
a22 >= 0
"""
env, master, subproblems, constraints, _ = reformfromstring(s)
@test CL.getobjsense(master) == CL.MinSense
_s(n, v) = map(t -> t[2], sort!(collect(zip(n,v)); by = t -> t[1]))
_s2(t) = sort!(t, by = t -> t[1])
names, kinds, duties, costs, bounds = get_vars_info(master)
@test sort(names) == ["x1", "x2", "z"]
@test _s(names, kinds) == [ClMP.Integ, ClMP.Integ, ClMP.Continuous]
@test _s(names, duties) == [ClMP.MasterPureVar, ClMP.MasterPureVar, ClMP.MasterBendSecondStageCostVar]
@test _s(names, costs) == [1.0, 4.0, 1.0]
@test _s(names, bounds) == [(0, Inf), (0.0, Inf), (-Inf, Inf)]
constrs = get_constrs_info(master)
c1 = constrs[1] # x1 + x2 >= 0
@test c1.coeffs == [("x1", 1.0), ("x2", 1.0)]
@test c1.duty == ClMP.MasterPureConstr
@test c1.sense == CL.Greater
@test c1.rhs == 0.0
sp1 = subproblems[1]
@test CL.getobjsense(sp1) == CL.MinSense
names, kinds, duties, costs, bounds = get_vars_info(sp1)
@test sort(names) == ["x1", "x2", "y1", "y2", "z"]
@test _s(names, kinds) == [ClMP.Integ, ClMP.Integ, ClMP.Continuous, ClMP.Continuous, ClMP.Continuous]
@test _s(names, duties) == [ClMP.BendSpFirstStageRepVar, ClMP.BendSpFirstStageRepVar, ClMP.BendSpSepVar, ClMP.BendSpSepVar, ClMP.BendSpCostRepVar]
@test _s(names, costs) == [1.0, 4.0, 2.0, 3.0, 1.0]
@test _s(names, bounds) == [(0.0, Inf), (0.0, Inf), (0.0, Inf), (0.0, Inf), (-Inf, Inf)]
@test !isnothing(sp1.duty_data.second_stage_cost_var)
constrs = get_constrs_info(sp1)
c1 = constrs[1] # x1 + 3x2 + y1 + y2 >= 3
@test _s2(c1.coeffs) == _s2([("x1", 1.0), ("y1", 1.0), ("x2", 3.0), ("y2", 1.0)])
@test c1.duty == ClMP.BendSpTechnologicalConstr
@test c1.sense == CL.Greater
@test c1.rhs == 3.0
c2 = constrs[2] # y1 + y2 >= 0
@test c2.coeffs == [("y1", 1.0), ("y2", 1.0)]
@test c2.duty == ClMP.BendSpPureConstr
@test c2.sense == CL.Greater
@test c2.rhs == 0.0
c3 = constrs[3] # -x1 + 3x2 + 2y1 + 3y2 >= 2
@test _s2(c3.coeffs) == _s2([("x1", -1.0), ("y1", 2.0), ("x2", 3.0), ("y2", 3.0)])
@test c3.duty == ClMP.BendSpTechnologicalConstr
@test c3.sense == CL.Greater
@test c3.rhs == 2.0
end
register!(integration_tests, "parser", minimize_test3)
function columns_test()
form = """
master
min
100.0 local_art_of_cov_5 + 100.0 local_art_of_cov_4 + 100.0 local_art_of_cov_6 + 100.0 local_art_of_cov_7 + 100.0 local_art_of_cov_2 + 100.0 local_art_of_cov_3 + 100.0 local_art_of_cov_1 + 100.0 local_art_of_sp_lb_5 + 100.0 local_art_of_sp_ub_5 + 100.0 local_art_of_sp_lb_4 + 100.0 local_art_of_sp_ub_4 + 1000.0 global_pos_art_var + 1000.0 global_neg_art_var + 51.0 MC_30 + 38.0 MC_31 + 31.0 MC_32 + 35.0 MC_33 + 48.0 MC_34 + 13.0 MC_35 + 53.0 MC_36 + 28.0 MC_37 + 8.0 x_11 + 5.0 x_12 + 11.0 x_13 + 21.0 x_14 + 6.0 x_15 + 5.0 x_16 + 19.0 x_17 + 1.0 x_21 + 12.0 x_22 + 11.0 x_23 + 12.0 x_24 + 14.0 x_25 + 8.0 x_26 + 5.0 x_27 + 0.0 PricingSetupVar_sp_5 + 0.0 PricingSetupVar_sp_4
s.t.
1.0 x_11 + 1.0 x_21 + 1.0 local_art_of_cov_1 + 1.0 global_pos_art_var + 1.0 MC_31 + 1.0 MC_34 + 1.0 MC_35 + 1.0 MC_36 >= 1.0
1.0 x_12 + 1.0 x_22 + 1.0 local_art_of_cov_2 + 1.0 global_pos_art_var + 1.0 MC_31 + 1.0 MC_32 + 1.0 MC_33 >= 1.0
1.0 x_13 + 1.0 x_23 + 1.0 local_art_of_cov_3 + 1.0 global_pos_art_var + 1.0 MC_31 + 1.0 MC_33 + 1.0 MC_37 >= 1.0
1.0 x_14 + 1.0 x_24 + 1.0 local_art_of_cov_4 + 1.0 global_pos_art_var + 1.0 MC_30 + 1.0 MC_32 + 1.0 MC_33 + 1.0 MC_34 + 1.0 MC_35 + 1.0 MC_36 + 1.0 MC_37 >= 1.0
1.0 x_15 + 1.0 x_25 + 1.0 local_art_of_cov_5 + 1.0 global_pos_art_var + 1.0 MC_30 + 1.0 MC_31 >= 1.0
1.0 x_16 + 1.0 x_26 + 1.0 local_art_of_cov_6 + 1.0 global_pos_art_var + 1.0 MC_30 + 1.0 MC_32 + 1.0 MC_36 >= 1.0
1.0 x_17 + 1.0 x_27 + 1.0 local_art_of_cov_7 + 1.0 global_pos_art_var + 1.0 MC_30 + 1.0 MC_34 + 1.0 MC_36 + 1.0 MC_37 >= 1.0
1.0 PricingSetupVar_sp_5 + 1.0 local_art_of_sp_lb_5 + 1.0 MC_30 + 1.0 MC_32 + 1.0 MC_34 + 1.0 MC_36 >= 0.0 {MasterConvexityConstr}
1.0 PricingSetupVar_sp_5 - 1.0 local_art_of_sp_ub_5 + 1.0 MC_30 + 1.0 MC_32 + 1.0 MC_34 + 1.0 MC_36 <= 1.0 {MasterConvexityConstr}
1.0 PricingSetupVar_sp_4 + 1.0 local_art_of_sp_lb_4 + 1.0 MC_31 + 1.0 MC_33 + 1.0 MC_35 + 1.0 MC_37 >= 0.0 {MasterConvexityConstr}
1.0 PricingSetupVar_sp_4 - 1.0 local_art_of_sp_ub_4 + 1.0 MC_31 + 1.0 MC_33 + 1.0 MC_35 + 1.0 MC_37 <= 1.0 {MasterConvexityConstr}
dw_sp
min
x_11 + x_12 + x_13 + x_14 + x_15 + x_16 + x_17 + 0.0 PricingSetupVar_sp_5
s.t.
2.0 x_11 + 3.0 x_12 + 3.0 x_13 + 1.0 x_14 + 2.0 x_15 + 1.0 x_16 + 1.0 x_17 <= 5.0
origin
MC_30, MC_32, MC_34, MC_36
dw_sp
min
x_21 + x_22 + x_23 + x_24 + x_25 + x_26 + x_27 + 0.0 PricingSetupVar_sp_4
s.t.
5.0 x_21 + 1.0 x_22 + 1.0 x_23 + 3.0 x_24 + 1.0 x_25 + 5.0 x_26 + 4.0 x_27 <= 8.0
origin
MC_31, MC_33, MC_35, MC_37
continuous
columns
MC_30, MC_31, MC_32, MC_33, MC_34, MC_35, MC_36, MC_37
artificial
local_art_of_cov_5, local_art_of_cov_4, local_art_of_cov_6, local_art_of_cov_7, local_art_of_cov_2, local_art_of_cov_3, local_art_of_cov_1, local_art_of_sp_lb_5, local_art_of_sp_ub_5, local_art_of_sp_lb_4, local_art_of_sp_ub_4, global_pos_art_var, global_neg_art_var
integer
pricing_setup
PricingSetupVar_sp_4, PricingSetupVar_sp_5
binary
representatives
x_11, x_21, x_12, x_22, x_13, x_23, x_14, x_24, x_15, x_25, x_16, x_26, x_17, x_27
bounds
0.0 <= x_11 <= 1.0
0.0 <= x_21 <= 1.0
0.0 <= x_12 <= 1.0
0.0 <= x_22 <= 1.0
0.0 <= x_13 <= 1.0
0.0 <= x_23 <= 1.0
0.0 <= x_14 <= 1.0
0.0 <= x_24 <= 1.0
0.0 <= x_15 <= 1.0
0.0 <= x_25 <= 1.0
0.0 <= x_16 <= 1.0
0.0 <= x_26 <= 1.0
0.0 <= x_17 <= 1.0
0.0 <= x_27 <= 1.0
1.0 <= PricingSetupVar_sp_4 <= 1.0
1.0 <= PricingSetupVar_sp_5 <= 1.0
local_art_of_cov_5 >= 0.0
local_art_of_cov_4 >= 0.0
local_art_of_cov_6 >= 0.0
local_art_of_cov_7 >= 0.0
local_art_of_cov_2 >= 0.0
local_art_of_cov_3 >= 0.0
local_art_of_cov_1 >= 0.0
local_art_of_sp_lb_5 >= 0.0
local_art_of_sp_ub_5 >= 0.0
local_art_of_sp_lb_4 >= 0.0
local_art_of_sp_ub_4 >= 0.0
global_pos_art_var >= 0.0
global_neg_art_var >= 0.0
"""
env, master, sps, constrs, reform = Coluna.Tests.Parser.reformfromstring(form)
@show master
varids = Dict(
Coluna.MathProg.getname(master, varid) => varid for (varid, var) in Coluna.MathProg.getvars(master)
)
@test varids["MC_30"].origin_form_uid == varids["PricingSetupVar_sp_5"].assigned_form_uid
@test varids["MC_31"].origin_form_uid == varids["PricingSetupVar_sp_4"].assigned_form_uid
@test varids["MC_32"].origin_form_uid == varids["PricingSetupVar_sp_5"].assigned_form_uid
@test varids["MC_33"].origin_form_uid == varids["PricingSetupVar_sp_4"].assigned_form_uid
@test varids["MC_34"].origin_form_uid == varids["PricingSetupVar_sp_5"].assigned_form_uid
@test varids["MC_35"].origin_form_uid == varids["PricingSetupVar_sp_4"].assigned_form_uid
@test varids["MC_36"].origin_form_uid == varids["PricingSetupVar_sp_5"].assigned_form_uid
@test varids["MC_37"].origin_form_uid == varids["PricingSetupVar_sp_4"].assigned_form_uid
return
end
register!(integration_tests, "parser", columns_test) | Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 7896 |
# Formulation with a given nb of variables. No constraint & no cost.
function build_formulation(nb_variables)
env = CL.Env{ClMP.VarId}(CL.Params())
form = ClMP.create_formulation!(env, ClMP.DwSp(nothing, nothing, nothing, ClMP.Continuous))
vars = Dict(
"x$i" => ClMP.setvar!(form, "x$i", ClMP.DwSpPricingVar) for i in 1:nb_variables
)
fake_model = JuMP.Model()
@variable(fake_model, x[i in 1:nb_variables])
for name in ["x$i" for i in 1:nb_variables]
CleverDicts.add_item(env.varids, ClMP.getid(vars[name]))
end
return env, form, vars, x
end
# Specs about pricing callbacks (we consider the case of a minimization problem):
# - Optimal primal <-> optimal dual (case 1)
# - Unbounded primal <-> infeasible dual (case 2)
# - Infeasible primal <-> unbounded dual (case 3)
# - Infeasible primal <-> infeasible dual (case 4)
# - heuristic solution (case 5)
function cb_returns_a_dual_bound()
env, form, vars, x = build_formulation(5)
function callback(cbdata)
CL._submit_dual_bound(cbdata, 0.5)
end
push!(form.optimizers, ClMP.UserOptimizer(callback))
state = ClA.run!(ClA.UserOptimize(), env, form, ClA.OptimizationState(form))
@test ClA.get_ip_primal_bound(state) == Inf
@test ClA.get_ip_dual_bound(state) == 0.5
@test ClA.getterminationstatus(state) == CL.OTHER_LIMIT
@test isnothing(ClA.get_best_ip_primal_sol(state))
@test isnothing(ClA.get_best_lp_primal_sol(state))
end
register!(integration_tests, "pricing_callback", cb_returns_a_dual_bound)
function cb_returns_an_optimal_solution() # case 1
env, form, vars, x = build_formulation(5)
function callback(cbdata)
cost = -15.0
variables = [x[1].index, x[3].index]
values = [1.0, 1.0]
custom_data = nothing
CL._submit_pricing_solution(env, cbdata, cost, variables, values, custom_data)
CL._submit_dual_bound(cbdata, cost)
end
push!(form.optimizers, ClMP.UserOptimizer(callback))
expected_primalsol = ClMP.PrimalSolution(
form,
[ClMP.getid(vars["x1"]), ClMP.getid(vars["x3"])],
[1.0, 1.0],
-15.0,
CL.FEASIBLE_SOL
)
state = ClA.run!(ClA.UserOptimize(), env, form, ClA.OptimizationState(form))
@test ClA.get_ip_primal_bound(state) == -15.0
@test ClA.get_ip_dual_bound(state) == -15.0
@test ClA.getterminationstatus(state) == ClB.OPTIMAL
@test ClA.get_best_ip_primal_sol(state) == expected_primalsol
@test isnothing(ClA.get_best_lp_primal_sol(state))
end
register!(integration_tests, "pricing_callback", cb_returns_an_optimal_solution)
function cb_returns_heuristic_solution() # case 5
env, form, vars, x = build_formulation(5)
function callback(cbdata)
cost = -15.0
variables = [x[1].index, x[3].index]
values = [1.0, 1.0]
custom_data = nothing
CL._submit_pricing_solution(env, cbdata, cost, variables, values, custom_data)
CL._submit_dual_bound(cbdata, -20)
end
push!(form.optimizers, ClMP.UserOptimizer(callback))
expected_primalsol = ClMP.PrimalSolution(
form,
[ClMP.getid(vars["x1"]), ClMP.getid(vars["x3"])],
[1.0, 1.0],
-15.0,
CL.FEASIBLE_SOL
)
state = ClA.run!(ClA.UserOptimize(), env, form, ClA.OptimizationState(form))
@test ClA.get_ip_primal_bound(state) == -15.0
@test ClA.get_ip_dual_bound(state) == -20.0
@test ClA.getterminationstatus(state) == ClB.OTHER_LIMIT
@test ClA.get_best_ip_primal_sol(state) == expected_primalsol
@test isnothing(ClA.get_best_lp_primal_sol(state))
end
register!(integration_tests, "pricing_callback", cb_returns_heuristic_solution)
function cb_returns_heuristic_solution_2() # case 5
env, form, vars, x = build_formulation(5)
function callback(cbdata)
cost = -15.0
variables = [x[1].index, x[3].index]
values = [1.0, 1.0]
custom_data = nothing
CL._submit_pricing_solution(env, cbdata, cost, variables, values, custom_data)
CL._submit_dual_bound(cbdata, -Inf)
end
push!(form.optimizers, ClMP.UserOptimizer(callback))
state = ClA.run!(ClA.UserOptimize(), env, form, ClA.OptimizationState(form))
@test ClA.get_ip_primal_bound(state) == -15.0
@test ClA.get_ip_dual_bound(state) == -Inf
@test ClA.getterminationstatus(state) == ClB.OTHER_LIMIT
@test !isnothing(ClA.get_best_ip_primal_sol(state))
@test isnothing(ClA.get_best_lp_primal_sol(state))
end
register!(integration_tests, "pricing_callback", cb_returns_heuristic_solution_2)
# cb returns infinite dual bound (primal infeasible)
function cb_returns_infinite_dual_bound() # case 4
env, form, vars, x = build_formulation(5)
function callback(cbdata)
CL._submit_dual_bound(cbdata, Inf)
end
push!(form.optimizers, ClMP.UserOptimizer(callback))
state = ClA.run!(ClA.UserOptimize(), env, form, ClA.OptimizationState(form))
@test ClA.get_ip_primal_bound(state) === nothing
@test ClA.get_ip_dual_bound(state) == Inf
@test ClA.getterminationstatus(state) == ClB.INFEASIBLE
@test isnothing(ClA.get_best_ip_primal_sol(state))
@test isnothing(ClA.get_best_lp_primal_sol(state))
end
register!(integration_tests, "pricing_callback", cb_returns_infinite_dual_bound)
function cb_returns_unbounded_primal() # case 2
env, form, vars, x = build_formulation(5)
function callback(cbdata)
cost = -Inf
variables = Coluna.MathProg.VarId[]
values = Float64[]
custom_data = nothing
CL._submit_pricing_solution(env, cbdata, cost, variables, values, custom_data)
CL._submit_dual_bound(cbdata, nothing)
end
push!(form.optimizers, ClMP.UserOptimizer(callback))
state = ClA.run!(ClA.UserOptimize(), env, form, ClA.OptimizationState(form))
@test ClA.get_ip_primal_bound(state) == -Inf
@test ClA.get_ip_dual_bound(state) === nothing
@test ClA.getterminationstatus(state) == ClB.UNBOUNDED
@test isnothing(ClA.get_best_lp_primal_sol(state))
end
register!(integration_tests, "pricing_callback", cb_returns_unbounded_primal)
function cb_returns_incorrect_dual_bound()
env, form, vars, x = build_formulation(5)
function callback(cbdata)
cost = -15.0
variables = [x[1].index, x[3].index]
values = [1.0, 1.0]
custom_data = nothing
CL._submit_pricing_solution(env, cbdata, cost, variables, values, custom_data)
CL._submit_dual_bound(cbdata, -10) # dual bound > primal bound !!!
end
push!(form.optimizers, ClMP.UserOptimizer(callback))
@test_throws ClA.IncorrectPricingDualBound ClA.run!(ClA.UserOptimize(), env, form, ClA.OptimizationState(form))
end
register!(integration_tests, "pricing_callback", cb_returns_incorrect_dual_bound)
function cb_returns_solution_but_no_dual_bound()
env, form, vars, x = build_formulation(5)
function callback(cbdata)
cost = -15.0
variables = [x[1].index, x[3].index]
values = [1.0, 1.0]
custom_data = nothing
CL._submit_pricing_solution(env, cbdata, cost, variables, values, custom_data)
end
push!(form.optimizers, ClMP.UserOptimizer(callback))
@test_throws ClA.MissingPricingDualBound ClA.run!(ClA.UserOptimize(), env, form, ClA.OptimizationState(form))
end
register!(integration_tests, "pricing_callback", cb_returns_solution_but_no_dual_bound)
function cb_set_dual_bound_twice()
env, form, vars, x = build_formulation(5)
function callback(cbdata)
CL._submit_dual_bound(cbdata, 1.0)
CL._submit_dual_bound(cbdata, 2.0)
end
push!(form.optimizers, ClMP.UserOptimizer(callback))
@test_throws ClA.MultiplePricingDualBounds ClA.run!(ClA.UserOptimize(), env, form, ClA.OptimizationState(form))
end
register!(integration_tests, "pricing_callback", cb_set_dual_bound_twice) | Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 3188 | # Test retrieval of variable bounds from pricing solver.
# We optimize the formulation with a branch-and-price and set the node limit to 2.
# We know the branching constraint (deterministic behavior) applied at the second node (x[1, 1] >= 1)
# We retrieve the current bounds of x[1, 1] in the pricing callback and we check that the last lower bound retrieved (so in the second node) is 1.
# Test breaks because branching constraints are not updated to variable bounds yet.
@testset "Old - bound_callback_tests" begin
data = ClD.GeneralizedAssignment.data("play2.txt")
coluna = JuMP.optimizer_with_attributes(
CL.Optimizer,
"default_optimizer" => GLPK.Optimizer,
"params" => CL.Params(solver = ClA.BranchCutAndPriceAlgorithm(maxnumnodes = 2))
)
model, x, dec = ClD.GeneralizedAssignment.model_without_knp_constraints(data, coluna)
# Subproblem models are created once and for all
# One model for each machine
# Subproblem models are created once and for all
# One model for each machine
sp_models = Dict{Int, Any}()
for m in data.machines
sp = JuMP.Model(GLPK.Optimizer)
@variable(sp, y[j in data.jobs], Bin)
@variable(sp, lb_y[j in data.jobs] >= 0)
@variable(sp, ub_y[j in data.jobs] >= 0)
@constraint(sp, knp, sum(data.weight[j,m]*y[j] for j in data.jobs) <= data.capacity[m])
@constraint(sp, lbs[j in data.jobs], y[j] + lb_y[j] >= 0)
@constraint(sp, ubs[j in data.jobs], y[j] - ub_y[j] <= 0)
sp_models[m] = (sp, y, lb_y, ub_y)
end
lb = 0.0
ub = 1.0
function my_pricing_callback(cbdata)
machine_id = BD.callback_spid(cbdata, model)
sp, y, lb_y, ub_y = sp_models[machine_id]
red_costs = [BD.callback_reduced_cost(cbdata, x[machine_id, j]) for j in data.jobs]
# Update the model
## Bounds on subproblem variables
for j in data.jobs
JuMP.fix(lb_y[j], BD.callback_lb(cbdata, x[machine_id, j]), force = true)
JuMP.fix(ub_y[j], BD.callback_ub(cbdata, x[machine_id, j]), force = true)
end
if machine_id == 1
lb = BD.callback_lb(cbdata, x[1, 1])
ub = BD.callback_ub(cbdata, x[1, 1])
end
## Objective function
@objective(sp, Min, sum(red_costs[j]*y[j] for j in data.jobs))
JuMP.optimize!(sp)
# Retrieve the solution
solcost = JuMP.objective_value(sp)
solvars = JuMP.VariableRef[]
solvarvals = Float64[]
for j in data.jobs
val = JuMP.value(y[j])
if val ≈ 1
push!(solvars, x[machine_id, j])
push!(solvarvals, 1.0)
end
end
# Submit the solution
MOI.submit(
model, BD.PricingSolution(cbdata), solcost, solvars, solvarvals
)
MOI.submit(model, BD.PricingDualBound(cbdata), solcost)
return
end
master = BD.getmaster(dec)
subproblems = BD.getsubproblems(dec)
BD.specify!.(subproblems, lower_multiplicity = 0, solver = my_pricing_callback)
JuMP.optimize!(model)
@test_broken lb == 1.0
@test ub == 1.0
end
| Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 1025 | @testset "Old - optimizer with attributes" begin
data = ClD.GeneralizedAssignment.data("play2.txt")
println(JuMP.optimizer_with_attributes(GLPK.Optimizer))
println(GLPK.Optimizer)
coluna = JuMP.optimizer_with_attributes(
Coluna.Optimizer,
"params" => CL.Params(solver = ClA.BranchCutAndPriceAlgorithm(
branchingtreefile = "playgap.dot"
)),
"default_optimizer" => JuMP.optimizer_with_attributes(GLPK.Optimizer, "tm_lim" => 60 * 1_100, "msg_lev" => GLPK.GLP_MSG_OFF)
)
println(coluna)
model, x, dec = ClD.GeneralizedAssignment.model(data, coluna)
BD.objectiveprimalbound!(model, 100)
BD.objectivedualbound!(model, 0)
JuMP.optimize!(model)
@test JuMP.objective_value(model) ≈ 75.0
@test JuMP.termination_status(model) == MOI.OPTIMAL
@test ClD.GeneralizedAssignment.print_and_check_sol(data, model, x)
@test MOI.get(model, MOI.NumberOfVariables()) == length(x)
@test MOI.get(model, MOI.SolverName()) == "Coluna"
end | Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 3644 | # @testset "Old - GAP with ad-hoc pricing callback and stages" begin
# data = ClD.GeneralizedAssignment.data("play2.txt")
# coluna = JuMP.optimizer_with_attributes(
# CL.Optimizer,
# "default_optimizer" => GLPK.Optimizer,
# "params" => CL.Params(
# solver = ClA.BranchCutAndPriceAlgorithm(
# colgen_stages_pricing_solvers = [2, 2]
# )
# )
# )
# model, x, dec = ClD.GeneralizedAssignment.model_without_knp_constraints(data, coluna)
# # Subproblem models are created once and for all
# # One model for each machine
# # Subproblem models are created once and for all
# # One model for each machine
# sp_models = Dict{Int, Any}()
# for m in data.machines
# sp = JuMP.Model(GLPK.Optimizer)
# @variable(sp, y[j in data.jobs], Bin)
# @variable(sp, lb_y[j in data.jobs] >= 0)
# @variable(sp, ub_y[j in data.jobs] >= 0)
# @variable(sp, max_card >= 0) # this sets the maximum solution cardinality for heuristic pricing
# @constraint(sp, card, sum(y[j] for j in data.jobs) <= max_card)
# @constraint(sp, knp, sum(data.weight[j,m]*y[j] for j in data.jobs) <= data.capacity[m])
# @constraint(sp, lbs[j in data.jobs], y[j] + lb_y[j] >= 0)
# @constraint(sp, ubs[j in data.jobs], y[j] - ub_y[j] <= 0)
# sp_models[m] = (sp, y, lb_y, ub_y, max_card)
# end
# nb_exact_calls = 0
# function my_pricing_callback(cbdata)
# # (cbdata.stage == 2) && return
# machine_id = BD.callback_spid(cbdata, model)
# sp, y, lb_y, ub_y, max_card = sp_models[machine_id]
# red_costs = [BD.callback_reduced_cost(cbdata, x[machine_id, j]) for j in data.jobs]
# # Update the model
# ## Bounds on subproblem variables
# for j in data.jobs
# JuMP.fix(lb_y[j], BD.callback_lb(cbdata, x[machine_id, j]), force = true)
# JuMP.fix(ub_y[j], BD.callback_ub(cbdata, x[machine_id, j]), force = true)
# end
# JuMP.fix(max_card, (cbdata.stage == 1) ? length(data.jobs) : 3, force = true)
# nb_exact_calls += (cbdata.stage == 1) ? 1 : 0
# ## Objective function
# @objective(sp, Min, sum(red_costs[j]*y[j] for j in data.jobs))
# JuMP.optimize!(sp)
# # Retrieve the solution
# solcost = JuMP.objective_value(sp)
# solvars = JuMP.VariableRef[]
# solvarvals = Float64[]
# for j in data.jobs
# val = JuMP.value(y[j])
# if val ≈ 1
# push!(solvars, x[machine_id, j])
# push!(solvarvals, 1.0)
# end
# end
# # Submit the solution
# MOI.submit(
# model, BD.PricingSolution(cbdata), solcost, solvars, solvarvals
# )
# return
# end
# master = BD.getmaster(dec)
# subproblems = BD.getsubproblems(dec)
# BD.specify!.(subproblems, lower_multiplicity = 0, solver = [GLPK.Optimizer, my_pricing_callback])
# JuMP.optimize!(model)
# @test nb_exact_calls < 30 # WARNING: this test is necessary to properly test stage 2.
# # Disabling stage 2 (uncommenting line 48) generates 40 exact
# # calls, against 18 when it is enabled. These numbers may change
# # a little bit with versions due to numerical errors.
# @test JuMP.objective_value(model) ≈ 75.0
# @test JuMP.termination_status(model) == MOI.OPTIMAL
# @test ClD.GeneralizedAssignment.print_and_check_sol(data, model, x)
# end | Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 544 | # function show_functions_tests()
# data = ClD.GeneralizedAssignment.data("play2.txt")
# coluna = JuMP.optimizer_with_attributes(
# CL.Optimizer,
# "default_optimizer" => GLPK.Optimizer,
# "params" => CL.Params(solver = ClA.TreeSearchAlgorithm())
# )
# problem, x, dec = ClD.GeneralizedAssignment.model(data, coluna, true)
# @test occursin("A JuMP Model", repr(problem))
# JuMP.optimize!(problem)
# @test_nowarn Base.show(problem.moi_backend.inner.re_formulation.master.optimizers[1])
# end
| Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 1379 | @testset "Old - Disaggregated solution" begin
I = 1:3
@axis(BinsType, [1])
w = [2, 5, 7]
Q = 8
coluna = JuMP.optimizer_with_attributes(
Coluna.Optimizer,
"params" => Coluna.Params(solver = ClA.ColumnGeneration()),
"default_optimizer" => GLPK.Optimizer
)
model = BlockModel(coluna)
@variable(model, x[k in BinsType, i in I], Bin)
@variable(model, y[k in BinsType], Bin)
@constraint(model, sp[i in I], sum(x[k, i] for k in BinsType) == 1)
@constraint(model, ks[k in BinsType], sum(w[i] * x[k, i] for i in I) - y[k] * Q <= 0)
@objective(model, Min, sum(y[k] for k in BinsType))
@dantzig_wolfe_decomposition(model, dec, BinsType)
subproblems = BlockDecomposition.getsubproblems(dec)
specify!.(subproblems, lower_multiplicity = 0, upper_multiplicity = BD.length(I)) # we use at most 3 bins
JuMP.optimize!(model)
for k in BinsType
bins = BD.getsolutions(model, k)
for bin in bins
@test BD.value(bin) == 1.0 # value of the master column variable
@test BD.value(bin, x[k, 1]) == BD.value(bin, x[k, 2]) # x[1,1] and x[1,2] in the same bin
@test BD.value(bin, x[k, 1]) != BD.value(bin, x[k, 3]) # only x[1,3] in its bin
@test BD.value(bin, x[k, 2]) != BD.value(bin, x[k, 3]) # only x[1,3] in its bin
end
end
end
| Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 982 | # function subproblem_solvers_test()
# @testset "play gap with lazy cuts" begin
# data = ClD.GeneralizedAssignment.data("play2.txt")
# coluna = JuMP.optimizer_with_attributes(
# Coluna.Optimizer,
# "params" => CL.Params(solver = ClA.BranchCutAndPriceAlgorithm(max_nb_cut_rounds = 1000)),
# "default_optimizer" => GLPK.Optimizer
# )
# model, x, dec = ClD.GeneralizedAssignment.model(data, coluna)
# subproblems = getsubproblems(dec)
# specify!(subproblems[1], lower_multiplicity=0, solver=JuMP.optimizer_with_attributes(GLPK.Optimizer, "tm_lim" => 60 * 1_100, "msg_lev" => GLPK.GLP_MSG_OFF))
# specify!(subproblems[2], lower_multiplicity=0, solver=JuMP.optimizer_with_attributes(GLPK.Optimizer, "tm_lim" => 60 * 2_200))
# optimize!(model)
# @test JuMP.objective_value(model) ≈ 75.0
# @test JuMP.termination_status(model) == MOI.OPTIMAL
# end
# end | Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 524 | for dir in ["MustImplement", "ColunaBase", "MathProg", "ColGen", "Benders", "Branching", "Algorithm", "TreeSearch", "Presolve"]
dirpath = joinpath(@__DIR__, dir)
for filename in readdir(dirpath)
includet(joinpath(dirpath, filename))
end
end
# for dir in readdir(".")
# dirpath = joinpath(dir)
# !isdir(dirpath) && continue
# for filename in readdir(dirpath)
# println("include(joinpath(\"",dirpath,"\", \"", filename,"\"))")
# end
# end
run_unit_tests() = run_tests(unit_tests)
| Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 3040 | struct Algorithm1 <: Coluna.AlgoAPI.AbstractAlgorithm
a::Int
b::Int
end
ClA.check_parameter(::Algorithm1, ::Val{:a}, value, reform) = 0 <= value <= 1
ClA.check_parameter(::Algorithm1, ::Val{:b}, value, reform) = 1 <= value <= 2
struct Algorithm2 <: Coluna.AlgoAPI.AbstractAlgorithm
alg1::Algorithm1
c::String
end
ClA.get_child_algorithms(a::Algorithm2, reform::ClMP.Reformulation) = Dict("alg1" => (a.alg1, reform))
# We check that the parameters of the child algorithm is consistent with the expected value.
ClA.check_parameter(::Algorithm2, ::Val{:alg1}, value, reform) = value.a != -1
ClA.check_parameter(::Algorithm2, ::Val{:c}, value, reform) = length(value) == 4
struct Algorithm3 <: Coluna.AlgoAPI.AbstractAlgorithm
d::String
e::Int
end
ClA.check_parameter(::Algorithm3, ::Val{:d}, value, reform) = length(value) == 3
ClA.check_parameter(::Algorithm3, ::Val{:e}, value, reform) = 5 <= value <= 8
struct Algorithm4 <: Coluna.AlgoAPI.AbstractAlgorithm
alg2::Algorithm2
alg3::Algorithm3
end
ClA.get_child_algorithms(a::Algorithm4, reform::ClMP.Reformulation) = Dict(
"alg2" => (a.alg2, reform),
"alg3" => (a.alg3, reform)
)
ClA.check_parameter(::Algorithm4, ::Val{:alg2}, value, reform) = true
ClA.check_parameter(::Algorithm4, ::Val{:alg3}, value, reform) = true
function _check_parameters_reform()
env = Coluna.Env{Coluna.MathProg.VarId}(Coluna.Params())
origform = Coluna.MathProg.create_formulation!(env, MathProg.Original())
master = Coluna.MathProg.create_formulation!(env, MathProg.DwMaster())
dw_pricing_sps = Dict{ClMP.FormId, ClMP.Formulation{ClMP.DwSp}}()
bend_pricing_sps = Dict{ClMP.FormId, ClMP.Formulation{ClMP.BendersSp}}()
reform = ClMP.Reformulation(env, origform, master, dw_pricing_sps, bend_pricing_sps)
return reform
end
function check_parameters_1()
reform = _check_parameters_reform()
alg1 = Algorithm1(1, 2) # ok, ok
alg2 = Algorithm2(alg1, "3") # ok, not ok
alg3 = Algorithm3("4", 5) # not ok, ok
top_algo = Algorithm4(alg2, alg3)
inconsistencies = ClA.check_alg_parameters(top_algo, reform)
@test (:c, alg2, "3") ∈ inconsistencies
@test (:d, alg3, "4") ∈ inconsistencies
@test length(inconsistencies) == 2
end
register!(unit_tests, "Algorithm", check_parameters_1)
# we test with all checks returning false
function check_parameters_2()
reform = _check_parameters_reform()
alg1 = Algorithm1(-1, -3) # not ok, not ok
alg2 = Algorithm2(alg1, "N") # not ok, not ok
alg3 = Algorithm3("N", 4) # not ok, not ok
top_algo = Algorithm4(alg2, alg3)
inconsistencies = ClA.check_alg_parameters(top_algo, reform)
@test (:a, alg1, -1) ∈ inconsistencies
@test (:b, alg1, -3) ∈ inconsistencies
@test (:c, alg2, "N") ∈ inconsistencies
@test (:alg1, alg2, alg1) ∈ inconsistencies
@test (:d, alg3, "N") ∈ inconsistencies
@test (:e, alg3, 4) ∈ inconsistencies
@test length(inconsistencies) == 6
end
register!(unit_tests, "Algorithm", check_parameters_2) | Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 2217 | struct NodeAe1 <: Coluna.TreeSearch.AbstractNode
id::Int
depth::Int
parent::Union{Nothing, NodeAe1}
function NodeAe1(id::Int, parent::Union{Nothing, NodeAe1} = nothing)
depth = isnothing(parent) ? 0 : parent.depth + 1
return new(id, depth, parent)
end
end
mutable struct CustomSearchSpaceAe1 <: Coluna.TreeSearch.AbstractSearchSpace
nb_branches::Int
max_depth::Int
max_nb_of_nodes::Int
nb_nodes_generated::Int
visit_order::Vector{Int}
function CustomSearchSpaceAe1(nb_branches::Int, max_depth::Int, max_nb_of_nodes::Int)
return new(nb_branches, max_depth, max_nb_of_nodes, 0, [])
end
end
function Coluna.TreeSearch.new_root(space::CustomSearchSpaceAe1, input)
space.nb_nodes_generated += 1
return NodeAe1(1)
end
Coluna.TreeSearch.stop(sp::CustomSearchSpaceAe1, _) = false
struct CustomBestFirstSearch <: Coluna.TreeSearch.AbstractBestFirstSearch end
Coluna.TreeSearch.get_priority(::CustomBestFirstSearch, node::NodeAe1) = -node.id
function Coluna.TreeSearch.children(space::CustomSearchSpaceAe1, current, _)
children = NodeAe1[]
push!(space.visit_order, current.id)
if current.depth != space.max_depth &&
space.nb_nodes_generated + space.nb_branches <= space.max_nb_of_nodes
for _ in 1:space.nb_branches
space.nb_nodes_generated += 1
node_id = space.nb_nodes_generated
child = NodeAe1(node_id, current)
push!(children, child)
end
end
return children
end
Coluna.TreeSearch.tree_search_output(space::CustomSearchSpaceAe1) = space.visit_order
function test_dfs()
search_space = CustomSearchSpaceAe1(2, 3, 11)
visit_order = Coluna.TreeSearch.tree_search(Coluna.TreeSearch.DepthFirstStrategy(), search_space, nothing, nothing)
@test visit_order == [1, 3, 5, 7, 6, 4, 9, 8, 2, 11, 10]
return
end
register!(unit_tests, "explore", test_dfs)
function test_bfs()
search_space = CustomSearchSpaceAe1(2, 3, 11)
visit_order = Coluna.TreeSearch.tree_search(CustomBestFirstSearch(), search_space, nothing, nothing)
@test visit_order == [1, 3, 5, 7, 6, 4, 9, 8, 2, 11, 10]
end
register!(unit_tests, "explore", test_bfs)
| Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 14006 | function formulation_for_optimizationstate(sense = Coluna.MathProg.MinSense)
form = ClMP.create_formulation!(Env{ClMP.VarId}(Coluna.Params()), ClMP.Original(), obj_sense = sense)
var = ClMP.setvar!(form, "var1", ClMP.OriginalVar)
constr = ClMP.setconstr!(form, "constr1", ClMP.OriginalConstr)
return form, var, constr
end
function update_solution_with_min_objective()
form, var, constr = formulation_for_optimizationstate()
state = ClA.OptimizationState(
form, max_length_ip_primal_sols = 2.0,
max_length_lp_primal_sols = 2.0, max_length_lp_dual_sols = 2.0
)
primalsol = ClMP.PrimalSolution(form, [ClMP.getid(var)], [2.0], 2.0, ClB.UNKNOWN_FEASIBILITY)
dualsol = ClMP.DualSolution(form, [ClMP.getid(constr)], [1.0], ClMP.VarId[], Float64[], ClMP.ActiveBound[], 1.0, ClB.UNKNOWN_FEASIBILITY)
### ip primal
ClA.update_ip_primal_sol!(state, primalsol)
# check that `primalsol` is added to `state.ip_primal_sols`
@test length(ClA.get_ip_primal_sols(state)) == 1
@test ClA.get_ip_primal_sols(state)[1] == primalsol
# check that incumbent bound is updated
@test ClA.get_ip_primal_bound(state) == 2.0
ClA.update_ip_primal_sol!(state, ClMP.PrimalSolution(
form, [ClMP.getid(var)], [3.0], 3.0, ClB.UNKNOWN_FEASIBILITY
))
# check that solution worse than `primalsol` is NOT added to `state.ip_primal_sols`
@test length(ClA.get_ip_primal_sols(state)) == 1
@test ClA.get_ip_primal_sols(state)[1] == primalsol
###
### lp primal
ClA.update_lp_primal_sol!(state, primalsol)
# check that `primalsol` is added to `state.lp_primal_sols`
@test length(ClA.get_lp_primal_sols(state)) == 1
@test ClA.get_lp_primal_sols(state)[1] == primalsol
# check that incumbent bound is updated
@test ClA.get_lp_primal_bound(state) == 2.0
ClA.update_lp_primal_sol!(
state, ClMP.PrimalSolution(form, [ClMP.getid(var)], [3.0], 3.0, ClB.UNKNOWN_FEASIBILITY
))
# check that solution worse than `primalsol` is NOT added to `state.lp_primal_sols`
@test length(ClA.get_lp_primal_sols(state)) == 1
@test ClA.get_lp_primal_sols(state)[1] == primalsol
###
### lp dual
ClA.update_lp_dual_sol!(state, dualsol)
# check that `dualsol` is added to `state.lp_dual_sols`
@test length(ClA.get_lp_dual_sols(state)) == 1
@test ClA.get_lp_dual_sols(state)[1] == dualsol
# check that incumbent bound is updated
@test ClA.get_lp_dual_bound(state) == 1.0
ClA.update_lp_dual_sol!(state, ClMP.DualSolution(
form, [ClMP.getid(constr)], [0.0], ClMP.VarId[], Float64[], ClMP.ActiveBound[], 0.0, ClB.UNKNOWN_FEASIBILITY
))
# check that solution worse than `dualsol` is NOT added to `state.lp_dual_sols`
@test length(ClA.get_lp_dual_sols(state)) == 1
@test ClA.get_lp_dual_sols(state)[1] == dualsol
###
end
register!(unit_tests, "optimization_state", update_solution_with_min_objective)
function update_solution_with_max_objective()
form, var, constr = formulation_for_optimizationstate(ClMP.MaxSense)
state = ClA.OptimizationState(
form, max_length_ip_primal_sols = 2.0,
max_length_lp_primal_sols = 2.0, max_length_lp_dual_sols = 2.0
)
primalsol = ClMP.PrimalSolution(form, [ClMP.getid(var)], [1.0], 1.0, ClB.UNKNOWN_FEASIBILITY)
dualsol = ClMP.DualSolution(form, [ClMP.getid(constr)], [2.0], ClMP.VarId[], Float64[], ClMP.ActiveBound[], 2.0, ClB.UNKNOWN_FEASIBILITY)
### ip primal
ClA.update_ip_primal_sol!(state, primalsol)
# check that `primalsol` is added to `state.ip_primal_sols`
@test length(ClA.get_ip_primal_sols(state)) == 1
@test ClA.get_ip_primal_sols(state)[1] == primalsol
# check that incumbent bound is updated
@test ClA.get_ip_primal_bound(state) == 1.0
ClA.update_ip_primal_sol!(state, ClMP.PrimalSolution(
form, [ClMP.getid(var)], [0.0], 0.0, ClB.UNKNOWN_FEASIBILITY
))
# check that solution worse than `primalsol` is NOT added to `state.ip_primal_sols`
@test length(ClA.get_ip_primal_sols(state)) == 1
@test ClA.get_ip_primal_sols(state)[1] == primalsol
###
### lp primal
ClA.update_lp_primal_sol!(state, primalsol)
# check that `primalsol` is added to `state.lp_primal_sols`
@test length(ClA.get_lp_primal_sols(state)) == 1
@test ClA.get_lp_primal_sols(state)[1] == primalsol
# check that incumbent bound is updated
@test ClA.get_lp_primal_bound(state) == 1.0
ClA.update_lp_primal_sol!(
state, ClMP.PrimalSolution(form, [ClMP.getid(var)], [0.0], 0.0, ClB.UNKNOWN_FEASIBILITY
))
# check that solution worse than `primalsol` is NOT added to `state.lp_primal_sols`
@test length(ClA.get_lp_primal_sols(state)) == 1
@test ClA.get_lp_primal_sols(state)[1] == primalsol
###
### lp dual
ClA.update_lp_dual_sol!(state, dualsol)
# check that `dualsol` is added to `state.lp_dual_sols`
@test length(ClA.get_lp_dual_sols(state)) == 1
@test ClA.get_lp_dual_sols(state)[1] == dualsol
# check that incumbent bound is updated
@test ClA.get_lp_dual_bound(state) == 2.0
ClA.update_lp_dual_sol!(state, ClMP.DualSolution(
form, [ClMP.getid(constr)], [3.0], ClMP.VarId[], Float64[], ClMP.ActiveBound[], 3.0, ClB.UNKNOWN_FEASIBILITY
))
# check that solution worse than `dualsol` is NOT added to `state.lp_dual_sols`
@test length(ClA.get_lp_dual_sols(state)) == 1
@test ClA.get_lp_dual_sols(state)[1] == dualsol
###
end
register!(unit_tests, "optimization_state", update_solution_with_max_objective)
function add_solution_with_min_objective()
form, var, constr = formulation_for_optimizationstate()
state = ClA.OptimizationState(form)
primalsol = ClMP.PrimalSolution(form, [ClMP.getid(var)], [2.0], 2.0, ClB.UNKNOWN_FEASIBILITY)
dualsol = ClMP.DualSolution(form, [ClMP.getid(constr)], [1.0], ClMP.VarId[], Float64[], ClMP.ActiveBound[], 1.0, ClB.UNKNOWN_FEASIBILITY)
### ip primal
ClA.add_ip_primal_sols!(
state,
ClMP.PrimalSolution(form, [ClMP.getid(var)], [3.0], 3.0, ClB.UNKNOWN_FEASIBILITY),
primalsol
)
# check that `primalsol` is added to `state.ip_primal_sols` and worst solution is removed
@test length(ClA.get_ip_primal_sols(state)) == 1
@test ClA.get_ip_primal_sols(state)[1] == primalsol
# check that incumbent bound is updated
@test ClA.get_ip_primal_bound(state) == 2.0
###
### lp primal
ClA.add_lp_primal_sol!(state, ClMP.PrimalSolution(
form, [ClMP.getid(var)], [3.0], 3.0, ClB.UNKNOWN_FEASIBILITY
))
# check that incumbent bound is updated
@test ClA.get_lp_primal_bound(state) == 3.0
ClA.add_lp_primal_sol!(state, primalsol)
# check that `primalsol` is added to `state.lp_primal_sols` and worst solution is removed
@test length(ClA.get_lp_primal_sols(state)) == 1
@test ClA.get_lp_primal_sols(state)[1] == primalsol
# check that incumbent bound is updated
@test ClA.get_lp_primal_bound(state) == 2.0
###
### lp dual
ClA.add_lp_dual_sol!(state, ClMP.DualSolution(
form, [ClMP.getid(constr)], [0.0], ClMP.VarId[], Float64[], ClMP.ActiveBound[], 0.0, ClB.UNKNOWN_FEASIBILITY
))
# check that incumbent bound is updated
@test ClA.get_lp_dual_bound(state) == 0.0
ClA.add_lp_dual_sol!(state, dualsol)
# check that `dualsol` is added to `state.lp_dual_sols` and worst solution is removed
@test length(ClA.get_lp_dual_sols(state)) == 1
@test ClA.get_lp_dual_sols(state)[1] == dualsol
# check that incumbent bound is updated
@test ClA.get_lp_dual_bound(state) == 1.0
###
end
register!(unit_tests, "optimization_state", add_solution_with_min_objective)
function add_solution_with_max_objective()
form, var, constr = formulation_for_optimizationstate(ClMP.MaxSense)
state = ClA.OptimizationState(form)
primalsol = ClMP.PrimalSolution(form, [ClMP.getid(var)], [1.0], 1.0, ClB.UNKNOWN_FEASIBILITY)
dualsol = ClMP.DualSolution(form, [ClMP.getid(constr)], [2.0], ClMP.VarId[], Float64[], ClMP.ActiveBound[], 2.0, ClB.UNKNOWN_FEASIBILITY)
### ip primal
ClA.add_ip_primal_sols!(
state,
ClMP.PrimalSolution(form, [ClMP.getid(var)], [0.0], 0.0, ClB.UNKNOWN_FEASIBILITY),
primalsol
)
# check that `primalsol` is added to `state.ip_primal_sols` and worst solution is removed
@test length(ClA.get_ip_primal_sols(state)) == 1
@test ClA.get_ip_primal_sols(state)[1] == primalsol
# check that incumbent bound is updated
@test ClA.get_ip_primal_bound(state) == 1.0
###
### lp primal
ClA.add_lp_primal_sol!(state, ClMP.PrimalSolution(
form, [ClMP.getid(var)], [0.0], 0.0, ClB.UNKNOWN_FEASIBILITY
))
# check that incumbent bound is updated
@test ClA.get_lp_primal_bound(state) == 0.0
ClA.add_lp_primal_sol!(state, primalsol)
# check that `primalsol` is added to `state.lp_primal_sols` and worst solution is removed
@test length(ClA.get_lp_primal_sols(state)) == 1
@test ClA.get_lp_primal_sols(state)[1] == primalsol
# check that incumbent bound is updated
@test ClA.get_lp_primal_bound(state) == 1.0
###
### lp dual
ClA.add_lp_dual_sol!(state, ClMP.DualSolution(
form, [ClMP.getid(constr)], [3.0], ClMP.VarId[], Float64[], ClMP.ActiveBound[], 3.0, ClB.UNKNOWN_FEASIBILITY
))
# check that incumbent bound is updated
@test ClA.get_lp_dual_bound(state) == 3.0
ClA.add_lp_dual_sol!(state, dualsol)
# check that `dualsol` is added to `state.lp_dual_sols` and worst solution is removed
@test length(ClA.get_lp_dual_sols(state)) == 1
@test ClA.get_lp_dual_sols(state)[1] == dualsol
# check that incumbent bound is updated
@test ClA.get_lp_dual_bound(state) == 2.0
###
end
register!(unit_tests, "optimization_state", add_solution_with_max_objective)
function set_solution_with_min_objective()
form, var, constr = formulation_for_optimizationstate()
state = ClA.OptimizationState(
form, ip_primal_bound = 3.0, lp_primal_bound = 3.0, lp_dual_bound = -1.0
)
primalsol = ClMP.PrimalSolution(form, [ClMP.getid(var)], [2.0], 2.0, ClB.UNKNOWN_FEASIBILITY)
dualsol = ClMP.DualSolution(form, [ClMP.getid(constr)], [0.0], ClMP.VarId[], Float64[], ClMP.ActiveBound[], 0.0, ClB.UNKNOWN_FEASIBILITY)
### ip primal
ClA.set_ip_primal_sol!(state, ClMP.PrimalSolution(
form, [ClMP.getid(var)], [1.0], 1.0, ClB.UNKNOWN_FEASIBILITY
))
ClA.set_ip_primal_sol!(state, primalsol)
# check that only the solution which was set last is in `state.ip_primal_sols`
@test length(ClA.get_ip_primal_sols(state)) == 1
@test ClA.get_ip_primal_sols(state)[1] == primalsol
# check that incumbent bound is NOT updated
@test ClA.get_ip_primal_bound(state) == 3.0
###
### lp primal
ClA.set_lp_primal_sol!(state, ClMP.PrimalSolution(
form, [ClMP.getid(var)], [1.0], 1.0, ClB.UNKNOWN_FEASIBILITY
))
ClA.set_lp_primal_sol!(state, primalsol)
# check that only the solution which was set last is in `state.lp_primal_sols`
@test length(ClA.get_lp_primal_sols(state)) == 1
@test ClA.get_lp_primal_sols(state)[1] == primalsol
# check that incumbent bound is NOT updated
@test ClA.get_lp_primal_bound(state) == 3.0
###
### lp dual
ClA.set_lp_dual_sol!(state, ClMP.DualSolution(
form, [ClMP.getid(constr)], [1.0], ClMP.VarId[], Float64[], ClMP.ActiveBound[], 1.0, ClB.UNKNOWN_FEASIBILITY
))
ClA.set_lp_dual_sol!(state, dualsol)
# check that only the solution which was set last is in `state.lp_dual_sols`
@test length(ClA.get_lp_dual_sols(state)) == 1
@test ClA.get_lp_dual_sols(state)[1] == dualsol
# check that incumbent bound is NOT updated
@test ClA.get_lp_dual_bound(state) == -1.0
###
end
register!(unit_tests, "optimization_state", set_solution_with_min_objective)
function set_solution_with_max_objective()
form, var, constr = formulation_for_optimizationstate(ClMP.MaxSense)
state = ClA.OptimizationState(
form, ip_primal_bound = -1.0, lp_primal_bound = -1.0, lp_dual_bound = 3.0
)
primalsol = ClMP.PrimalSolution(form, [ClMP.getid(var)], [0.0], 0.0, ClB.UNKNOWN_FEASIBILITY)
dualsol = ClMP.DualSolution(form, [ClMP.getid(constr)], [2.0], ClMP.VarId[], Float64[], ClMP.ActiveBound[], 2.0, ClB.UNKNOWN_FEASIBILITY)
### ip primal
ClA.set_ip_primal_sol!(state, ClMP.PrimalSolution(
form, [ClMP.getid(var)], [1.0], 1.0, ClB.UNKNOWN_FEASIBILITY
))
ClA.set_ip_primal_sol!(state, primalsol)
# check that only the solution which was set last is in `state.ip_primal_sols`
@test length(ClA.get_ip_primal_sols(state)) == 1
@test ClA.get_ip_primal_sols(state)[1] == primalsol
# check that incumbent bound is NOT updated
@test ClA.get_ip_primal_bound(state) == -1.0
###
### lp primal
ClA.set_lp_primal_sol!(state, ClMP.PrimalSolution(
form, [ClMP.getid(var)], [1.0], 1.0, ClB.UNKNOWN_FEASIBILITY
))
ClA.set_lp_primal_sol!(state, primalsol)
# check that only the solution which was set last is in `state.lp_primal_sols`
@test length(ClA.get_lp_primal_sols(state)) == 1
@test ClA.get_lp_primal_sols(state)[1] == primalsol
# check that incumbent bound is NOT updated
@test ClA.get_lp_primal_bound(state) == -1.0
###
### lp dual
ClA.set_lp_dual_sol!(state, ClMP.DualSolution(
form, [ClMP.getid(constr)], [1.0], ClMP.VarId[], Float64[], ClMP.ActiveBound[], 1.0, ClB.UNKNOWN_FEASIBILITY
))
ClA.set_lp_dual_sol!(state, dualsol)
# check that only the solution which was set last is in `state.lp_dual_sols`
@test length(ClA.get_lp_dual_sols(state)) == 1
@test ClA.get_lp_dual_sols(state)[1] == dualsol
# check that incumbent bound is NOT updated
@test ClA.get_lp_dual_bound(state) == 3.0
end
register!(unit_tests, "optimization_state", set_solution_with_max_objective) | Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 1979 | # @testset "Algorithm - Presolve" begin
# @testset "RemovalOfFixedVariables" begin
# @test ClA._fix_var(0.99, 1.01, 0.1)
# @test !ClA._fix_var(0.98, 1.1, 0.1)
# @test ClA._fix_var(1.5, 1.5, 0.1)
# @test_broken !ClA._infeasible_var(1.09, 0.91, 0.1)
# @test ClA._infeasible_var(1.2, 0.9, 0.1)
# # Create the following formulation:
# # min x1 + 2x2 + 3x3
# # st. x1 >= 1
# # x2 >= 2
# # x3 >= 3
# # x1 + 2x2 + 3x3 >= 10
# env = CL.Env{ClMP.VarId}(CL.Params())
# form = ClMP.create_formulation!(env, ClMP.DwMaster())
# vars = Dict{String, ClMP.Variable}()
# for i in 1:3
# x = ClMP.setvar!(form, "x$i", ClMP.OriginalVar; cost = i, lb = i)
# vars["x$i"] = x
# end
# members = Dict{ClMP.VarId,Float64}(
# ClMP.getid(vars["x1"]) => 1,
# ClMP.getid(vars["x2"]) => 2,
# ClMP.getid(vars["x3"]) => 3
# )
# c = ClMP.setconstr!(form, "c", ClMP.OriginalConstr;
# rhs = 10, sense = ClMP.Greater, members = members
# )
# DynamicSparseArrays.closefillmode!(ClMP.getcoefmatrix(form))
# @test ClMP.getcurrhs(form, c) == 10
# ClMP.setcurlb!(form, vars["x1"], 2)
# ClMP.setcurub!(form, vars["x1"], 2)
# @test ClMP.getcurrhs(form, c) == 10
# ClA.treat!(form, ClA.RemovalOfFixedVariables(1e-6))
# @test ClMP.getcurrhs(form, c) == 10 - 2
# ClMP.setcurlb!(form, vars["x2"], 3)
# ClMP.setcurub!(form, vars["x2"], 3)
# ClA.treat!(form, ClA.RemovalOfFixedVariables(1e-6))
# @test ClMP.getcurrhs(form, c) == 10 - 2 - 2*3
# ClMP.unfix!(form, vars["x1"])
# ClMP.setcurlb!(form, vars["x1"], 1)
# ClA.treat!(form, ClA.RemovalOfFixedVariables(1e-6))
# @test ClMP.getcurrhs(form, c) == 10 - 2*3
# return
# end
# end | Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 1998 | function unit_master_columns_record()
env = CL.Env{ClMP.VarId}(CL.Params())
# Create the following formulation:
# min 1*v1 + 2*v2 + 4*v3
# c1: 2*v1 + v3 >= 4
# c2: v1 + 2*v2 >= 5
# c3: v1 + v2 + v3 >= 3
form = ClMP.create_formulation!(env, ClMP.DwMaster())
vars = Dict{String,ClMP.Variable}()
constrs = Dict{String,ClMP.Constraint}()
rhs = [4,5,3]
for i in 1:3
c = ClMP.setconstr!(form, "c$i", ClMP.MasterMixedConstr; rhs = rhs[i], sense = ClMP.Less)
constrs["c$i"] = c
end
members = [
Dict(ClMP.getid(constrs["c1"]) => 2.0, ClMP.getid(constrs["c2"]) => 1.0, ClMP.getid(constrs["c3"]) => 1.0),
Dict(ClMP.getid(constrs["c2"]) => 2.0, ClMP.getid(constrs["c3"]) => 1.0),
Dict(ClMP.getid(constrs["c1"]) => 1.0, ClMP.getid(constrs["c3"]) => 1.0),
]
costs = [1,2,4]
for i in 1:3
v = ClMP.setvar!(form, "v$i", ClMP.MasterCol; cost = costs[i], members = members[i], lb = 0)
vars["v$i"] = v
end
DynamicSparseArrays.closefillmode!(ClMP.getcoefmatrix(form))
storage = ClB.getstorage(form)
r1 = ClB.create_record(storage, ClA.MasterColumnsUnit)
@test isempty(setdiff(r1.active_cols, ClMP.getid.(values(vars))))
# make changes on the formulation
ClMP.deactivate!(form, vars["v2"])
r2 = ClB.create_record(storage, ClA.MasterColumnsUnit)
v1v3 = Set{ClMP.VarId}([ClMP.getid(vars["v1"]), ClMP.getid(vars["v3"])])
@test isempty(setdiff(r2.active_cols, v1v3))
ClB.restore_from_record!(storage, r1)
active_varids = filter(var_id -> iscuractive(form, var_id), keys(ClMP.getvars(form)))
@test isempty(setdiff(active_varids, ClMP.getid.(values(vars))))
ClB.restore_from_record!(storage, r2)
active_varids = filter(var_id -> iscuractive(form, var_id), keys(ClMP.getvars(form)))
@test isempty(setdiff(active_varids, v1v3))
end
register!(unit_tests, "storage_record", unit_master_columns_record) | Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 3118 | function unit_partial_solution_record()
env = CL.Env{ClMP.VarId}(CL.Params())
# Create the following formulation:
# min 1*v1 + 2*v2 + 4*v3
# c1: 2*v1 + v3 >= 4
# c2: v1 + 2*v2 >= 5
# c3: v1 + v2 + v3 >= 3
# 0 <= v1 <= 20
# -10 <= v2 <= 10
# -20 <= v3 <= 0
form = ClMP.create_formulation!(env, ClMP.DwMaster())
vars = Dict{String,ClMP.Variable}()
constrs = Dict{String,ClMP.Constraint}()
rhs = [4,5,3]
for i in 1:3
c = ClMP.setconstr!(form, "c$i", ClMP.OriginalConstr; rhs = rhs[i], sense = ClMP.Less)
constrs["c$i"] = c
end
members = [
Dict(ClMP.getid(constrs["c1"]) => 2.0, ClMP.getid(constrs["c2"]) => 1.0, ClMP.getid(constrs["c3"]) => 1.0),
Dict(ClMP.getid(constrs["c2"]) => 2.0, ClMP.getid(constrs["c3"]) => 1.0),
Dict(ClMP.getid(constrs["c1"]) => 1.0, ClMP.getid(constrs["c3"]) => 1.0),
]
costs = [1,2,4]
ubounds = [20,10,0]
lbounds = [0,-10,-20]
for i in 1:3
v = ClMP.setvar!(form, "v$i", ClMP.OriginalVar; cost = costs[i], members = members[i], lb = lbounds[i], ub = ubounds[i])
vars["v$i"] = v
end
DynamicSparseArrays.closefillmode!(ClMP.getcoefmatrix(form))
storage = ClB.getstorage(form)
r1 = ClB.create_record(storage, ClA.PartialSolutionUnit)
@test isempty(r1.partial_solution)
# make changes on the formulation
ClMP.add_to_partial_solution!(form, vars["v1"], 5.0, true) # we propagate to bounds
ClMP.add_to_partial_solution!(form, vars["v2"], -1.0, true)
ClMP.add_to_partial_solution!(form, vars["v3"], -2.0, true)
@test ClMP.get_value_in_partial_sol(form, vars["v1"]) == 5
@test ClMP.get_value_in_partial_sol(form, vars["v2"]) == -1
@test ClMP.get_value_in_partial_sol(form, vars["v3"]) == -2
@test ClMP.getcurlb(form, vars["v1"]) == 0
@test ClMP.getcurlb(form, vars["v2"]) == -9
@test ClMP.getcurlb(form, vars["v3"]) == -18
@test ClMP.getcurub(form, vars["v1"]) == 15
@test ClMP.getcurub(form, vars["v2"]) == 0
@test ClMP.getcurub(form, vars["v3"]) == 0
@test ClMP.in_partial_sol(form, vars["v1"])
@test ClMP.in_partial_sol(form, vars["v2"])
@test ClMP.in_partial_sol(form, vars["v3"])
r2 = ClB.create_record(storage, ClA.PartialSolutionUnit)
@test isempty(setdiff(keys(r2.partial_solution), ClMP.getid.(values(vars))))
@test r2.partial_solution[ClMP.getid(vars["v1"])] == 5.0
@test r2.partial_solution[ClMP.getid(vars["v2"])] == -1.0
@test r2.partial_solution[ClMP.getid(vars["v3"])] == -2.0
ClB.restore_from_record!(storage, r1)
@test !ClMP.in_partial_sol(form, vars["v1"])
@test !ClMP.in_partial_sol(form, vars["v2"])
@test !ClMP.in_partial_sol(form, vars["v3"])
ClB.restore_from_record!(storage, r2)
@test ClMP.get_value_in_partial_sol(form, vars["v1"]) == 5.0
@test ClMP.get_value_in_partial_sol(form, vars["v2"]) == -1.0
@test ClMP.get_value_in_partial_sol(form, vars["v3"]) == -2.0
end
register!(unit_tests, "storage_record", unit_partial_solution_record) | Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 3727 | function unit_static_var_constr_record()
function test_var_record(state, cost, lb, ub)
@test state.cost == cost
@test state.lb == lb
@test state.ub == ub
end
function test_var(form, var, cost, lb, ub)
@test ClMP.getcurcost(form, var) == cost
@test ClMP.getcurlb(form, var) == lb
@test ClMP.getcurub(form, var) == ub
end
function test_constr_record(state, rhs)
@test state.rhs == rhs
end
function test_constr(form, constr, rhs)
@test ClMP.getcurrhs(form, constr) == rhs
end
env = CL.Env{ClMP.VarId}(CL.Params())
# Create the following formulation:
# min 1*v1 + 2*v2 + 4*v3
# c1: 2*v1 + v3 >= 4
# c2: v1 + 2*v2 >= 5
# c3: v1 + v2 + v3 >= 3
# 0 <= v1 <= 10
# 0 <= v2 <= 20
# 0 <= v3 <= 30
form = ClMP.create_formulation!(env, ClMP.DwMaster())
vars = Dict{String,ClMP.Variable}()
constrs = Dict{String,ClMP.Constraint}()
rhs = [4,5,3]
for i in 1:3
c = ClMP.setconstr!(form, "c$i", ClMP.OriginalConstr; rhs = rhs[i], sense = ClMP.Less)
constrs["c$i"] = c
end
members = [
Dict(ClMP.getid(constrs["c1"]) => 2.0, ClMP.getid(constrs["c2"]) => 1.0, ClMP.getid(constrs["c3"]) => 1.0),
Dict(ClMP.getid(constrs["c2"]) => 2.0, ClMP.getid(constrs["c3"]) => 1.0),
Dict(ClMP.getid(constrs["c1"]) => 1.0, ClMP.getid(constrs["c3"]) => 1.0),
]
costs = [1,2,4]
ubounds = [10,20,30]
for i in 1:3
v = ClMP.setvar!(form, "v$i", ClMP.OriginalVar; cost = costs[i], members = members[i], lb = 0, ub = ubounds[i])
vars["v$i"] = v
end
DynamicSparseArrays.closefillmode!(ClMP.getcoefmatrix(form))
storage = ClB.getstorage(form)
r1 = ClB.create_record(storage, ClA.StaticVarConstrUnit)
@test isempty(setdiff(keys(r1.vars), ClMP.getid.(values(vars))))
@test isempty(setdiff(keys(r1.constrs), ClMP.getid.(values(constrs))))
test_var_record(r1.vars[ClMP.getid(vars["v1"])], 1, 0, 10)
test_var_record(r1.vars[ClMP.getid(vars["v2"])], 2, 0, 20)
test_var_record(r1.vars[ClMP.getid(vars["v3"])], 4, 0, 30)
test_constr_record(r1.constrs[ClMP.getid(constrs["c1"])], 4)
test_constr_record(r1.constrs[ClMP.getid(constrs["c2"])], 5)
test_constr_record(r1.constrs[ClMP.getid(constrs["c3"])], 3)
# make changes on the formulation
ClMP.setcurlb!(form, vars["v1"], 5.0)
ClMP.setcurub!(form, vars["v2"], 12.0)
ClMP.setcurcost!(form, vars["v3"], 4.6)
ClMP.setcurrhs!(form, constrs["c1"], 1.0)
ClMP.deactivate!(form, constrs["c2"])
r2 = ClB.create_record(storage, ClA.StaticVarConstrUnit)
@test isempty(setdiff(keys(r2.vars), ClMP.getid.(values(vars))))
@test length(r2.constrs) == 2
test_var_record(r2.vars[ClMP.getid(vars["v1"])], 1, 5, 10)
test_var_record(r2.vars[ClMP.getid(vars["v2"])], 2, 0, 12)
test_var_record(r2.vars[ClMP.getid(vars["v3"])], 4.6, 0, 30)
test_constr_record(r2.constrs[ClMP.getid(constrs["c1"])], 1)
test_constr_record(r2.constrs[ClMP.getid(constrs["c3"])], 3)
ClB.restore_from_record!(storage, r1)
test_var(form, vars["v1"], 1, 0, 10)
test_var(form, vars["v2"], 2, 0, 20)
test_var(form, vars["v3"], 4, 0, 30)
test_constr(form, constrs["c1"], 4)
@test ClMP.iscuractive(form, constrs["c2"])
ClB.restore_from_record!(storage, r2)
test_var(form, vars["v1"], 1, 5, 10)
test_var(form, vars["v2"], 2, 0, 12)
test_var(form, vars["v3"], 4.6, 0, 30)
test_constr(form, constrs["c1"], 1)
@test !ClMP.iscuractive(form, constrs["c2"])
end
register!(unit_tests, "storage_record", unit_static_var_constr_record) | Coluna | https://github.com/atoptima/Coluna.jl.git |
|
[
"MPL-2.0"
] | 0.8.1 | 828c61e9434b6af5f7908e42aacd17de35f08482 | code | 1754 | function reset_parameters_after_optimize_with_moi()
# Create the formulation:
# Min x
# s.t. x >= 1
env = Env{ClMP.VarId}(Coluna.Params())
form = ClMP.create_formulation!(env, ClMP.Original(), obj_sense = ClMP.MinSense)
ClMP.setvar!(form, "x", ClMP.OriginalVar; cost = 1, lb = 1)
closefillmode!(ClMP.getcoefmatrix(form))
algo1 = ClA.MoiOptimize(
time_limit = 1200,
silent = false,
custom_parameters = Dict(
"it_lim" => 60
)
)
algo2 = ClA.MoiOptimize(
silent = false,
custom_parameters = Dict(
"mip_gap" => 0.03
)
)
optimizer = ClMP.MoiOptimizer(MOI._instantiate_and_check(GLPK.Optimizer))
get_time_lim() = MOI.get(optimizer.inner, MOI.TimeLimitSec())
get_silent() = MOI.get(optimizer.inner, MOI.Silent())
get_it_lim() = MOI.get(optimizer.inner, MOI.RawOptimizerAttribute("it_lim"))
get_mip_gap() = MOI.get(optimizer.inner, MOI.RawOptimizerAttribute("mip_gap"))
default_time_lim = get_time_lim()
default_silent = get_silent()
default_it_lim = get_it_lim()
default_mip_gap = get_mip_gap()
ClA.optimize_with_moi!(optimizer, form, algo1, ClA.OptimizationState(form))
@test get_time_lim() == default_time_lim
@test get_silent() == default_silent
@test get_it_lim() == default_it_lim
@test get_mip_gap() == default_mip_gap
ClA.optimize_with_moi!(optimizer, form, algo2, ClA.OptimizationState(form))
@test get_time_lim() == default_time_lim
@test get_silent() == default_silent
@test get_it_lim() == default_it_lim
@test get_mip_gap() == default_mip_gap
return
end
register!(unit_tests, "subsolvers", reset_parameters_after_optimize_with_moi) | Coluna | https://github.com/atoptima/Coluna.jl.git |
Subsets and Splits