Bendersalgo

Manifest.toml

@@ -37,9 +37,7 @@ version = "0.4.1"
 
 [[ColunaDemos]]
 deps = ["BlockDecomposition", "JuMP"]
-git-tree-sha1 = "f81e48f431e1321bcc71f004d87608b8aaf278f0"
-repo-rev = "master"
-repo-url = "https://github.com/atoptima/ColunaDemos.jl.git"
+path = "/Users/fv/.julia/dev/ColunaDemos"
 uuid = "a54e61d4-7723-11e9-2469-af255fcaa246"
 version = "0.1.0"
 
@@ -219,10 +217,10 @@ uuid = "276daf66-3868-5448-9aa4-cd146d93841b"
 version = "0.7.2"
 
 [[StaticArrays]]
-deps = ["InteractiveUtils", "LinearAlgebra", "Random", "Statistics", "Test"]
-git-tree-sha1 = "3841b39ed5f047db1162627bf5f80a9cd3e39ae2"
+deps = ["LinearAlgebra", "Random", "Statistics"]
+git-tree-sha1 = "db23bbf50064c582b6f2b9b043c8e7e98ea8c0c6"
 uuid = "90137ffa-7385-5640-81b9-e52037218182"
-version = "0.10.3"
+version = "0.11.0"
 
 [[Statistics]]
 deps = ["LinearAlgebra", "SparseArrays"]

src/decomposition.jl

@@ -172,12 +172,26 @@ function create_side_vars_constrs!(sp::Formulation{DwSp})
     return
 end
 
+
+function dutyofbendmastvar(var, annotations, orig_form)
+    orig_coef = getcoefmatrix(orig_form)
+    for (constrid, coef) in orig_coef[:, getid(var)]
+        constr_ann = annotations.ann_per_constr[constrid]
+        #if coef != 0 && BD.getformulation(constr_ann) == BD.Benders  # TODO use haskey instead testing != 0
+        if BD.getformulation(constr_ann) == BD.BendersSepSp 
+            return MasterBendFirstStageVar
+        end
+    end
+    return MasterPureVar
+end
+
 # Master of Benders decomposition
 function instantiate_orig_vars!(mast::Formulation{BendersMaster}, orig_form, annotations, mast_ann)
     !haskey(annotations.vars_per_ann, mast_ann) && return
     vars = annotations.vars_per_ann[mast_ann]
     for (id, var) in vars
-        clone_in_formulation!(mast, orig_form, var, MasterPureVar)
+        duty = dutyofbendmastvar(var, annotations, orig_form)
+        clone_in_formulation!(mast, orig_form, var, duty)
     end
     return
 end
@@ -193,8 +207,21 @@ end
 
 function create_side_vars_constrs!(mast::Formulation{BendersMaster})
     for sp in mast.parent_formulation.benders_sep_subprs
