Implement NoColGenStab + fix colgen tests

src/Algorithm/colgen.jl

@@ -109,7 +109,7 @@ function get_units_usage(algo::ColumnGeneration, reform::Reformulation)
     push!(units_usage, (master, MasterColumnsUnit, READ_AND_WRITE))
     #push!(units_usage, (master, PartialSolutionUnit, READ_ONLY))
     if stabilization_is_used(algo)
-        push!(units_usage, (master, ColGenStabilizationUnit, READ_AND_WRITE))
+        #push!(units_usage, (master, ColGenStabilizationUnit, READ_AND_WRITE))
     end
     return units_usage
 end

src/Algorithm/colgen/default.jl

@@ -529,7 +529,8 @@ 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)
-    if isnothing(cur_primal_sol) || isbetter(getvalue(primal_sol), getvalue(cur_primal_sol))
+    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

src/Algorithm/colgen/printer.jl

@@ -177,7 +177,7 @@ function _colgen_iter_str(
 end
 
 function ColGen.after_colgen_iteration(ctx::ColGenPrinterContext, phase, stage, env, colgen_iteration, stab, 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), stab.base_α))
+    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
 

src/Algorithm/colgen/stabilization.jl

@@ -1,11 +1,12 @@
-# struct NoColGenStab end
-# ColGen.setup_stabilization(ctx, master) = NoColGenStab()
-# ColGen.update_stabilization_after_master_optim!(::NoColGenStab, phase, mast_dual_sol) = nothing
-# ColGen.check_misprice(::NoColGenStab, generated_cols, mast_dual_sol) = false
-# ColGen.update_stabilization_after_pricing_optim!(::NoColGenStab, valid_db, pseudo_db, pricing_dual_sol) = nothing
-# ColGen.update_stabilization_after_iter!(::NoColGenStab) = nothing
-
-
+struct NoColGenStab end
+#ColGen.setup_stabilization(ctx, master) = NoColGenStab()
+ColGen.update_stabilization_after_master_optim!(::NoColGenStab, phase, mast_dual_sol) = false
+ColGen.get_master_dual_sol(::NoColGenStab, phase, mast_dual_sol) = mast_dual_sol
+ColGen.check_misprice(::NoColGenStab, generated_cols, mast_dual_sol) = false
+ColGen.update_stabilization_after_pricing_optim!(::NoColGenStab, master, valid_db, pseudo_db, mast_dual_sol) = nothing
+ColGen.update_stabilization_after_misprice!(::NoColGenStab, mast_dual_sol) = nothing
+ColGen.update_stabilization_after_iter!(::NoColGenStab, ctx, master, generated_columns, 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.
@@ -35,8 +36,10 @@ mutable struct ColGenStab{F}
     )
 end
 
-ColGen.setup_stabilization!(ctx, master) = ColGenStab(master)
+ColGen.get_output_str(stab::ColGenStab) = stab.base_α
 
+# ColGen.setup_stabilization!(ctx, master) = ColGenStab(master)
+ColGen.setup_stabilization!(ctx, master) = NoColGenStab()
 
 function ColGen.update_stabilization_after_master_optim!(stab::ColGenStab, phase, mast_dual_sol)
     stab.nb_misprices = 0

src/ColGen/stabilization.jl

@@ -10,4 +10,6 @@
 
 @mustimplement "ColGenStab" update_stabilization_after_misprice!(stab, mast_dual_sol) = nothing
 
-@mustimplement "ColGenStab" update_stabilization_after_iter!(stab, ctx, master, generated_columns, mast_dual_sol) = nothing
+@mustimplement "ColGenStab" update_stabilization_after_iter!(stab, ctx, master, generated_columns, mast_dual_sol) = nothing
+
+@mustimplement "ColGenStab" get_output_str(stab) = nothing

test/e2e/gap/generalized_assignment.jl

@@ -23,7 +23,7 @@ function gap_toy_instance()
     @test MOI.get(model, MOI.NumberOfVariables()) == length(x)
     @test MOI.get(model, MOI.SolverName()) == "Coluna"
 end
