simplified logic for pseudo cost (and its snapshot) for the regular and deterministic mode.

Signed-off-by: Nicolas Guidotti <224634272+nguidotti@users.noreply.github.com>

Author: nguidotti

cpp/src/branch_and_bound/branch_and_bound.cpp

@@ -1020,7 +1020,9 @@ struct deterministic_bfs_policy_t
                                                 const std::vector<i_t>& fractional,
                                                 const std::vector<f_t>& x) override
   {
-    i_t var  = this->worker.pc_snapshot.variable_selection(fractional, x);
+    logger_t log;
+    log.log  = false;
+    i_t var  = this->worker.pc_snapshot.variable_selection(fractional, x, log);
     auto dir = martin_criteria(x[var], this->bnb.root_relax_soln_.x[var]);
     return {var, dir};
   }
@@ -1029,8 +1031,10 @@ struct deterministic_bfs_policy_t
                                  const std::vector<i_t>& fractional,
                                  const std::vector<f_t>& x) override
   {
+    logger_t log;
+    log.log = false;
     node->objective_estimate =
-      this->worker.pc_snapshot.obj_estimate(fractional, x, node->lower_bound);
+      this->worker.pc_snapshot.obj_estimate(fractional, x, node->lower_bound, log);
   }
 
   void on_node_completed(mip_node_t<i_t, f_t>* node,
@@ -1095,24 +1099,22 @@ struct deterministic_diving_policy_t
                                                 const std::vector<i_t>& fractional,
                                                 const std::vector<f_t>& x) override
   {
+    logger_t log;
+    log.log = false;
+
     switch (this->worker.diving_type) {
       case search_strategy_t::PSEUDOCOST_DIVING:
-        return this->worker.variable_selection_from_snapshot(fractional, x);
+        return pseudocost_diving(
+          this->worker.pc_snapshot, fractional, x, *this->worker.root_solution, log);
 
       case search_strategy_t::LINE_SEARCH_DIVING:
-        if (this->worker.root_solution) {
-          logger_t log;
-          log.log = false;
-          return line_search_diving<i_t, f_t>(fractional, x, *this->worker.root_solution, log);
-        }
-        return this->worker.variable_selection_from_snapshot(fractional, x);
+        return line_search_diving<i_t, f_t>(fractional, x, *this->worker.root_solution, log);
 
       case search_strategy_t::GUIDED_DIVING:
-        return this->worker.guided_variable_selection(fractional, x);
+        return guided_diving(
+          this->worker.pc_snapshot, fractional, x, this->worker.incumbent_snapshot, log);
 
       case search_strategy_t::COEFFICIENT_DIVING: {
-        logger_t log;
-        log.log = false;
         return coefficient_diving<i_t, f_t>(this->worker.leaf_problem,
                                             fractional,
                                             x,
@@ -1121,7 +1123,7 @@ struct deterministic_diving_policy_t
                                             log);
       }
 
-      default: return this->worker.variable_selection_from_snapshot(fractional, x);
+      default: CUOPT_LOG_ERROR("Invalid diving method!"); return {-1, rounding_direction_t::NONE};
     }
   }
 