-        nu = collect(values(filter(var -> getduty(var[2]) == BendSpRepSecondStageCostVar, getvars(sp))))[1]
-        clone_in_formulation!(mast, sp, nu, MasterBendSecondStageCostVar)
+        nu = collect(values(filter(var -> getduty(var[2]) == BendSpSlackSecondStageCostVar, getvars(sp))))[1]
+        name = "η[$(split(getname(nu), "[")[end])"
+        setvar!(
+            mast, name, MasterBendSecondStageCostVar; cost = getcurcost(nu),
+            lb = -Inf, ub = Inf, 
+            kind = Continuous, sense = Free, is_explicit = true, id = getid(nu)
+        )
+        setvar!(
+            sp, name, BendSpRepSecondStageCostVar; cost = getcurcost(nu),
+            lb = -Inf, ub = Inf, 
+            kind = Continuous, sense = Free, is_explicit = false,
+            id = Id{Variable}(getid(nu), 2)
+        )
+
+        # clone_in_formulation!(mast, sp, eta, MasterBendSecondStageCostVar)
     end
     return
 end
@@ -204,46 +231,58 @@ function create_artificial_vars!(mast::Formulation{BendersMaster})
 end
 
 # Separation sp of Benders decomposition
-function involvedinbendsp(var, orig_form, annotations, sp_ann)
-    !haskey(annotations.constrs_per_ann, sp_ann) && return false
-    constrs = annotations.constrs_per_ann[sp_ann]
-    orig_coef = getcoefmatrix(orig_form)
-    for (constr_id, constr) in constrs
-        if orig_coef[constr_id, getid(var)] != 0
-            return true
-        end
-    end
-    return false
-end
+#function involvedinbendsp(var, orig_form, annotations, sp_ann)
+#    !haskey(annotations.constrs_per_ann, sp_ann) && return false
+#    constrs = annotations.constrs_per_ann[sp_ann]
+#    orig_coef = getcoefmatrix(orig_form)
+#    for (constr_id, constr) in constrs
+#        if orig_coef[constr_id, getid(var)] != 0 # TODO use haskey instead
+#            return true
+#        end
+#    end
+#    return false
+#end
 
 function instantiate_orig_vars!(sp::Formulation{BendersSp}, orig_form, annotations, sp_ann)
+
     if haskey(annotations.vars_per_ann, sp_ann)
         vars = annotations.vars_per_ann[sp_ann]
         for (id, var) in vars
             clone_in_formulation!(sp, orig_form, var, BendSpSepVar)
         end
     end
+
     mast_ann = getparent(annotations, sp_ann)
     if haskey(annotations.vars_per_ann, mast_ann)
         vars = annotations.vars_per_ann[mast_ann]
         for (id, var) in vars
-            if involvedinbendsp(var, orig_form, annotations, sp_ann)
+            if dutyofbendmastvar(var, annotations, orig_form) == MasterBendFirstStageVar
+                #if involvedinbendsp(var, orig_form, annotations, sp_ann)
                 name = "μ[$(split(getname(var), "[")[end])"
-                setvar!(
-                    sp, name, BendSpRepFirstStageVar; cost = 0.0, lb = -Inf, ub = Inf, 
+                mu = setvar!(
+                    sp, name, BendSpSlackFirstStageVar; cost = getcurcost(var),
+                    lb = -Inf, ub = Inf, 
                     kind = Continuous, sense = Free, is_explicit = true, id = id
                 )
+                setvar!(
+                    sp, getname(var), BendSpRepFirstStageVar; cost = 0.0,
+                    lb = -Inf, ub = Inf, 
+                    kind = getperenekind(var), sense = getperenesense(var), is_explicit = false,
+                    id = Id{Variable}(getid(mu), 2)
+                )
             end
         end
     end
     return
 end
 
+
 function dutyofbendspconstr(constr, annotations, orig_form)
     orig_coef = getcoefmatrix(orig_form)
     for (varid, coef) in orig_coef[getid(constr), :]
         var_ann = annotations.ann_per_var[varid]
-        if coef != 0 && BD.getformulation(var_ann) == BD.Master
+        #if coef != 0 && BD.getformulation(var_ann) == BD.Master
+        if BD.getformulation(var_ann) == BD.Master
             return BendSpTechnologicalConstr
         end
     end
@@ -266,7 +305,7 @@ function create_side_vars_constrs!(sp::Formulation{BendersSp})
     # Cost constraint
     mast = getmaster(sp)
     nu = setvar!(
-        sp, "ν[$sp_id]", BendSpRepSecondStageCostVar; cost = 1.0, lb = -Inf, ub = Inf,
+        sp, "ν[$sp_id]", BendSpSlackSecondStageCostVar; cost = 1.0, lb = -Inf, ub = Inf,
         kind = Continuous, sense = Free, is_explicit = true
     )
     cost = setconstr!(
@@ -275,7 +314,8 @@ function create_side_vars_constrs!(sp::Formulation{BendersSp})
     )
     sp_coef[getid(cost), getid(nu)] = 1.0
     for (var_id, var) in filter(var -> getduty(var[2]) == BendSpSepVar, getvars(sp))
-            sp_coef[getid(cost), var_id] = - getperenecost(var)
+        sp_coef[getid(cost), var_id] = - getperenecost(var)
+        setperenecost!(var, 0.0)
     end
     return
 end
@@ -294,7 +334,7 @@ function getoptbuilder(prob::Problem, ann)
 end
 
 function buildformulations!(prob::Problem, annotations::Annotations, reform, 
-                               parent, node::BD.Root)
+                            parent, node::BD.Root)
     ann = BD.annotation(node)
     form_type = BD.getformulation(ann)
     dec_type = BD.getdecomposition(ann)
@@ -311,7 +351,7 @@ function buildformulations!(prob::Problem, annotations::Annotations, reform,
 end
 
 function buildformulations!(prob::Problem, annotations::Annotations, reform, 
-                               parent, node::BD.Leaf)
+                            parent, node::BD.Leaf)
     ann = BD.annotation(node)
     form_type = BD.getformulation(ann)
     dec_type = BD.getdecomposition(ann)
@@ -341,4 +381,4 @@ function reformulate!(prob::Problem, annotations::Annotations,
         @show sp
         exit()
     end
-end
+end

src/filters.jl

@@ -13,6 +13,10 @@ _active_pricing_sp_var_(id_v::Pair{VarId,Variable}) = get_cur_is_active(id_v[2])
 "Returns true if `id_v[2]` is a benders subproblem variable and is currently active"
 _active_benders_sp_var_(id_v::Pair{VarId,Variable}) = get_cur_is_active(id_v[2]) == true && getduty(id_v[2]) <: AbstractBendSpVar
 
+_active_firststage_mast_var_(id_v::Pair{VarId,Variable}) = get_cur_is_active(id_v[2]) == true && getduty(id_v[2]) <: MasterBendFirstStageVar
+
+_active_firststage_sp_var_(id_v::Pair{VarId,Variable}) = get_cur_is_active(id_v[2]) == true && getduty(id_v[2]) <: BendSpRepFirstStageVar
+
 "Returns true if `v` is a master representative of a pricing subproblem variable and is currently active"
 _active_pricing_mast_rep_sp_var_(v::Variable) = get_cur_is_active(v) == true && getduty(v) <: AbstractMasterRepDwSpVar
 
@@ -35,4 +39,4 @@ _active_(id_vc::Pair{I,T}) where {I<:Id,T<:AbstractVarConstr} = _active_(id_vc[2
 _active_explicit_(vc::AbstractVarConstr) = (get_cur_is_active(vc) && get_cur_is_explicit(vc))
 
 "Returns true if `id_vc[2]` is currently active and is explicit"
-_active_explicit_(id_vc::Pair{I,T}) where {I<:Id,T<:AbstractVarConstr} = (get_cur_is_active(id_vc[2]) && get_cur_is_explicit(id_vc[2]))
+_active_explicit_(id_vc::Pair{I,T}) where {I<:Id,T<:AbstractVarConstr} = (get_cur_is_active(id_vc[2]) && get_cur_is_explicit(id_vc[2]))

src/globals.jl

@@ -1,5 +1,6 @@
 Base.@kwdef mutable struct GlobalValues
     initial_solve_time::Float64 = 0.0
+    MAX_IDENTICAL_CLONES::Int = 10
     MAX_PROCESSES::Int = 100
     MAX_FORMULATIOS::Int = 100
 end

src/reformulation.jl

@@ -34,7 +34,8 @@ add_dw_pricing_sp!(r::Reformulation, f) = push!(r.dw_pricing_subprs, f)
 add_benders_sep_sp!(r::Reformulation, f) = push!(r.benders_sep_subprs, f)
 
 function optimize!(reformulation::Reformulation)
-    opt_result = apply!(GlobalStrategy, reformulation)
+    #opt_result = apply!(GlobalStrategy, reformulation)
+    opt_result = apply!(reformulation.stratergy, reformulation)
     opt_result.primal_sols = [proj_cols_on_rep(
         getbestprimalsol(opt_result), getmaster(reformulation)
     )]

src/solsandbounds.jl

@@ -189,3 +189,12 @@ end
 
 Base.copy(s::T) where {T<:AbstractSolution} = T(s.bound, copy(s.sol))
 
+function Base.filter(f::Function, ds::DualSolution{S}) where {S<:AbstractObjSense}
+    newsol = filter(f, ds.sol)
+    elements = getelements(newsol)
+    bound = 0.0
+    for id_val in newsol
+        bound += id_val[2] * getcurrhs(elements[id_val[1]])
+    end
+    return DualSolution{S}(bound, newsol) 
+end

src/types.jl

@@ -63,6 +63,8 @@ struct DwSpPureVar <: AbstractDwSpVar end
 
 struct BendSpSepVar <: AbstractBendSpVar end
 struct BendSpPureVar <: AbstractBendSpVar end
+struct BendSpSlackFirstStageVar  <: AbstractBendSpRepMastVar end
+struct BendSpSlackSecondStageCostVar <: AbstractBendSpRepMastVar end
 struct BendSpRepFirstStageVar  <: AbstractBendSpRepMastVar end
 struct BendSpRepSecondStageCostVar <: AbstractBendSpRepMastVar end
 

src/variable.jl

@@ -124,5 +124,6 @@ getcurcost(vc::AbstractVarConstr) = vc.cur_data.cost
 getcurlb(vc::AbstractVarConstr) = vc.cur_data.lb
 getcurub(vc::AbstractVarConstr) = vc.cur_data.ub
 setcurcost!(vc::AbstractVarConstr, cost::Float64) = vc.cur_data.cost = cost
+setperenecost!(vc::AbstractVarConstr, cost::Float64) = vc.cur_data.cost = vc.perene_data.cost = cost
 setcurlb!(vc::AbstractVarConstr, lb::Float64) = vc.cur_data.lb = lb
 setcurub!(vc::AbstractVarConstr, ub::Float64) = vc.cur_data.ub = ub

src/vcids.jl

@@ -12,14 +12,16 @@ struct Id{VC <: AbstractVarConstr}
     uid::Int
     form_uid::Int
     proc_uid::Int
+    sequence_nb::Int
     _hash::Int
 end
 
-function _create_hash(uid::Int, form_uid::Int, proc_uid::Int)
+function _create_hash(uid::Int, form_uid::Int, proc_uid::Int, sequence_nb::Int)
     return (
-        uid * _globals_.MAX_FORMULATIOS * _globals_.MAX_PROCESSES
-        + form_uid * _globals_.MAX_PROCESSES
-        + proc_uid
+        uid * _globals_.MAX_FORMULATIOS * _globals_.MAX_PROCESSES * _globals_.MAX_IDENTICAL_CLONES
+        + form_uid * _globals_.MAX_PROCESSES * _globals_.MAX_IDENTICAL_CLONES
+        + proc_uid  * _globals_.MAX_IDENTICAL_CLONES
+        + sequence_nb
     )
 end
 
@@ -28,9 +30,13 @@ end
 
 Constructs an `Id` of type `VC` with `uid` = uid and `form_uid` = form_uid.
 """
-function Id{VC}(uid::Int, form_uid::Int) where {VC}
+function Id{VC}(uid::Int, form_uid::Int; sequence_nb = 1) where {VC}
     proc_uid = Distributed.myid()
-    Id{VC}(uid, form_uid, proc_uid, _create_hash(uid, form_uid, proc_uid))
+    Id{VC}(uid, form_uid, proc_uid, 1, _create_hash(uid, form_uid, proc_uid, sequence_nb))
+end
+
+function Id{VC}(id::Id, sequence_nb::Int) where {VC}
+    Id{VC}(id.uid, id.form_uid; sequence_nb = sequence_nb)
 end
 
 Base.hash(a::Id, h::UInt) = hash(a._hash, h)
@@ -41,8 +47,9 @@ Base.isless(a::Id, b::Id) = Base.isless(a.uid, b.uid)
 Base.zero(I::Type{<:Id}) = I(-1, -1, -1, -1) 
 getuid(id::Id) = id.uid
 getformuid(id::Id) = id.form_uid
+getseqnb(id::Id) = id.sequence_nb
 getprocuid(id::Id) = id.proc_uid
-getsortid(id::Id) = getuid(id) + 1000000 * getformuid(id)
+getsortid(id::Id) = getuid(id) + 1000000 * getformuid(id) + 10000000 * getseqnb(id)
 
 function Base.show(io::IO, id::Id{T}) where {T}
     print(io, T,"#", id._hash)

test/full_instances_tests.jl

@@ -1,5 +1,5 @@
 function full_instances_tests()
-    generalized_assignment_tests()
+    #generalized_assignment_tests()
     lot_sizing_tests()
 end
 
@@ -107,7 +107,7 @@ end
 
 function lot_sizing_tests()
     @testset "play single mode multi items lot sizing" begin
-        data = CLD.SingleModeMultiItemsLotSizing.data("lotSizing-3-20.txt")
+        data = CLD.SingleModeMultiItemsLotSizing.data("lotSizing-3-20-2.txt")
 
         coluna = JuMP.with_optimizer(Coluna.Optimizer,
             default_optimizer = with_optimizer(GLPK.Optimizer)
@@ -116,4 +116,4 @@ function lot_sizing_tests()
         problem, x, y, dec = CLD.SingleModeMultiItemsLotSizing.model(data, coluna)
         JuMP.optimize!(problem)
     end
-end
+end

test/unit/vcids.jl

@@ -8,20 +8,20 @@ function id_unit_tests()
     @test CL.getuid(var_id) == 20
     @test CL.getformuid(var_id) == 13
     @test CL.getprocuid(var_id) == 1
-    @test var_id._hash == 201301
-    @test isequal(var_id, 201301)
-    @test isequal(201301, var_id)
+    @test var_id._hash == 2013011
+    @test isequal(var_id, 2013011)
+    @test isequal(2013011, var_id)
 
     constr_id = CL.Id{CL.Constraint}(100, 3)
     @test CL.getuid(constr_id) == 100
     @test CL.getformuid(constr_id) == 3
     @test CL.getprocuid(constr_id) == 1
-    @test constr_id._hash == 1000301
-    @test isequal(constr_id, 1000301)
-    @test isequal(1000301, constr_id)
+    @test constr_id._hash == 10003011
+    @test isequal(constr_id, 10003011)
+    @test isequal(10003011, constr_id)
 
     @test var_id < constr_id
-    @test CL.getsortid(constr_id) == 100 + 1000000 * 3
+    #@test CL.getsortid(constr_id) == 100 + 1000000 * 3
 
     return
 end