minimize code changes

Author: nguidotti

cpp/src/dual_simplex/diving_queue.hpp

@@ -41,11 +41,6 @@ struct diving_root_t {
   {
     return a.node.lower_bound > b.node.lower_bound;
   }
-
-  friend bool operator<(const diving_root_t<i_t, f_t>& a, const diving_root_t<i_t, f_t>& b)
-  {
-    return a.node.lower_bound < b.node.lower_bound;
-  }
 };
 
 // A min-heap for storing the starting nodes for the dives.
@@ -57,22 +52,14 @@ class diving_queue_t {
   std::vector<diving_root_t<i_t, f_t>> buffer;
   static constexpr i_t max_size_ = 256;
 
-  void discard_worst_node()
-  {
-    auto max_it = std::max_element(buffer.begin(), buffer.end(), std::less<>());
-    std::swap(*max_it, buffer.back());
-    buffer.pop_back();
-    std::make_heap(buffer.begin(), buffer.end(), std::greater<>());
-  }
-
  public:
   diving_queue_t() { buffer.reserve(max_size_); }
 
   void push(diving_root_t<i_t, f_t>&& node)
   {
     buffer.push_back(std::move(node));
     std::push_heap(buffer.begin(), buffer.end(), std::greater<>());
-    if (buffer.size() > max_size()) { discard_worst_node(); }
+    if (buffer.size() > max_size()) { buffer.pop_back(); }
   }
 
   void emplace(mip_node_t<i_t, f_t>&& node,
@@ -81,12 +68,11 @@ class diving_queue_t {
   {
     buffer.emplace_back(std::move(node), lower, upper);
     std::push_heap(buffer.begin(), buffer.end(), std::greater<>());
-    if (buffer.size() > max_size()) { discard_worst_node(); }
+    if (buffer.size() > max_size()) { buffer.pop_back(); }
   }
 
   diving_root_t<i_t, f_t> pop()
   {
-    assert(!buffer.empty() && "Cannot pop from an empty queue!");
     std::pop_heap(buffer.begin(), buffer.end(), std::greater<>());
     diving_root_t<i_t, f_t> node = std::move(buffer.back());
     buffer.pop_back();
@@ -95,13 +81,7 @@ class diving_queue_t {
 
   i_t size() const { return buffer.size(); }
   constexpr i_t max_size() const { return max_size_; }
-
-  const diving_root_t<i_t, f_t>& top() const
-  {
-    assert(!buffer.empty() && "Cannot get top from an empty queue!");
-    return buffer.front();
-  }
-
+  const diving_root_t<i_t, f_t>& top() const { return buffer.front(); }
   void clear() { buffer.clear(); }
 };
 

cpp/src/dual_simplex/mip_node.hpp

@@ -105,7 +105,6 @@ class mip_node_t {
     assert(branch_var >= 0);
     assert(lower.size() > branch_var);
     assert(upper.size() > branch_var);
-    assert(bounds_changed.size() > branch_var);
 
     // If the bounds have already been updated on another node,
     // skip this node as it contains a less tight bounds.

cpp/src/dual_simplex/node_presolve.cpp

@@ -252,21 +252,21 @@ bool node_presolver_t<i_t, f_t>::bound_strengthening(
   int num_ub_changed = 0;
 
   for (i_t i = 0; i < n; ++i) {
-    if (lower[i] > lower_bounds[i] + settings.primal_tol ||
-        (!std::isfinite(lower_bounds[i]) && std::isfinite(lower[i]))) {
+    if (lower[i] > problem.lower[i] + settings.primal_tol ||
+        (!std::isfinite(problem.lower[i]) && std::isfinite(lower[i]))) {
       num_lb_changed++;
-      lb_change += std::isfinite(lower_bounds[i])
-                     ? (lower[i] - lower_bounds[i]) /
-                         (1e-6 + std::max(std::abs(lower[i]), std::abs(lower_bounds[i])))
-                     : 1.0;
+      lb_change +=
+        std::isfinite(problem.lower[i])
+          ? (lower[i] - problem.lower[i]) / (1e-6 + std::max(abs(lower[i]), abs(problem.lower[i])))
+          : 1.0;
     }
-    if (upper[i] < upper_bounds[i] - settings.primal_tol ||
-        (!std::isfinite(upper_bounds[i]) && std::isfinite(upper[i]))) {
+    if (upper[i] < problem.upper[i] - settings.primal_tol ||
+        (!std::isfinite(problem.upper[i]) && std::isfinite(upper[i]))) {
       num_ub_changed++;
-      ub_change += std::isfinite(upper_bounds[i])
-                     ? (upper_bounds[i] - upper[i]) /
-                         (1e-6 + std::max(std::abs(upper_bounds[i]), std::abs(upper[i])))
-                     : 1.0;
+      ub_change +=
+        std::isfinite(problem.upper[i])
+          ? (problem.upper[i] - upper[i]) / (1e-6 + std::max(abs(problem.upper[i]), abs(upper[i])))
+          : 1.0;
     }
   }