@@ -3366,11 +3368,12 @@ template <typename PoolT>
 void branch_and_bound_t<i_t, f_t>::deterministic_broadcast_snapshots(
   PoolT& pool, const std::vector<f_t>& incumbent_snapshot)
 {
-  deterministic_snapshot_t<i_t, f_t> snap;
-  snap.upper_bound    = upper_bound_.load();
-  snap.total_lp_iters = exploration_stats_.total_lp_iters.load();
-  snap.incumbent      = incumbent_snapshot;
-  snap.pc_snapshot    = pc_.create_snapshot();
+  deterministic_snapshot_t<i_t, f_t> snap{
+    .upper_bound    = upper_bound_,
+    .pc_snapshot    = pc_,
+    .incumbent      = incumbent_snapshot,
+    .total_lp_iters = exploration_stats_.total_lp_iters,
+  };
 
   for (auto& worker : pool) {
     worker.set_snapshots(snap);

cpp/src/branch_and_bound/constants.hpp

@@ -0,0 +1,31 @@
+/* clang-format off */
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/* clang-format on */
+
+#pragma once
+
+namespace cuopt::linear_programming::dual_simplex {
+
+constexpr int num_search_strategies = 5;
+
+// Indicate the search and variable selection algorithms used by each thread
+// in B&B (See [1]).
+//
+// [1] T. Achterberg, “Constraint Integer Programming,” PhD, Technischen Universität Berlin,
+// Berlin, 2007. doi: 10.14279/depositonce-1634.
+enum search_strategy_t : int {
+  BEST_FIRST         = 0,  // Best-First + Plunging.
+  PSEUDOCOST_DIVING  = 1,  // Pseudocost diving (9.2.5)
+  LINE_SEARCH_DIVING = 2,  // Line search diving (9.2.4)
+  GUIDED_DIVING      = 3,  // Guided diving (9.2.3).
+  COEFFICIENT_DIVING = 4   // Coefficient diving (9.2.1)
+};
+
+enum class rounding_direction_t { NONE = -1, DOWN = 0, UP = 1 };
+
+enum class branch_and_bound_mode_t { REGULAR = 0, DETERMINISTIC = 1 };
+
+}  // namespace cuopt::linear_programming::dual_simplex

cpp/src/branch_and_bound/deterministic_workers.hpp

@@ -58,7 +58,7 @@ struct deterministic_snapshot_t {
   f_t upper_bound;
   pseudo_cost_snapshot_t<i_t, f_t> pc_snapshot;
   std::vector<f_t> incumbent;
-  i_t total_lp_iters;
+  int64_t total_lp_iters;
 };
 
 template <typename i_t, typename f_t, typename Derived>
@@ -90,7 +90,7 @@ class deterministic_worker_base_t : public branch_and_bound_worker_t<i_t, f_t> {
                               const std::vector<variable_type_t>& var_types,
                               const simplex_solver_settings_t<i_t, f_t>& settings,
                               const std::string& context_name)
-    : base_t(id, original_lp, Arow, var_types, settings), work_context(context_name)
+    : base_t(id, original_lp, Arow, var_types, settings), work_context(context_name), pc_snapshot(1)
   {
     work_context.deterministic = true;
   }
@@ -345,22 +345,6 @@ class deterministic_diving_worker_t
       {objective, solution, depth, this->worker_id, this->next_solution_seq++});
     ++this->total_integer_solutions;
   }
-
-  branch_variable_t<i_t> variable_selection_from_snapshot(const std::vector<i_t>& fractional,
-                                                          const std::vector<f_t>& solution) const
-  {
-    assert(root_solution != nullptr);
-    return this->pc_snapshot.pseudocost_diving(fractional, solution, *root_solution);
-  }
-
-  branch_variable_t<i_t> guided_variable_selection(const std::vector<i_t>& fractional,
-                                                   const std::vector<f_t>& solution) const
-  {
-    if (this->incumbent_snapshot.empty()) {
-      return variable_selection_from_snapshot(fractional, solution);
-    }
-    return this->pc_snapshot.guided_diving(fractional, solution, this->incumbent_snapshot);
-  }
 };
 
 template <typename i_t, typename f_t, typename WorkerT, typename Derived>

cpp/src/branch_and_bound/diving_heuristics.cpp

@@ -65,38 +65,117 @@ branch_variable_t<i_t> line_search_diving(const std::vector<i_t>& fractional,
   return {branch_var, round_dir};
 }
 
