Rename branching_scheme* to tree_search* and add tree_search() functions

Each module's branching_scheme.{hpp,cpp} is renamed to tree_search.{hpp,cpp}
and gains a tree_search() function (with TreeSearchOutput/TreeSearchParameters
structs) following the same pattern as rectangleguillotine/column_generation_2.
The optimize_tree_search helper that previously lived in each optimize.cpp
anonymous namespace is eliminated; optimize.cpp now calls tree_search() directly.

For box, branching_scheme_maximal_spaces.* becomes tree_search_maximal_spaces.*
with a tree_search_maximal_spaces() function.

Author: fontanf

src/box/CMakeLists.txt

@@ -9,8 +9,8 @@ target_sources(PackingSolver_box PRIVATE
     optimize.cpp
     post_process.cpp
     block.cpp
-    branching_scheme.cpp
-    branching_scheme_maximal_spaces.cpp)
+    tree_search.cpp
+    tree_search_maximal_spaces.cpp)
 target_include_directories(PackingSolver_box PUBLIC
     ${PROJECT_SOURCE_DIR}/include)
 target_include_directories(PackingSolver_box PRIVATE

src/box/optimize.cpp

@@ -2,14 +2,12 @@
 
 #include "packingsolver/box/algorithm_formatter.hpp"
 #include "packingsolver/box/instance_builder.hpp"
-#include "box/branching_scheme.hpp"
-#include "box/branching_scheme_maximal_spaces.hpp"
+#include "box/tree_search.hpp"
+#include "box/tree_search_maximal_spaces.hpp"
 #include "algorithms/dichotomic_search.hpp"
 #include "algorithms/sequential_value_correction.hpp"
 #include "algorithms/column_generation.hpp"
 
-#include "treesearchsolver/iterative_beam_search_2.hpp"
-#include "treesearchsolver/iterative_beam_search.hpp"
 
 #include <thread>
 
@@ -19,217 +17,7 @@ using namespace packingsolver::box;
 namespace
 {
 
-void optimize_tree_search(
-        const Instance& instance,
-        const OptimizeParameters& parameters,
-        AlgorithmFormatter& algorithm_formatter)
-{
-    std::vector<GuideId> guides;
-    if (!parameters.tree_search_guides.empty()) {
-        guides = parameters.tree_search_guides;
-    } else if (instance.objective() == Objective::Knapsack) {
-        guides = {4, 5};
-    } else {
-        guides = {0, 1};
-    }
-    //guides = {4};
-
-    std::vector<Direction> directions;
-    if (instance.objective() == Objective::OpenDimensionX) {
-        directions = {Direction::X};
-    } else if (instance.objective() == Objective::OpenDimensionY) {
-        directions = {Direction::Y};
-    } else if (instance.objective() == Objective::OpenDimensionZ) {
-        directions = {Direction::Z};
-    } else if (instance.number_of_bin_types() == 1) {
-        directions = {Direction::X, Direction::Y, Direction::Z};
-    } else {
-        directions = {Direction::Any};
-    }
-    //directions = {Direction::Z};
-
-    std::vector<double> growth_factors = {1.5};
-    if (guides.size() * directions.size() * 2 <= 4)
-        growth_factors = {1.33, 1.5};
-    if (parameters.optimization_mode != OptimizationMode::Anytime)
-        growth_factors = {1.5};
-
-    std::vector<BranchingScheme> branching_schemes;
-    std::vector<treesearchsolver::IterativeBeamSearch2Parameters<BranchingScheme>> ibs_parameters_list;
-    std::vector<box::Output> outputs;
-    for (double growth_factor: growth_factors) {
-        for (GuideId guide_id: guides) {
-            for (Direction direction: directions) {
-                //std::cout << growth_factor << " " << guide_id << " " << direction << std::endl;
-                BranchingScheme::Parameters branching_scheme_parameters;
-                branching_scheme_parameters.guide_id = guide_id;
-                branching_scheme_parameters.direction = direction;
-                branching_schemes.push_back(BranchingScheme(instance, branching_scheme_parameters));
-                treesearchsolver::IterativeBeamSearch2Parameters<BranchingScheme> ibs_parameters;
-                ibs_parameters.verbosity_level = 0;
-                ibs_parameters.timer = parameters.timer;
-                ibs_parameters.timer.add_end_boolean(&algorithm_formatter.end_boolean());
-                ibs_parameters.growth_factor = growth_factor;
-                if (parameters.optimization_mode != OptimizationMode::Anytime) {
-                    ibs_parameters.minimum_size_of_the_queue = 1;
-                    ibs_parameters.growth_factor
-                        = parameters.not_anytime_tree_search_queue_size;
-                    ibs_parameters.maximum_size_of_the_queue
-                        = parameters.not_anytime_tree_search_queue_size;
-                }
-                if (!parameters.json_search_tree_path.empty()) {
-                    ibs_parameters.json_search_tree_path = parameters.json_search_tree_path
-                        + "_guide_" + std::to_string(branching_scheme_parameters.guide_id)
-                        + "_d_" + std::to_string((int)branching_scheme_parameters.direction);
-                }
-                ibs_parameters_list.push_back(ibs_parameters);
-                outputs.push_back(box::Output(instance));
-            }
-        }
-    }
-
-    std::vector<std::thread> threads;
-    std::forward_list<std::exception_ptr> exception_ptr_list;
-    for (Counter i = 0; i < (Counter)branching_schemes.size(); ++i) {
-        if (parameters.optimization_mode != OptimizationMode::NotAnytimeDeterministic) {
-            ibs_parameters_list[i].new_solution_callback
-                = [&algorithm_formatter, &branching_schemes, i](
-                        const treesearchsolver::Output<BranchingScheme>& tss_output)
-                {
-                    const treesearchsolver::IterativeBeamSearch2Output<BranchingScheme>& tssibs_output
-                        = static_cast<const treesearchsolver::IterativeBeamSearch2Output<BranchingScheme>&>(tss_output);
-                    Solution solution = branching_schemes[i].to_solution(
-                            tssibs_output.solution_pool.best());
-                    std::stringstream ss;
-                    ss << "TS g " << branching_schemes[i].parameters().guide_id
-                        << " d " << branching_schemes[i].parameters().direction
-                        << " q " << tssibs_output.maximum_size_of_the_queue;
-                    algorithm_formatter.update_solution(solution, ss.str());
-
-                    if (tssibs_output.optimal) {
-                        if (solution.instance().objective() == packingsolver::Objective::BinPacking) {
-                            algorithm_formatter.update_bin_packing_bound(
-                                    solution.number_of_bins());
-                        }
-                    }
-                };
-        } else {
-            ibs_parameters_list[i].new_solution_callback
-                = [&outputs, &branching_schemes, i](
-                        const treesearchsolver::Output<BranchingScheme>& tss_output)
-                {
-                    const treesearchsolver::IterativeBeamSearch2Output<BranchingScheme>& tssibs_output
-                        = static_cast<const treesearchsolver::IterativeBeamSearch2Output<BranchingScheme>&>(tss_output);
-                    Solution solution = branching_schemes[i].to_solution(
-                            tssibs_output.solution_pool.best());
-                    outputs[i].solution_pool.add(solution);
-                };
-        }
-        if (parameters.optimization_mode != OptimizationMode::NotAnytimeSequential) {
-            exception_ptr_list.push_front(std::exception_ptr());
-            threads.push_back(std::thread(
-                        wrapper<decltype(&treesearchsolver::iterative_beam_search_2<BranchingScheme>), treesearchsolver::iterative_beam_search_2<BranchingScheme>>,
-                        std::ref(exception_ptr_list.front()),
-                        std::ref(branching_schemes[i]),
-                        ibs_parameters_list[i]));
-        } else {
-            treesearchsolver::iterative_beam_search_2<BranchingScheme>(
-                    branching_schemes[i],
-                    ibs_parameters_list[i]);
-        }
-    }
-    for (Counter i = 0; i < (Counter)threads.size(); ++i)
-        threads[i].join();
-    for (const std::exception_ptr& exception_ptr: exception_ptr_list)
-        if (exception_ptr)
-            std::rethrow_exception(exception_ptr);
-    if (parameters.optimization_mode == OptimizationMode::NotAnytimeDeterministic) {
-        for (Counter i = 0; i < (Counter)branching_schemes.size(); ++i) {
-            std::stringstream ss;
-            ss << "TS g " << branching_schemes[i].parameters().guide_id
-                << " d " << branching_schemes[i].parameters().direction;
-            algorithm_formatter.update_solution(outputs[i].solution_pool.best(), ss.str());
-        }
-    }
-}
-
-void optimize_tree_search_maximal_spaces(
-        const Instance& instance,
-        const OptimizeParameters& parameters,
-        AlgorithmFormatter& algorithm_formatter)
-{
-    MaxReachableLengths max_reachable_lengths = compute_max_reachable_lengths(instance);
-    std::vector<std::vector<Block>> all_blocks = compute_blocks(instance);
-
-    std::vector<BranchingSchemeMaximalSpaces> branching_schemes;
-    std::vector<treesearchsolver::IterativeBeamSearchParameters<BranchingSchemeMaximalSpaces>> ibs_parameters_list;
-    std::vector<box::Output> outputs;
-    {
-        BranchingSchemeMaximalSpaces::Parameters branching_scheme_parameters;
-        branching_schemes.push_back(BranchingSchemeMaximalSpaces(instance, all_blocks, max_reachable_lengths, branching_scheme_parameters));
-        treesearchsolver::IterativeBeamSearchParameters<BranchingSchemeMaximalSpaces> ibs_parameters;
-        ibs_parameters.verbosity_level = 0;
-        ibs_parameters.timer = parameters.timer;
-        ibs_parameters.timer.add_end_boolean(&algorithm_formatter.end_boolean());
-        ibs_parameters.global_history = true;
-        ibs_parameters_list.push_back(ibs_parameters);
-        outputs.push_back(box::Output(instance));
-    }
 
-    std::vector<std::thread> threads;
-    std::forward_list<std::exception_ptr> exception_ptr_list;
-    for (Counter i = 0; i < (Counter)branching_schemes.size(); ++i) {
-        if (parameters.optimization_mode != OptimizationMode::NotAnytimeDeterministic) {
-            ibs_parameters_list[i].new_solution_callback
-                = [&algorithm_formatter, &branching_schemes, i](
-                        const treesearchsolver::Output<BranchingSchemeMaximalSpaces>& tss_output)
-                {
-                    const treesearchsolver::IterativeBeamSearchOutput<BranchingSchemeMaximalSpaces>& tssibs_output
-                        = static_cast<const treesearchsolver::IterativeBeamSearchOutput<BranchingSchemeMaximalSpaces>&>(tss_output);
-                    Solution solution = branching_schemes[i].to_solution(
-                            tssibs_output.solution_pool.best());
-                    std::stringstream ss;
-                    ss << "TSMS n " << tssibs_output.maximum_size_of_the_queue;
-                    algorithm_formatter.update_solution(solution, ss.str());
-                };
-        } else {
-            ibs_parameters_list[i].new_solution_callback
-                = [&outputs, &branching_schemes, i](
-                        const treesearchsolver::Output<BranchingSchemeMaximalSpaces>& tss_output)
-                {
-                    const treesearchsolver::IterativeBeamSearchOutput<BranchingSchemeMaximalSpaces>& tssibs_output
-                        = static_cast<const treesearchsolver::IterativeBeamSearchOutput<BranchingSchemeMaximalSpaces>&>(tss_output);
-                    Solution solution = branching_schemes[i].to_solution(
-                            tssibs_output.solution_pool.best());
-                    outputs[i].solution_pool.add(solution);
-                };
-        }
-        if (parameters.optimization_mode != OptimizationMode::NotAnytimeSequential) {
-            exception_ptr_list.push_front(std::exception_ptr());
-            threads.push_back(std::thread(
-                        wrapper<decltype(&treesearchsolver::iterative_beam_search<BranchingSchemeMaximalSpaces>), treesearchsolver::iterative_beam_search<BranchingSchemeMaximalSpaces>>,
-                        std::ref(exception_ptr_list.front()),
-                        std::ref(branching_schemes[i]),
-                        ibs_parameters_list[i]));
-        } else {
-            treesearchsolver::iterative_beam_search<BranchingSchemeMaximalSpaces>(
-                    branching_schemes[i],
-                    ibs_parameters_list[i]);
-        }
-    }
-    for (Counter i = 0; i < (Counter)threads.size(); ++i)
-        threads[i].join();
-    for (const std::exception_ptr& exception_ptr: exception_ptr_list)
-        if (exception_ptr)
-            std::rethrow_exception(exception_ptr);
-    if (parameters.optimization_mode == OptimizationMode::NotAnytimeDeterministic) {
-        for (Counter i = 0; i < (Counter)branching_schemes.size(); ++i) {
-            std::stringstream ss;
-            ss << "TSMS";
-            algorithm_formatter.update_solution(outputs[i].solution_pool.best(), ss.str());
-        }
-    }
-}
 
 void optimize_sequential_single_knapsack(
         const Instance& instance,
@@ -448,6 +236,53 @@ void optimize_column_generation(
     columngenerationsolver::limited_discrepancy_search(cgs_model, cgslds_parameters);
 }
 
+void optimize_tree_search(
+        const Instance& instance,
+        const OptimizeParameters& parameters,
+        AlgorithmFormatter& algorithm_formatter)
+{
+    TreeSearchParameters ts_parameters;
+    ts_parameters.verbosity_level = 0;
+    ts_parameters.timer = parameters.timer;
+    ts_parameters.timer.add_end_boolean(&algorithm_formatter.end_boolean());
+    ts_parameters.guides = parameters.tree_search_guides;
+    ts_parameters.optimization_mode = parameters.optimization_mode;
+    ts_parameters.not_anytime_tree_search_queue_size = parameters.not_anytime_tree_search_queue_size;
+    ts_parameters.json_search_tree_path = parameters.json_search_tree_path;
+    ts_parameters.new_solution_callback = [&algorithm_formatter](
+            const packingsolver::Output<Instance, Solution>& ts_output)
+    {
+        const TreeSearchOutput& ts_out = static_cast<const TreeSearchOutput&>(ts_output);
+        algorithm_formatter.update_solution(ts_out.solution_pool.best(), ts_out.current_label);
+        if (ts_out.is_optimal
+                && ts_out.solution_pool.best().instance().objective() == packingsolver::Objective::BinPacking) {
+            algorithm_formatter.update_bin_packing_bound(
+                    ts_out.solution_pool.best().number_of_bins());
+        }
+    };
+    tree_search(instance, ts_parameters);
+}
+
+void optimize_tree_search_maximal_spaces(
+        const Instance& instance,
+        const OptimizeParameters& parameters,
+        AlgorithmFormatter& algorithm_formatter)
+{
+    TreeSearchMaximalSpacesParameters ts_ms_parameters;
+    ts_ms_parameters.verbosity_level = 0;
+    ts_ms_parameters.timer = parameters.timer;
+    ts_ms_parameters.timer.add_end_boolean(&algorithm_formatter.end_boolean());
+    ts_ms_parameters.optimization_mode = parameters.optimization_mode;
+    ts_ms_parameters.not_anytime_tree_search_queue_size = parameters.not_anytime_tree_search_queue_size;
+    ts_ms_parameters.new_solution_callback = [&algorithm_formatter](
+            const packingsolver::Output<Instance, Solution>& ts_output)
+    {
+        const TreeSearchMaximalSpacesOutput& ts_out = static_cast<const TreeSearchMaximalSpacesOutput&>(ts_output);
+        algorithm_formatter.update_solution(ts_out.solution_pool.best(), ts_out.current_label);
+    };
+    tree_search_maximal_spaces(instance, ts_ms_parameters);
+}
+
 }
 
 packingsolver::box::Output packingsolver::box::optimize(