-register!(e2e_tests, "gap", gap_toy_instance; f = true)
+register!(e2e_tests, "gap", gap_toy_instance)
 
 function gap_strong_branching()
     println("\e[45m gap strong branching \e[00m")

test/unit/Benders/benders_default.jl

@@ -937,7 +937,7 @@ function benders_default_loc_routing()
     result = Coluna.Benders.run_benders_loop!(ctx, env)
     @test result.mlp ≈ 293.5
 end
-register!(unit_tests, "benders_default", benders_default_loc_routing, f = true)
+register!(unit_tests, "benders_default", benders_default_loc_routing)
 
 
 
@@ -962,7 +962,7 @@ function benders_default_loc_routing_infeasible()
     result = Coluna.Benders.run_benders_loop!(ctx, env)
     @test result.infeasible == true
 end
-register!(unit_tests, "benders_default", benders_default_loc_routing_infeasible, f = true)
+register!(unit_tests, "benders_default", benders_default_loc_routing_infeasible)
 
 function benders_default_location_routing_subopt()
     env, reform = benders_form_location_routing_subopt()
@@ -985,7 +985,7 @@ function benders_default_location_routing_subopt()
     result = Coluna.Benders.run_benders_loop!(ctx, env)
     @test result.mlp ≈ 386.0
 end
-register!(unit_tests, "benders_default", benders_default_location_routing_subopt, f = true)
+register!(unit_tests, "benders_default", benders_default_location_routing_subopt)
 
 
 function test_two_identicals_cut_at_two_iterations_failure()

test/unit/ColGen/colgen_default.jl

@@ -182,7 +182,7 @@ function test_subgradient_calculation_helper()
     @test helper.A[cids["c4"], vids["z1"]] == -1
     @test helper.A[cids["c4"], vids["z2"]] == -1
 end
-register!(unit_tests, "colgen_default", test_subgradient_calculation_helper; f = true)
+register!(unit_tests, "colgen_default", test_subgradient_calculation_helper)
 
 # All the tests are based on the Generalized Assignment problem.
 # x_mj = 1 if job j is assigned to machine m
