Fix infinite average pseudocost + Handle numerical issues in strong branching (#678)

If the LP relaxation when branching on a fractional variable in the strong branching do not lead to a optimal solution and the iteration limit is not reach, then the corresponding pseudocost is set to infinite. This ignore any issue in the dual simplex and cause the pseudocost average to also be infinite.

This PR properly handle numerical issues in the dual simplex in strong branching and exclude infinite pseudocost to be included in the average.

Not critical for 25.12.

Authors:
  - Nicolas L. Guidotti (https://github.com/nguidotti)

Approvers:
  - Chris Maes (https://github.com/chris-maes)

URL: #678

Author: nguidotti

cpp/src/dual_simplex/pseudo_costs.cpp

@@ -70,9 +70,10 @@ void strong_branch_helper(i_t start,
                                           iter,
                                           child_edge_norms);
 
-      f_t obj = std::numeric_limits<f_t>::infinity();
+      f_t obj = std::numeric_limits<f_t>::quiet_NaN();
       if (status == dual::status_t::DUAL_UNBOUNDED) {
         // LP was infeasible
+        obj = std::numeric_limits<f_t>::infinity();
       } else if (status == dual::status_t::OPTIMAL || status == dual::status_t::ITERATION_LIMIT) {
         obj = compute_objective(child_problem, solution.x);
       } else {
@@ -227,11 +228,17 @@ void pseudo_costs_t<i_t, f_t>::initialized(i_t& num_initialized_down,
   for (i_t j = 0; j < n; j++) {
     if (pseudo_cost_num_down[j] > 0) {
       num_initialized_down++;
-      pseudo_cost_down_avg += pseudo_cost_sum_down[j] / pseudo_cost_num_down[j];
+      if (std::isfinite(pseudo_cost_sum_down[j])) {
+        pseudo_cost_down_avg += pseudo_cost_sum_down[j] / pseudo_cost_num_down[j];
+      }
     }
+
     if (pseudo_cost_num_up[j] > 0) {
       num_initialized_up++;
-      pseudo_cost_up_avg += pseudo_cost_sum_up[j] / pseudo_cost_num_up[j];
+
+      if (std::isfinite(pseudo_cost_sum_up[j])) {
+        pseudo_cost_up_avg += pseudo_cost_sum_up[j] / pseudo_cost_num_up[j];
+      }
     }
   }
   if (num_initialized_down > 0) {
@@ -317,14 +324,16 @@ void pseudo_costs_t<i_t, f_t>::update_pseudo_costs_from_strong_branching(
   for (i_t k = 0; k < fractional.size(); k++) {
     const i_t j = fractional[k];
     for (i_t branch = 0; branch < 2; branch++) {
-      const f_t frac = branch == 0 ? root_soln[j] - std::floor(root_soln[j])
-                                   : std::ceil(root_soln[j]) - root_soln[j];
       if (branch == 0) {
         f_t change_in_obj = strong_branch_down[k];
+        if (std::isnan(change_in_obj)) { continue; }
+        f_t frac = root_soln[j] - std::floor(root_soln[j]);
         pseudo_cost_sum_down[j] += change_in_obj / frac;
         pseudo_cost_num_down[j]++;
       } else {
         f_t change_in_obj = strong_branch_up[k];
+        if (std::isnan(change_in_obj)) { continue; }
+        f_t frac = std::ceil(root_soln[j]) - root_soln[j];
         pseudo_cost_sum_up[j] += change_in_obj / frac;
         pseudo_cost_num_up[j]++;
       }