Merge branch 'main' into modernize-dependencies

rgsl888prabhu · web-flow · commit b3a20a08fba5 · 2025-12-23T10:19:09.000+05:30
diff --git a/cpp/src/linear_programming/solve.cu b/cpp/src/linear_programming/solve.cu
@@ -924,17 +924,9 @@ optimization_problem_solution_t<i_t, f_t> solve_lp(
                       reduced_costs,
                       cuopt::linear_programming::problem_category_t::LP,
                       status_to_skip,
+                      settings.dual_postsolve,
                       op_problem.get_handle_ptr()->get_stream());
 
-      thrust::fill(rmm::exec_policy(op_problem.get_handle_ptr()->get_stream()),
-                   dual_solution.data(),
-                   dual_solution.data() + dual_solution.size(),
-                   std::numeric_limits<f_t>::signaling_NaN());
-      thrust::fill(rmm::exec_policy(op_problem.get_handle_ptr()->get_stream()),
-                   reduced_costs.data(),
-                   reduced_costs.data() + reduced_costs.size(),
-                   std::numeric_limits<f_t>::signaling_NaN());
-
       auto full_stats = solution.get_additional_termination_information();
 
       // Create a new solution with the full problem solution
diff --git a/cpp/src/linear_programming/utilities/problem_checking.cu b/cpp/src/linear_programming/utilities/problem_checking.cu
@@ -45,9 +45,8 @@ void problem_checking_t<i_t, f_t>::check_csr_representation(
   cuopt_expects(thrust::all_of(op_problem.get_handle_ptr()->get_thrust_policy(),
                                op_problem.get_constraint_matrix_indices().cbegin(),
                                op_problem.get_constraint_matrix_indices().cend(),
-                               [n_variables = op_problem.get_n_variables()] __device__(i_t val) {
-                                 return val >= 0 && val < n_variables;
-                               }),
+                               [n_variables = op_problem.get_n_variables()] __device__(
+                                 i_t val) -> bool { return val >= 0 && val < n_variables; }),
                 error_type_t::ValidationError,
                 "A_indices values must positive lower than the number of variables (c size).");
 }
@@ -72,7 +71,7 @@ void problem_checking_t<i_t, f_t>::check_initial_primal_representation(
                                   [lower_bounds = make_span(op_problem.get_variable_lower_bounds()),
                                    upper_bounds = make_span(op_problem.get_variable_upper_bounds()),
                                    assignment_span = make_span(primal_initial_solution),
-                                   int_tol         = 1e-8] __device__(i_t idx) {
+                                   int_tol         = 1e-8] __device__(i_t idx) -> bool {
                                     return assignment_span[idx] < lower_bounds[idx] - int_tol ||
                                            assignment_span[idx] > upper_bounds[idx] + int_tol;
                                   }),
@@ -171,13 +170,14 @@ void problem_checking_t<i_t, f_t>::check_problem_representation(
 
   // Check row type if set
   if (!op_problem.get_row_types().is_empty()) {
-    cuopt_expects(
-      thrust::all_of(op_problem.get_handle_ptr()->get_thrust_policy(),
-                     op_problem.get_row_types().cbegin(),
-                     op_problem.get_row_types().cend(),
-                     [] __device__(char val) { return val == 'E' || val == 'G' || val == 'L'; }),
-      error_type_t::ValidationError,
-      "row_types values must equal to 'E', 'G' or 'L'.");
+    cuopt_expects(thrust::all_of(op_problem.get_handle_ptr()->get_thrust_policy(),
+                                 op_problem.get_row_types().cbegin(),
+                                 op_problem.get_row_types().cend(),
+                                 [] __device__(char val) -> bool {
+                                   return val == 'E' || val == 'G' || val == 'L';
+                                 }),
+                  error_type_t::ValidationError,
+                  "row_types values must equal to 'E', 'G' or 'L'.");
 
     cuopt_expects(
       op_problem.get_row_types().size() == op_problem.get_constraint_bounds().size(),
@@ -322,19 +322,17 @@ bool problem_checking_t<i_t, f_t>::has_crossing_bounds(
     thrust::make_counting_iterator(0),
     thrust::make_counting_iterator(0) + op_problem.get_variable_upper_bounds().size(),
     [upper_bounds = make_span(op_problem.get_variable_upper_bounds()),
-     lower_bounds = make_span(op_problem.get_variable_lower_bounds())] __device__(size_t i) {
-      return upper_bounds[i] >= lower_bounds[i];
-    });
+     lower_bounds = make_span(op_problem.get_variable_lower_bounds())] __device__(size_t i)
+      -> bool { return upper_bounds[i] >= lower_bounds[i]; });
 
   // Check if all constraint bounds are valid (upper >= lower)
   bool all_constraint_bounds_valid = thrust::all_of(
     op_problem.get_handle_ptr()->get_thrust_policy(),
     thrust::make_counting_iterator(0),
     thrust::make_counting_iterator(0) + op_problem.get_constraint_upper_bounds().size(),
     [upper_bounds = make_span(op_problem.get_constraint_upper_bounds()),
-     lower_bounds = make_span(op_problem.get_constraint_lower_bounds())] __device__(size_t i) {
-      return upper_bounds[i] >= lower_bounds[i];
-    });
+     lower_bounds = make_span(op_problem.get_constraint_lower_bounds())] __device__(size_t i)
+      -> bool { return upper_bounds[i] >= lower_bounds[i]; });
 
   // Return true if any bounds are invalid (crossing)
   return !all_variable_bounds_valid || !all_constraint_bounds_valid;