@@ -695,6 +695,7 @@ ColGen.check_primal_ip_feasibility!(master_lp_primal_sol, ::TestColGenIterationC
 ColGen.is_unbounded(ctx::TestColGenIterationContext) = ColGen.is_unbounded(ctx.context)
 ColGen.is_infeasible(ctx::TestColGenIterationContext) = ColGen.is_infeasible(ctx.context)
 ColGen.update_master_constrs_dual_vals!(ctx::TestColGenIterationContext, phase, reform, master_lp_dual_sol) = ColGen.update_master_constrs_dual_vals!(ctx.context, phase, reform, master_lp_dual_sol)
+ColGen.update_reduced_costs!(ctx::TestColGenIterationContext, phase, red_costs) = nothing
 ColGen.get_subprob_var_orig_costs(ctx::TestColGenIterationContext) = ColGen.get_subprob_var_orig_costs(ctx.context)
 ColGen.get_subprob_var_coef_matrix(ctx::TestColGenIterationContext) = ColGen.get_subprob_var_coef_matrix(ctx.context)
 
@@ -707,6 +708,7 @@ function ColGen.update_sp_vars_red_costs!(ctx::TestColGenIterationContext, sp::F
     return
 end
 
+ColGen.compute_sp_init_pb(ctx::TestColGenIterationContext, sp::Formulation{DwSp}) =  ColGen.compute_sp_init_pb(ctx.context, sp)
 ColGen.compute_sp_init_db(ctx::TestColGenIterationContext, sp::Formulation{DwSp}) = ColGen.compute_sp_init_db(ctx.context, sp)
 ColGen.set_of_columns(ctx::TestColGenIterationContext) = ColGen.set_of_columns(ctx.context)
 ColGen.push_in_set!(ctx::TestColGenIterationContext, set, col) = ColGen.push_in_set!(ctx.context, set, col)
@@ -716,14 +718,14 @@ function ColGen.insert_columns!(reform, ctx::TestColGenIterationContext, phase,
     return ColGen.insert_columns!(reform, ctx.context, phase, columns)
 end
 
-function ColGen.optimize_pricing_problem!(ctx::TestColGenIterationContext, sp::Formulation{DwSp}, env, optimizer, master_dual_sol)
-    output = ColGen.optimize_pricing_problem!(ctx.context, sp, env, optimizer, master_dual_sol)
+function ColGen.optimize_pricing_problem!(ctx::TestColGenIterationContext, sp::Formulation{DwSp}, env, optimizer, master_dual_sol, stab_changes_mast_dual_sol)
+    output = ColGen.optimize_pricing_problem!(ctx.context, sp, env, optimizer, master_dual_sol, stab_changes_mast_dual_sol)
     # test here
     return output
 end
 
-function ColGen.compute_dual_bound(ctx::TestColGenIterationContext, phase, master_lp_obj_val, sp_dbs, master_dual_sol)
-    return ColGen.compute_dual_bound(ctx.context, phase, master_lp_obj_val, sp_dbs, master_dual_sol)
+function ColGen.compute_dual_bound(ctx::TestColGenIterationContext, phase, sp_dbs, master_dual_sol)
+    return ColGen.compute_dual_bound(ctx.context, phase, sp_dbs, master_dual_sol)
 end
 
 function test_colgen_iteration_min_gap()
@@ -783,7 +785,7 @@ function test_colgen_iteration_min_gap()
         pricing_var_reduced_costs,
     )
 
-    output = ColGen.run_colgen_iteration!(ctx, ClA.ColGenPhase3(), TestColGenStage(), env, nothing)
+    output = ColGen.run_colgen_iteration!(ctx, ClA.ColGenPhase3(), TestColGenStage(), env, nothing, Coluna.Algorithm.NoColGenStab())
     @test output.mlp ≈ 79.666666667
     @test output.db ≈ 21.3333333333
     @test output.nb_new_cols == 2
@@ -847,7 +849,7 @@ function test_colgen_iteration_max_gap()
     for sp in sps
         ClMP.push_optimizer!(sp, () -> ClA.MoiOptimizer(GLPK.Optimizer()))
     end
-    output = ColGen.run_colgen_iteration!(ctx, ClA.ColGenPhase3(), TestColGenStage(), env, nothing)
+    output = ColGen.run_colgen_iteration!(ctx, ClA.ColGenPhase3(), TestColGenStage(), env, nothing, Coluna.Algorithm.NoColGenStab())
     @test output.mlp ≈ 87.00
     @test output.db ≈ 110.00
     @test output.nb_new_cols == 2
@@ -915,7 +917,7 @@ function test_colgen_iteration_pure_master_vars()
         pricing_var_reduced_costs,
     )
 
-    output = ColGen.run_colgen_iteration!(ctx, ClA.ColGenPhase3(), TestColGenStage(), env, nothing)
+    output = ColGen.run_colgen_iteration!(ctx, ClA.ColGenPhase3(), TestColGenStage(), env, nothing, Coluna.Algorithm.NoColGenStab())
     @test output.mlp ≈ 52.9500
     @test output.db ≈ 51.5000
     @test output.nb_new_cols == 1
@@ -979,7 +981,7 @@ function test_colgen_iteration_obj_const()
         pricing_var_reduced_costs,
     )
 
-    output = ColGen.run_colgen_iteration!(ctx, ClA.ColGenPhase3(), TestColGenStage(), env, nothing)
+    output = ColGen.run_colgen_iteration!(ctx, ClA.ColGenPhase3(), TestColGenStage(), env, nothing, Coluna.Algorithm.NoColGenStab())
 
     @test output.mlp ≈ 779.6666666666667 
     @test output.db ≈ 717.6666666766668
