Merge branch 'main' into update_doc_and_cusparse_check

Author: rgsl888prabhu

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

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{};

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);
 };
 

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()),

cpp/tests/linear_programming/pdlp_test.cu

@@ -210,13 +210,15 @@ TEST(pdlp_class, run_sub_mittleman)
     for (auto solver_mode : solver_mode_list) {
       auto settings             = pdlp_solver_settings_t<int, double>{};
       settings.pdlp_solver_mode = solver_mode;
+      settings.dual_postsolve   = false;
       for (auto [presolve, epsilon] : {std::pair{true, 1e-1}, std::pair{false, 1e-6}}) {
         settings.presolve = presolve;
         settings.method   = cuopt::linear_programming::method_t::PDLP;
         const raft::handle_t handle_{};
         optimization_problem_solution_t<int, double> solution =
           solve_lp(&handle_, op_problem, settings);
-        printf("running %s mode %d presolve? %d\n", name.c_str(), (int)solver_mode, presolve);
+        printf(
+          "running %s mode %d presolve? %d\n", name.c_str(), (int)solver_mode, settings.presolve);
         EXPECT_EQ((int)solution.get_termination_status(), CUOPT_TERIMINATION_STATUS_OPTIMAL);
         EXPECT_FALSE(is_incorrect_objective(
           expected_objective_value,
@@ -857,6 +859,35 @@ TEST(pdlp_class, warm_start)
   }
 }
 
+TEST(pdlp_class, dual_postsolve_size)
+{
+  const raft::handle_t handle_{};
+
+  auto path = make_path_absolute("linear_programming/afiro_original.mps");
+  cuopt::mps_parser::mps_data_model_t<int, double> op_problem =
+    cuopt::mps_parser::parse_mps<int, double>(path, true);
+
+  auto solver_settings     = pdlp_solver_settings_t<int, double>{};
+  solver_settings.method   = cuopt::linear_programming::method_t::PDLP;
+  solver_settings.presolve = true;
+
+  {
+    solver_settings.dual_postsolve = true;
+    optimization_problem_solution_t<int, double> solution =
+      solve_lp(&handle_, op_problem, solver_settings);
+    EXPECT_EQ((int)solution.get_termination_status(), CUOPT_TERIMINATION_STATUS_OPTIMAL);
+    EXPECT_EQ(solution.get_dual_solution().size(), op_problem.get_n_constraints());
+  }
+
+  {
+    solver_settings.dual_postsolve = false;
+    optimization_problem_solution_t<int, double> solution =
+      solve_lp(&handle_, op_problem, solver_settings);
+    EXPECT_EQ((int)solution.get_termination_status(), CUOPT_TERIMINATION_STATUS_OPTIMAL);
+    EXPECT_EQ(solution.get_dual_solution().size(), 0);
+  }
+}
+
 TEST(dual_simplex, afiro)
 {
   cuopt::linear_programming::pdlp_solver_settings_t<int, double> settings =