Reduced cost strenghtening

cpp/src/branch_and_bound/CMakeLists.txt

@@ -5,7 +5,6 @@
 
 set(BRANCH_AND_BOUND_SRC_FILES
   ${CMAKE_CURRENT_SOURCE_DIR}/branch_and_bound.cpp
-  ${CMAKE_CURRENT_SOURCE_DIR}/mip_node.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/pseudo_costs.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/diving_heuristics.cpp
   )

cpp/src/branch_and_bound/branch_and_bound.hpp

@@ -8,12 +8,12 @@
 #pragma once
 
 #include <branch_and_bound/bb_event.hpp>
-#include <branch_and_bound/branch_and_bound_worker.hpp>
 #include <branch_and_bound/deterministic_workers.hpp>
-#include <branch_and_bound/diving_heuristics.hpp>
 #include <branch_and_bound/mip_node.hpp>
 #include <branch_and_bound/node_queue.hpp>
 #include <branch_and_bound/pseudo_costs.hpp>
+#include <branch_and_bound/worker.hpp>
+#include <branch_and_bound/worker_pool.hpp>
 
 #include <cuts/cuts.hpp>
 
@@ -30,8 +30,6 @@
 #include <utilities/work_limit_context.hpp>
 #include <utilities/work_unit_scheduler.hpp>
 
-#include <omp.h>
-
 #include <atomic>
 #include <functional>
 #include <future>
@@ -102,7 +100,7 @@ class branch_and_bound_t {
     }
   }
 
-  // Set a solution based on the user problem during the course of the solve
+  // Set a solution based on the user problem during solve time
   void set_new_solution(const std::vector<f_t>& solution);
 
   // This queues the solution to be processed at the correct work unit timestamp
@@ -147,10 +145,6 @@ class branch_and_bound_t {
                                     std::vector<i_t>& nonbasic_list,
                                     std::vector<f_t>& edge_norms);
 
-  i_t find_reduced_cost_fixings(f_t upper_bound,
-                                std::vector<f_t>& lower_bounds,
-                                std::vector<f_t>& upper_bounds);
-
   // The main entry routine. Returns the solver status and populates solution with the incumbent.
   mip_status_t solve(mip_solution_t<i_t, f_t>& solution);
 
@@ -325,6 +319,8 @@ class branch_and_bound_t {
     dual::status_t lp_status,
     logger_t& log);
 
+  void root_reduced_cost_fixing(f_t upper_bound);
+
   // ============================================================================
   // Deterministic BSP (Bulk Synchronous Parallel) methods for deterministic parallel B&B
   // ============================================================================

cpp/src/branch_and_bound/deterministic_workers.hpp

@@ -8,9 +8,9 @@
 #pragma once
 
 #include <branch_and_bound/bb_event.hpp>
-#include <branch_and_bound/branch_and_bound_worker.hpp>
 #include <branch_and_bound/diving_heuristics.hpp>
 #include <branch_and_bound/node_queue.hpp>
+#include <branch_and_bound/worker.hpp>
 
 #include <utilities/work_limit_context.hpp>
 
@@ -316,10 +316,13 @@ class deterministic_diving_worker_t
   void enqueue_dive_node(mip_node_t<i_t, f_t>* node, const lp_problem_t<i_t, f_t>& original_lp)
   {
     dive_queue_entry_t<i_t, f_t> entry;
-    entry.resolved_lower = original_lp.lower;
-    entry.resolved_upper = original_lp.upper;
     std::vector<bool> bounds_changed(original_lp.num_cols, false);
-    node->get_variable_bounds(entry.resolved_lower, entry.resolved_upper, bounds_changed);
+    bool feasible = node->get_variable_bounds(original_lp.lower,
+                                              original_lp.upper,
+                                              entry.resolved_lower,
+                                              entry.resolved_upper,
+                                              bounds_changed);
+    if (!feasible) { return; }
     entry.node = node->detach_copy();
     dive_queue.push_back(std::move(entry));
   }