@@ -1256,7 +1258,7 @@ function test_colgen_loop()
     ctx = ClA.ColGenContext(reform, ClA.ColumnGeneration())
     ColGen.setup_reformulation!(reform, phase)
     Coluna.set_optim_start_time!(env)
-    output = ColGen.run_colgen_phase!(ctx, phase, ColGenIterationTestStage(), env, nothing)
+    output = ColGen.run_colgen_phase!(ctx, phase, ColGenIterationTestStage(), env, nothing, Coluna.Algorithm.NoColGenStab())
 
     # EXPECTED:
     #    """

test/unit/ColGen/colgen_iteration.jl

@@ -133,8 +133,10 @@ struct ColGenIterationTestPricingResult
     dual_bound::Union{Nothing, Float64}
 end
 ColGen.get_primal_sols(res::ColGenIterationTestPricingResult) = res.primal_sols
+ColGen.get_primal_bound(res::ColGenIterationTestPricingResult) = res.primal_bound
 ColGen.get_dual_bound(res::ColGenIterationTestPricingResult) = res.dual_bound
 ColGen.compute_sp_init_db(::ColGenIterationTestContext, sp) = -Inf
+ColGen.compute_sp_init_pb(::ColGenIterationTestContext, sp) = Inf
 ColGen.set_of_columns(::ColGenIterationTestContext) = Vector{Float64}[]
 ColGen.is_infeasible(res::ColGenIterationTestPricingResult) = res.term_status == ClB.INFEASIBLE
 ColGen.is_unbounded(res::ColGenIterationTestPricingResult) = res.term_status == ClB.UNBOUNDED
@@ -146,7 +148,7 @@ function ColGen.push_in_set!(ctx::ColGenIterationTestContext, set::Vector{Vector
 end
 
 ## mock of the pricing solver
-function ColGen.optimize_pricing_problem!(ctx::ColGenIterationTestContext, form, env, optimizer, master_dual_sol)
+function ColGen.optimize_pricing_problem!(ctx::ColGenIterationTestContext, form, env, optimizer, master_dual_sol, stab_changes_mast_dual_sol)
     primal_val = nothing
     dual_val = nothing
     sols = Vector{Float64}[]
@@ -181,6 +183,8 @@ function ColGen.update_sp_vars_red_costs!(::ColGenIterationTestContext, subprob,
     return
 end
 
+ColGen.update_reduced_costs!(::ColGenIterationTestContext, phase, red_costs) = nothing
+
 function ColGen.check_primal_ip_feasibility!(sol, ctx::ColGenIterationTestContext, ::ColGenIterationTestPhase, reform, env)
     if ctx.new_ip_primal_sol
         @assert !ctx.master_has_new_cuts
@@ -208,7 +212,7 @@ function ColGen.insert_columns!(reform, ::ColGenIterationTestContext, phase, gen
     return [1]
 end
 
-function ColGen.compute_dual_bound(::ColGenIterationTestContext, ::ColGenIterationTestPhase, mast_lp_obj_val, sp_dbs, mast_dual_sol)
+function ColGen.compute_dual_bound(::ColGenIterationTestContext, ::ColGenIterationTestPhase, sp_dbs, mast_dual_sol)
     return 22.5 - 23/4
 end
 
@@ -264,7 +268,7 @@ end
 
 function colgen_iteration_master_ok_pricing_ok()
     ctx = ColGenIterationTestContext()
-    output = ColGen.run_colgen_iteration!(ctx, ColGenIterationTestPhase(), ColGenIterationTestStage(), nothing, nothing)
+    output = ColGen.run_colgen_iteration!(ctx, ColGenIterationTestPhase(), ColGenIterationTestStage(), nothing, nothing, Coluna.Algorithm.NoColGenStab())
     @test output.mlp == 22.5
     @test output.db == 22.5 - 23/4
     @test output.nb_new_cols == 1
@@ -283,7 +287,7 @@ function colgen_iteration_master_infeasible()
         master_solver_has_no_primal_solution = true,
         master_solver_has_no_dual_solution = true
     )
-    output = ColGen.run_colgen_iteration!(ctx, ColGenIterationTestPhase(), ColGenIterationTestStage(), nothing, nothing)
+    output = ColGen.run_colgen_iteration!(ctx, ColGenIterationTestPhase(), ColGenIterationTestStage(), nothing, nothing, Coluna.Algorithm.NoColGenStab())
     @test isnothing(output.mlp)
     @test output.db == Inf 
     @test output.nb_new_cols == 0
@@ -302,7 +306,7 @@ function colgen_iteration_pricing_infeasible()
         pricing_solver_has_no_solution = true,
         pricing_has_no_dual_bound = true
     )
-    output = ColGen.run_colgen_iteration!(ctx, ColGenIterationTestPhase(), ColGenIterationTestStage(), nothing, nothing)
+    output = ColGen.run_colgen_iteration!(ctx, ColGenIterationTestPhase(), ColGenIterationTestStage(), nothing, nothing, Coluna.Algorithm.NoColGenStab())
     @test isnothing(output.mlp)
     @test output.db == Inf
     @test output.nb_new_cols == 0
@@ -321,7 +325,7 @@ function colgen_iteration_master_unbounded()
         master_solver_has_no_primal_solution = true,
         master_solver_has_no_dual_solution = true
     )
-    @test_throws ColGen.UnboundedProblemError ColGen.run_colgen_iteration!(ctx, ColGenIterationTestPhase(), ColGenIterationTestStage(), nothing, nothing)
+    @test_throws ColGen.UnboundedProblemError ColGen.run_colgen_iteration!(ctx, ColGenIterationTestPhase(), ColGenIterationTestStage(), nothing, nothing, Coluna.Algorithm.NoColGenStab())
 end
 register!(unit_tests, "colgen_iteration", colgen_iteration_master_unbounded)
 
@@ -331,15 +335,15 @@ function colgen_iteration_pricing_unbounded()
         pricing_solver_has_no_solution = true,
         pricing_has_no_dual_bound = true
     )