diff --git a/cpp/src/mip/diversity/recombiners/bound_prop_recombiner.cuh b/cpp/src/mip/diversity/recombiners/bound_prop_recombiner.cuh
@@ -9,6 +9,7 @@
 
 #include "recombiner.cuh"
 
+#include <thrust/pair.h>
 #include <mip/local_search/rounding/constraint_prop.cuh>
 #include <mip/relaxed_lp/relaxed_lp.cuh>
 #include <mip/solution/solution.cuh>
diff --git a/cpp/src/mip/feasibility_jump/utils.cuh b/cpp/src/mip/feasibility_jump/utils.cuh
@@ -9,6 +9,7 @@
 
 #include "feasibility_jump.cuh"
 
+#include <thrust/pair.h>
 #include <cuda/atomic>
 #include <raft/core/device_span.hpp>
 #include <rmm/device_scalar.hpp>
diff --git a/cpp/src/mip/local_search/rounding/bounds_repair.cu b/cpp/src/mip/local_search/rounding/bounds_repair.cu
@@ -268,7 +268,7 @@ void bounds_repair_t<i_t, f_t>::compute_damages(problem_t<i_t, f_t>& problem, i_
                       sort_iterator + n_candidates,
                       thrust::make_zip_iterator(thrust::make_tuple(
                         candidates.bound_shift.data(), candidates.variable_index.data())),
-                      [] __device__(auto tuple1, auto tuple2) {
+                      [] __device__(auto tuple1, auto tuple2) -> bool {
                         if (thrust::get<0>(tuple1) < thrust::get<0>(tuple2)) {
                           return true;
                         } else if (thrust::get<0>(tuple1) == thrust::get<0>(tuple2) &&
@@ -291,7 +291,7 @@ i_t bounds_repair_t<i_t, f_t>::find_cutoff_index(const candidates_t<i_t, f_t>& c
     handle_ptr->get_thrust_policy(),
     iterator,
     iterator + n_candidates,
-    [best_cstr_delta, best_damage] __device__(auto tuple) {
+    [best_cstr_delta, best_damage] __device__(auto tuple) -> bool {
       if (thrust::get<0>(tuple) == best_cstr_delta && thrust::get<1>(tuple) <= best_damage) {
         return true;
       }
diff --git a/cpp/src/mip/local_search/rounding/constraint_prop.cuh b/cpp/src/mip/local_search/rounding/constraint_prop.cuh
@@ -7,6 +7,7 @@
 
 #pragma once
 
+#include <thrust/pair.h>
 #include <mip/local_search/rounding/bounds_repair.cuh>
 #include <mip/presolve/bounds_presolve.cuh>
 #include <mip/presolve/conditional_bound_strengthening.cuh>
diff --git a/cpp/src/mip/presolve/bounds_presolve.cuh b/cpp/src/mip/presolve/bounds_presolve.cuh
@@ -16,6 +16,8 @@
 
 #include <utilities/timer.hpp>
 
+#include <thrust/pair.h>
+
 #include "bounds_update_data.cuh"
 #include "utils.cuh"
 
diff --git a/cpp/src/mip/presolve/bounds_update_helpers.cuh b/cpp/src/mip/presolve/bounds_update_helpers.cuh
@@ -5,6 +5,7 @@
  */
 /* clang-format on */
 
+#include <thrust/pair.h>
 #include <mip/problem/problem.cuh>
 #include <mip/utils.cuh>
 #include "bounds_update_data.cuh"
diff --git a/cpp/src/mip/presolve/third_party_presolve.cpp b/cpp/src/mip/presolve/third_party_presolve.cpp
@@ -356,11 +356,16 @@ void set_presolve_options(papilo::Presolve<f_t>& presolver,
                           f_t absolute_tolerance,
                           f_t relative_tolerance,
                           double time_limit,
+                          bool dual_postsolve,
                           i_t num_cpu_threads)
 {
   presolver.getPresolveOptions().tlim    = time_limit;
   presolver.getPresolveOptions().threads = num_cpu_threads;  //  user setting or  0 (automatic)
   presolver.getPresolveOptions().feastol = 1e-5;
+  if (dual_postsolve) {
+    presolver.getPresolveOptions().componentsmaxint = -1;
+    presolver.getPresolveOptions().detectlindep     = 0;
+  }
 }
 
 template <typename f_t>
@@ -404,8 +409,13 @@ std::optional<third_party_presolve_result_t<i_t, f_t>> third_party_presolve_t<i_
   if (category == problem_category_t::MIP) { dual_postsolve = false; }
   papilo::Presolve<f_t> presolver;
   set_presolve_methods<f_t>(presolver, category, dual_postsolve);
-  set_presolve_options<i_t, f_t>(
-    presolver, category, absolute_tolerance, relative_tolerance, time_limit, num_cpu_threads);
+  set_presolve_options<i_t, f_t>(presolver,
+                                 category,
+                                 absolute_tolerance,
+                                 relative_tolerance,
+                                 time_limit,
+                                 dual_postsolve,
+                                 num_cpu_threads);
   set_presolve_parameters<f_t>(
     presolver, category, op_problem.get_n_constraints(), op_problem.get_n_variables());
 
@@ -446,6 +456,7 @@ void third_party_presolve_t<i_t, f_t>::undo(rmm::device_uvector<f_t>& primal_sol
                                             rmm::device_uvector<f_t>& reduced_costs,
                                             problem_category_t category,
                                             bool status_to_skip,
+                                            bool dual_postsolve,
                                             rmm::cuda_stream_view stream_view)
 {
   if (status_to_skip) { return; }
@@ -455,8 +466,12 @@ void third_party_presolve_t<i_t, f_t>::undo(rmm::device_uvector<f_t>& primal_sol
   raft::copy(dual_sol_vec_h.data(), dual_solution.data(), dual_solution.size(), stream_view);
   std::vector<f_t> reduced_costs_vec_h(reduced_costs.size());
   raft::copy(reduced_costs_vec_h.data(), reduced_costs.data(), reduced_costs.size(), stream_view);
-
   papilo::Solution<f_t> reduced_sol(primal_sol_vec_h);
+  if (dual_postsolve) {
+    reduced_sol.dual         = dual_sol_vec_h;
+    reduced_sol.reducedCosts = reduced_costs_vec_h;
+    reduced_sol.type         = papilo::SolutionType::kPrimalDual;
+  }
   papilo::Solution<f_t> full_sol;
 
   papilo::Message Msg{};
diff --git a/cpp/src/mip/presolve/third_party_presolve.hpp b/cpp/src/mip/presolve/third_party_presolve.hpp
@@ -39,6 +39,7 @@ class third_party_presolve_t {
             rmm::device_uvector<f_t>& reduced_costs,
             problem_category_t category,
             bool status_to_skip,
+            bool dual_postsolve,
             rmm::cuda_stream_view stream_view);
 };
 
diff --git a/cpp/src/mip/problem/problem.cu b/cpp/src/mip/problem/problem.cu
@@ -547,20 +547,21 @@ void problem_t<i_t, f_t>::check_problem_representation(bool check_transposed,
   cuopt_expects(thrust::all_of(handle_ptr->get_thrust_policy(),
                                thrust::make_counting_iterator<i_t>(0),
                                thrust::make_counting_iterator<i_t>(n_variables),
-                               [vars_bnd = make_span(variable_bounds)] __device__(i_t idx) {
+                               [vars_bnd = make_span(variable_bounds)] __device__(i_t idx) -> bool {
                                  auto bounds = vars_bnd[idx];
                                  return get_lower(bounds) <= get_upper(bounds);
                                }),
                 error_type_t::ValidationError,
                 "Variable bounds are invalid");
   cuopt_expects(
-    thrust::all_of(handle_ptr->get_thrust_policy(),
-                   thrust::make_counting_iterator<i_t>(0),
-                   thrust::make_counting_iterator<i_t>(n_constraints),
-                   [constraint_lower_bounds = constraint_lower_bounds.data(),
-                    constraint_upper_bounds = constraint_upper_bounds.data()] __device__(i_t idx) {
-                     return constraint_lower_bounds[idx] <= constraint_upper_bounds[idx];
-                   }),
+    thrust::all_of(
+      handle_ptr->get_thrust_policy(),
+      thrust::make_counting_iterator<i_t>(0),
+      thrust::make_counting_iterator<i_t>(n_constraints),
+      [constraint_lower_bounds = constraint_lower_bounds.data(),
+       constraint_upper_bounds = constraint_upper_bounds.data()] __device__(i_t idx) -> bool {
+        return constraint_lower_bounds[idx] <= constraint_upper_bounds[idx];
+      }),
     error_type_t::ValidationError,
     "Constraints bounds are invalid");
 
@@ -582,23 +583,21 @@ void problem_t<i_t, f_t>::check_problem_representation(bool check_transposed,
     cuopt_assert(thrust::all_of(handle_ptr->get_thrust_policy(),
                                 integer_indices.cbegin(),
                                 integer_indices.cend(),
-                                [types = variable_types.data()] __device__(i_t idx) {
+                                [types = variable_types.data()] __device__(i_t idx) -> bool {
                                   return types[idx] == var_t::INTEGER;
                                 }),
                  "The integer indices table contains references to non-integer variables.");
     cuopt_assert(thrust::all_of(handle_ptr->get_thrust_policy(),
                                 binary_indices.cbegin(),
                                 binary_indices.cend(),
-                                [bin_table = is_binary_variable.data()] __device__(i_t idx) {
-                                  return bin_table[idx];
-                                }),
+                                [bin_table = is_binary_variable.data()] __device__(
+                                  i_t idx) -> bool { return bin_table[idx]; }),
                  "The binary indices table contains references to non-binary variables.");
     cuopt_assert(thrust::all_of(handle_ptr->get_thrust_policy(),
                                 nonbinary_indices.cbegin(),
                                 nonbinary_indices.cend(),
-                                [bin_table = is_binary_variable.data()] __device__(i_t idx) {
-                                  return !bin_table[idx];
-                                }),
+                                [bin_table = is_binary_variable.data()] __device__(
+                                  i_t idx) -> bool { return !bin_table[idx]; }),
                  "The non-binary indices table contains references to binary variables.");
     cuopt_assert(
       thrust::all_of(
@@ -607,7 +606,7 @@ void problem_t<i_t, f_t>::check_problem_representation(bool check_transposed,
         thrust::make_counting_iterator<i_t>(n_variables),
         [types     = variable_types.data(),
          bin_table = is_binary_variable.data(),
-         pb_view   = view()] __device__(i_t idx) {
+         pb_view   = view()] __device__(i_t idx) -> bool {
           // ensure the binary variable tables are correct
           if (bin_table[idx]) {
             if (!thrust::binary_search(
@@ -640,7 +639,7 @@ void problem_t<i_t, f_t>::check_problem_representation(bool check_transposed,
         thrust::make_counting_iterator<i_t>(n_variables),
         [types     = variable_types.data(),
          bin_table = is_binary_variable.data(),
-         pb_view   = view()] __device__(i_t idx) {
+         pb_view   = view()] __device__(i_t idx) -> bool {
           // ensure the binary variable tables are correct
           if (bin_table[idx]) {
             if (!thrust::binary_search(
@@ -673,7 +672,7 @@ void problem_t<i_t, f_t>::check_problem_representation(bool check_transposed,
         thrust::make_counting_iterator<i_t>(n_variables),
         [types     = variable_types.data(),
          bin_table = is_binary_variable.data(),
-         pb_view   = view()] __device__(i_t idx) {
+         pb_view   = view()] __device__(i_t idx) -> bool {
           // ensure the binary variable tables are correct
           if (bin_table[idx]) {
             if (!thrust::binary_search(
@@ -1212,7 +1211,7 @@ void problem_t<i_t, f_t>::set_implied_integers(const std::vector<i_t>& implied_i
   objective_is_integral = thrust::all_of(handle_ptr->get_thrust_policy(),
                                          thrust::make_counting_iterator(0),
                                          thrust::make_counting_iterator(n_variables),
-                                         [v = view()] __device__(i_t var_idx) {
+                                         [v = view()] __device__(i_t var_idx) -> bool {
                                            if (v.objective_coefficients[var_idx] == 0) return true;
                                            return v.is_integer(v.objective_coefficients[var_idx]) &&
                                                   (v.variable_types[var_idx] == var_t::INTEGER ||
diff --git a/cpp/src/mip/problem/problem_helpers.cuh b/cpp/src/mip/problem/problem_helpers.cuh
@@ -250,7 +250,7 @@ static void check_csr_representation([[maybe_unused]] const rmm::device_uvector<
   cuopt_assert(thrust::all_of(handle_ptr->get_thrust_policy(),
                               variables.cbegin(),
                               variables.cend(),
-                              [n_variables = n_variables] __device__(i_t val) {
+                              [n_variables = n_variables] __device__(i_t val) -> bool {
                                 return val >= 0 && val < n_variables;
                               }),
                "A_indices values must positive lower than the number of variables (c size).");
@@ -267,7 +267,7 @@ static bool check_var_bounds_sanity(const detail::problem_t<i_t, f_t>& problem)
                    thrust::counting_iterator(0),
                    thrust::counting_iterator((i_t)problem.variable_bounds.size()),
                    [tolerance = problem.tolerances.presolve_absolute_tolerance,
-                    var_bnd   = make_span(problem.variable_bounds)] __device__(i_t index) {
+                    var_bnd   = make_span(problem.variable_bounds)] __device__(i_t index) -> bool {
                      auto var_bounds = var_bnd[index];
                      return (get_lower(var_bounds) > get_upper(var_bounds) + tolerance);
                    });
@@ -283,7 +283,7 @@ static bool check_constraint_bounds_sanity(const detail::problem_t<i_t, f_t>& pr
                    thrust::counting_iterator((i_t)problem.constraint_lower_bounds.size()),
                    [tolerance = problem.tolerances.presolve_absolute_tolerance,
                     lb        = make_span(problem.constraint_lower_bounds),
-                    ub        = make_span(problem.constraint_upper_bounds)] __device__(i_t index) {
+                    ub = make_span(problem.constraint_upper_bounds)] __device__(i_t index) -> bool {
                      return (lb[index] > ub[index] + tolerance);
                    });
   return !crossing_bounds_detected;
diff --git a/cpp/src/mip/solution/solution.cuh b/cpp/src/mip/solution/solution.cuh
@@ -14,6 +14,7 @@
 #include <mip/problem/problem.cuh>
 #include <mip/relaxed_lp/lp_state.cuh>
 
+#include <thrust/pair.h>
 #include <raft/util/cuda_dev_essentials.cuh>
 #include <rmm/device_scalar.hpp>
 #include <rmm/device_uvector.hpp>
diff --git a/cpp/src/mip/solve.cu b/cpp/src/mip/solve.cu
@@ -195,12 +195,12 @@ mip_solution_t<i_t, f_t> solve_mip(optimization_problem_t<i_t, f_t>& op_problem,
 
     if (!run_presolve) { CUOPT_LOG_INFO("Presolve is disabled, skipping"); }
 
+    auto constexpr const dual_postsolve = false;
     if (run_presolve) {
       detail::sort_csr(op_problem);
       // allocate not more than 10% of the time limit to presolve.
       // Note that this is not the presolve time, but the time limit for presolve.
       const double presolve_time_limit = std::min(0.1 * time_limit, 60.0);
-      const bool dual_postsolve        = false;
       presolver   = std::make_unique<detail::third_party_presolve_t<i_t, f_t>>();
       auto result = presolver->apply(op_problem,
                                      cuopt::linear_programming::problem_category_t::MIP,
@@ -246,6 +246,7 @@ mip_solution_t<i_t, f_t> solve_mip(optimization_problem_t<i_t, f_t>& op_problem,
                       reduced_costs,
                       cuopt::linear_programming::problem_category_t::MIP,
                       status_to_skip,
+                      dual_postsolve,
                       op_problem.get_handle_ptr()->get_stream());
       if (!status_to_skip) {
         thrust::fill(rmm::exec_policy(op_problem.get_handle_ptr()->get_stream()),
diff --git a/cpp/src/mip/utils.cuh b/cpp/src/mip/utils.cuh
diff --git a/cpp/src/routing/local_search/sliding_tsp.cu b/cpp/src/routing/local_search/sliding_tsp.cu
diff --git a/cpp/src/routing/local_search/vrp/fragment_kernels.cuh b/cpp/src/routing/local_search/vrp/fragment_kernels.cuh
diff --git a/cpp/src/routing/solution/route_node_map.cuh b/cpp/src/routing/solution/route_node_map.cuh
diff --git a/cpp/src/routing/utilities/check_input.cu b/cpp/src/routing/utilities/check_input.cu
diff --git a/cpp/src/routing/utilities/md_utils.hpp b/cpp/src/routing/utilities/md_utils.hpp
diff --git a/cpp/tests/linear_programming/pdlp_test.cu b/cpp/tests/linear_programming/pdlp_test.cu
