Populate dual informat tion when dual post solve is enabled

Author: hlinsen

cpp/src/linear_programming/solve.cu

@@ -924,6 +924,7 @@ 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()),

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