-    @test_throws ColGen.UnboundedProblemError ColGen.run_colgen_iteration!(ctx, ColGenIterationTestPhase(), ColGenIterationTestStage(), nothing, nothing)
+    @test_throws ColGen.UnboundedProblemError ColGen.run_colgen_iteration!(ctx, ColGenIterationTestPhase(), ColGenIterationTestStage(), nothing, nothing, Coluna.Algorithm.NoColGenStab())
 end
 register!(unit_tests, "colgen_iteration", colgen_iteration_pricing_unbounded)
 
 function colgen_finds_ip_primal_sol()
     ctx = ColGenIterationTestContext(
         new_ip_primal_sol = true
     )
-    output = ColGen.run_colgen_iteration!(ctx, ColGenIterationTestPhase(), ColGenIterationTestStage(), nothing, nothing)
+    output = ColGen.run_colgen_iteration!(ctx, ColGenIterationTestPhase(), ColGenIterationTestStage(), nothing, nothing, Coluna.Algorithm.NoColGenStab())
     @test output.mlp == 22.5
     @test output.db == 22.5 - 23/4
     @test output.nb_new_cols == 1
@@ -356,7 +360,7 @@ function colgen_new_cuts_in_master()
     ctx = ColGenIterationTestContext(
         master_has_new_cuts = true
     )
-    output = ColGen.run_colgen_iteration!(ctx, ColGenIterationTestPhase(), ColGenIterationTestStage(), nothing, nothing)
+    output = ColGen.run_colgen_iteration!(ctx, ColGenIterationTestPhase(), ColGenIterationTestStage(), nothing, nothing, Coluna.Algorithm.NoColGenStab())
     @test isnothing(output.mlp)
     @test isnothing(output.db)
     @test output.nb_new_cols == 0
@@ -368,4 +372,3 @@ function colgen_new_cuts_in_master()
     @test isnothing(output.master_ip_primal_sol)
 end
 register!(unit_tests, "colgen_iteration", colgen_new_cuts_in_master)
-