-template <typename i_t, typename f_t>
-branch_variable_t<i_t> pseudocost_diving(pseudo_costs_t<i_t, f_t>& pc,
+template <typename i_t, typename f_t, branch_and_bound_mode_t Mode>
+branch_variable_t<i_t> pseudocost_diving(pseudo_costs_t<i_t, f_t, Mode>& pc,
                                          const std::vector<i_t>& fractional,
                                          const std::vector<f_t>& solution,
                                          const std::vector<f_t>& root_solution,
                                          logger_t& log)
 {
-  return pseudocost_diving_from_arrays(pc.pseudo_cost_sum_down.data(),
-                                       pc.pseudo_cost_sum_up.data(),
-                                       pc.pseudo_cost_num_down.data(),
-                                       pc.pseudo_cost_num_up.data(),
-                                       (i_t)pc.pseudo_cost_sum_down.size(),
-                                       fractional,
-                                       solution,
-                                       root_solution);
+  const i_t num_fractional = fractional.size();
+  if (num_fractional == 0) return {-1, rounding_direction_t::NONE};
+
+  pseudo_cost_averages_t<i_t, f_t> avgs = pc.compute_averages();
+
+  i_t branch_var                 = fractional[0];
+  f_t max_score                  = std::numeric_limits<f_t>::lowest();
+  rounding_direction_t round_dir = rounding_direction_t::DOWN;
+  constexpr f_t eps              = f_t(1e-6);
+
+  for (i_t j : fractional) {
+    f_t f_down  = solution[j] - std::floor(solution[j]);
+    f_t f_up    = std::ceil(solution[j]) - solution[j];
+    f_t pc_down = pc.pseudo_cost_num_down[j] != 0
+                    ? pc.pseudo_cost_sum_down[j] / pc.pseudo_cost_num_down[j]
+                    : avgs.down_avg;
+    f_t pc_up = pc.pseudo_cost_num_up[j] != 0 ? pc.pseudo_cost_sum_up[j] / pc.pseudo_cost_num_up[j]
+                                              : avgs.up_avg;
+
+    f_t score_down = std::sqrt(f_up) * (1 + pc_up) / (1 + pc_down);
+    f_t score_up   = std::sqrt(f_down) * (1 + pc_down) / (1 + pc_up);
+
+    f_t score                = 0;
+    rounding_direction_t dir = rounding_direction_t::DOWN;
+
+    f_t root_val = (j < static_cast<i_t>(root_solution.size())) ? root_solution[j] : solution[j];
+
+    if (solution[j] < root_val - f_t(0.4)) {
+      score = score_down;
+      dir   = rounding_direction_t::DOWN;
+    } else if (solution[j] > root_val + f_t(0.4)) {
+      score = score_up;
+      dir   = rounding_direction_t::UP;
+    } else if (f_down < f_t(0.3)) {
+      score = score_down;
+      dir   = rounding_direction_t::DOWN;
+    } else if (f_down > f_t(0.7)) {
+      score = score_up;
+      dir   = rounding_direction_t::UP;
+    } else if (pc_down < pc_up + eps) {
+      score = score_down;
+      dir   = rounding_direction_t::DOWN;
+    } else {
+      score = score_up;
+      dir   = rounding_direction_t::UP;
+    }
+
+    if (score > max_score) {
+      max_score  = score;
+      branch_var = j;
+      round_dir  = dir;
+    }
+  }
+
+  if (round_dir == rounding_direction_t::NONE) {
+    branch_var = fractional[0];
+    round_dir  = rounding_direction_t::DOWN;
+  }
+
+  return {branch_var, round_dir};
 }
 
-template <typename i_t, typename f_t>
-branch_variable_t<i_t> guided_diving(pseudo_costs_t<i_t, f_t>& pc,
+template <typename i_t, typename f_t, branch_and_bound_mode_t Mode>
+branch_variable_t<i_t> guided_diving(pseudo_costs_t<i_t, f_t, Mode>& pc,
                                      const std::vector<i_t>& fractional,
                                      const std::vector<f_t>& solution,
                                      const std::vector<f_t>& incumbent,
                                      logger_t& log)
 {
-  return guided_diving_from_arrays(pc.pseudo_cost_sum_down.data(),
-                                   pc.pseudo_cost_sum_up.data(),
-                                   pc.pseudo_cost_num_down.data(),
-                                   pc.pseudo_cost_num_up.data(),
-                                   (i_t)pc.pseudo_cost_sum_down.size(),
-                                   fractional,
-                                   solution,
-                                   incumbent);
+  const i_t num_fractional = fractional.size();
+  if (num_fractional == 0) return {-1, rounding_direction_t::NONE};
+
+  pseudo_cost_averages_t<i_t, f_t> avgs = pc.compute_averages();
+
+  i_t branch_var                 = fractional[0];
+  f_t max_score                  = std::numeric_limits<f_t>::lowest();
+  rounding_direction_t round_dir = rounding_direction_t::DOWN;
+  constexpr f_t eps              = f_t(1e-6);
+
+  for (i_t j : fractional) {
+    f_t f_down    = solution[j] - std::floor(solution[j]);
+    f_t f_up      = std::ceil(solution[j]) - solution[j];
+    f_t down_dist = std::abs(incumbent[j] - std::floor(solution[j]));
+    f_t up_dist   = std::abs(std::ceil(solution[j]) - incumbent[j]);
+    rounding_direction_t dir =
+      down_dist < up_dist + eps ? rounding_direction_t::DOWN : rounding_direction_t::UP;
+
+    f_t pc_down = pc.pseudo_cost_num_down[j] != 0
+                    ? pc.pseudo_cost_sum_down[j] / pc.pseudo_cost_num_down[j]
+                    : avgs.down_avg;
+    f_t pc_up  = pc.pseudo_cost_num_up[j] != 0 ? pc.pseudo_cost_sum_up[j] / pc.pseudo_cost_num_up[j]
+                                               : avgs.up_avg;
+    f_t score1 = dir == rounding_direction_t::DOWN ? 5 * pc_down * f_down : 5 * pc_up * f_up;
+    f_t score2 = dir == rounding_direction_t::DOWN ? pc_up * f_up : pc_down * f_down;
+    f_t score  = (score1 + score2) / 6;
+
+    if (score > max_score) {
+      max_score  = score;
+      branch_var = j;
+      round_dir  = dir;
+    }
+  }
+
+  return {branch_var, round_dir};
 }
 
 template <typename i_t, typename f_t>
@@ -187,12 +266,26 @@ template branch_variable_t<int> pseudocost_diving(pseudo_costs_t<int, double>& p
                                                   const std::vector<double>& root_solution,
                                                   logger_t& log);
 
+template branch_variable_t<int> pseudocost_diving(
+  pseudo_costs_t<int, double, branch_and_bound_mode_t::DETERMINISTIC>& pc,
+  const std::vector<int>& fractional,
+  const std::vector<double>& solution,
+  const std::vector<double>& root_solution,
+  logger_t& log);
+
 template branch_variable_t<int> guided_diving(pseudo_costs_t<int, double>& pc,
                                               const std::vector<int>& fractional,
                                               const std::vector<double>& solution,
                                               const std::vector<double>& incumbent,
                                               logger_t& log);
 
+template branch_variable_t<int> guided_diving(
+  pseudo_costs_t<int, double, branch_and_bound_mode_t::DETERMINISTIC>& pc,
+  const std::vector<int>& fractional,
+  const std::vector<double>& solution,
+  const std::vector<double>& incumbent,
+  logger_t& log);
+
 template void calculate_variable_locks(const lp_problem_t<int, double>& lp_problem,
                                        std::vector<int>& up_locks,
                                        std::vector<int>& down_locks);

cpp/src/branch_and_bound/diving_heuristics.hpp

@@ -22,15 +22,15 @@ branch_variable_t<i_t> line_search_diving(const std::vector<i_t>& fractional,
                                           const std::vector<f_t>& root_solution,
                                           logger_t& log);
 
-template <typename i_t, typename f_t>
-branch_variable_t<i_t> pseudocost_diving(pseudo_costs_t<i_t, f_t>& pc,
+template <typename i_t, typename f_t, branch_and_bound_mode_t Mode>
+branch_variable_t<i_t> pseudocost_diving(pseudo_costs_t<i_t, f_t, Mode>& pc,
                                          const std::vector<i_t>& fractional,
                                          const std::vector<f_t>& solution,
                                          const std::vector<f_t>& root_solution,
                                          logger_t& log);
 
-template <typename i_t, typename f_t>
-branch_variable_t<i_t> guided_diving(pseudo_costs_t<i_t, f_t>& pc,
+template <typename i_t, typename f_t, branch_and_bound_mode_t Mode>
+branch_variable_t<i_t> guided_diving(pseudo_costs_t<i_t, f_t, Mode>& pc,
                                      const std::vector<i_t>& fractional,
                                      const std::vector<f_t>& solution,
                                      const std::vector<f_t>& incumbent,

cpp/src/branch_and_bound/mip_node.hpp

@@ -7,6 +7,8 @@
 
 #pragma once
 
+#include <branch_and_bound/constants.hpp>
+
 #include <dual_simplex/initial_basis.hpp>
 #include <dual_simplex/types.hpp>
 
@@ -29,8 +31,6 @@ enum class node_status_t : int {
   NUMERICAL        = 5   // Encountered numerical issue when solving the LP relaxation
 };
 
-enum class rounding_direction_t : int8_t { NONE = -1, DOWN = 0, UP = 1 };
-
 inline bool inactive_status(node_status_t status)
 {
   return (status == node_status_t::FATHOMED || status == node_status_t::INTEGER_FEASIBLE ||