test/unit/ColGen/colgen_printer.jl

@@ -15,8 +15,8 @@ function printer_colgen_iteration_master_ok_pricing_ok()
         nothing,
         nothing
     )
-    expected_str = "  <st= 9> <it=  1> <et= 2.34> <mst= 1.23> <sp= 0.12> <cols= 1> <al= 0.00> <DB=   16.7500> <mlp=   22.5000> <PB=Inf>"
-    str = Coluna.Algorithm._colgen_iter_str(1, output, 3, 9, 0.12, 1.23, 2.34)
+    expected_str = "  <st= 9> <it=  1> <et= 2.34> <mst= 1.23> <sp= 0.12> <cols= 1> <al= 0.12> <DB=   16.7500> <mlp=   22.5000> <PB=Inf>"
+    str = Coluna.Algorithm._colgen_iter_str(1, output, 3, 9, 0.12, 1.23, 2.34, 0.12)
     @test expected_str == str
 end
 register!(unit_tests, "colgen_printer", printer_colgen_iteration_master_ok_pricing_ok)
@@ -38,7 +38,7 @@ function printer_colgen_iteration_master_infeasible()
         nothing
     )
     expected_str = "  <st= 9> <it=  1> <et= 2.34> - infeasible master"
-    str = Coluna.Algorithm._colgen_iter_str(1, output, 3, 9, 0.12, 1.23, 2.34)
+    str = Coluna.Algorithm._colgen_iter_str(1, output, 3, 9, 0.12, 1.23, 2.34, 0.0)
     @test expected_str == str
 end
 register!(unit_tests, "colgen_printer", printer_colgen_iteration_master_infeasible)
@@ -60,7 +60,7 @@ function printer_colgen_iteration_pricing_infeasible()
         nothing
     )
     expected_str = "  <st= 9> <it=  1> <et= 2.34> - infeasible subproblem"
-    str = Coluna.Algorithm._colgen_iter_str(1, output, 3, 9, 0.12, 1.23, 2.34)
+    str = Coluna.Algorithm._colgen_iter_str(1, output, 3, 9, 0.12, 1.23, 2.34, 0.0)
     @test expected_str == str
 end
 register!(unit_tests, "colgen_printer", printer_colgen_iteration_pricing_infeasible)
@@ -82,7 +82,7 @@ function printer_colgen_iteration_master_unbounded()
         nothing
     )
     expected_str = ""
-    str = Coluna.Algorithm._colgen_iter_str(1, output, 3, 9, 0.12, 1.23, 2.34)
+    str = Coluna.Algorithm._colgen_iter_str(1, output, 3, 9, 0.12, 1.23, 2.34, 0.0)
     @test_broken expected_str == str
 end
 register!(unit_tests, "colgen_printer", printer_colgen_iteration_master_unbounded)
@@ -104,7 +104,7 @@ function printer_colgen_iteration_pricing_unbounded()
         nothing
     )
     expected_str = "  <st= 9> <it=  1> <et= 2.34> - unbounded subproblem"
-    str = Coluna.Algorithm._colgen_iter_str(1, output, 3, 9, 0.12, 1.23, 2.34)
+    str = Coluna.Algorithm._colgen_iter_str(1, output, 3, 9, 0.12, 1.23, 2.34, 0.0)
     @test expected_str == str
 end
 register!(unit_tests, "colgen_printer", printer_colgen_iteration_pricing_unbounded)
@@ -148,7 +148,7 @@ function printer_colgen_new_cuts_in_master()
         nothing
     )
     expected_str = "  <st= 9> <it=  1> <et= 2.34> - new essential cut in master"
-    str = Coluna.Algorithm._colgen_iter_str(1, output, 3, 9, 0.12, 1.23, 2.34)
+    str = Coluna.Algorithm._colgen_iter_str(1, output, 3, 9, 0.12, 1.23, 2.34, 0.0)
     @test expected_str == str
 end
 register!(unit_tests, "colgen_printer", printer_colgen_new_cuts_in_master)