Fix bug in C API for bool parameters. Fix bug on irish-electricty

cpp/include/cuopt/logger.hpp

@@ -72,7 +72,11 @@ inline rapids_logger::logger& default_logger()
 {
   static rapids_logger::logger logger_ = [] {
     rapids_logger::logger logger_{"CUOPT", {default_sink()}};
+#if CUOPT_LOG_ACTIVE_LEVEL >= RAPIDS_LOGGER_LOG_LEVEL_INFO
+    logger_.set_pattern("%v");
+#else
     logger_.set_pattern(default_pattern());
+#endif
     logger_.set_level(default_level());
     logger_.flush_on(rapids_logger::level_enum::info);
 
@@ -90,7 +94,11 @@ inline void reset_default_logger()
 {
   default_logger().sinks().clear();
   default_logger().sinks().push_back(default_sink());
+#if CUOPT_LOG_ACTIVE_LEVEL >= RAPIDS_LOGGER_LOG_LEVEL_INFO
+  default_logger().set_pattern("%v");
+#else
   default_logger().set_pattern(default_pattern());
+#endif
   default_logger().set_level(default_level());
   default_logger().flush_on(rapids_logger::level_enum::info);
 }

cpp/src/linear_programming/cuopt_c.cpp

@@ -492,6 +492,14 @@ cuopt_int_t cuOptSetIntegerParameter(cuOptSolverSettings settings,
     static_cast<solver_settings_t<cuopt_int_t, cuopt_float_t>*>(settings);
   try {
     solver_settings->set_parameter<cuopt_int_t>(parameter_name, parameter_value);
+  } catch (const std::invalid_argument& e) {
+    // We could be trying to set a boolean parameter. Try that
+    try {
+      bool value = static_cast<bool>(parameter_value);
+      solver_settings->set_parameter<bool>(parameter_name, value);
+    } catch (const std::exception& e) {
+      return CUOPT_INVALID_ARGUMENT;
+    }
   } catch (const std::exception& e) {
     return CUOPT_INVALID_ARGUMENT;
   }
@@ -509,6 +517,14 @@ cuopt_int_t cuOptGetIntegerParameter(cuOptSolverSettings settings,
     static_cast<solver_settings_t<cuopt_int_t, cuopt_float_t>*>(settings);
   try {
     *parameter_value_ptr = solver_settings->get_parameter<cuopt_int_t>(parameter_name);
+  } catch (const std::invalid_argument& e) {
+    // We could be trying to get a boolean parameter. Try that
+    try {
+      *parameter_value_ptr =
+        static_cast<cuopt_int_t>(solver_settings->get_parameter<bool>(parameter_name));
+    } catch (const std::exception& e) {
+      return CUOPT_INVALID_ARGUMENT;
+    }
   } catch (const std::exception& e) {
     return CUOPT_INVALID_ARGUMENT;
   }

cpp/src/linear_programming/solve.cu

@@ -257,14 +257,21 @@ optimization_problem_solution_t<i_t, f_t> convert_dual_simplex_sol(
   info.solve_time            = duration;
   info.number_of_steps_taken = solution.iterations;
 
+  pdlp_termination_status_t termination_status = to_termination_status(status);
   auto sol = optimization_problem_solution_t<i_t, f_t>(final_primal_solution,
                                                        final_dual_solution,
                                                        final_reduced_cost,
                                                        problem.objective_name,
                                                        problem.var_names,
                                                        problem.row_names,
                                                        info,
-                                                       to_termination_status(status));
+                                                       termination_status);
+
+  if (termination_status != pdlp_termination_status_t::Optimal &&
+      termination_status != pdlp_termination_status_t::TimeLimit &&
+      termination_status != pdlp_termination_status_t::ConcurrentLimit) {
+    CUOPT_LOG_INFO("Dual simplex status %s", sol.get_termination_status_string().c_str());
+  }
 
   problem.handle_ptr->sync_stream();
   return sol;
@@ -295,7 +302,9 @@ std::tuple<dual_simplex::lp_solution_t<i_t, f_t>, dual_simplex::lp_status_t, f_t
 
   CUOPT_LOG_INFO("Dual simplex finished in %.2f seconds", duration.count() / 1000.0);
 
-  if (settings.concurrent_halt != nullptr) {
+  if (settings.concurrent_halt != nullptr && (status == dual_simplex::lp_status_t::OPTIMAL ||
+                                              status == dual_simplex::lp_status_t::UNBOUNDED ||
+                                              status == dual_simplex::lp_status_t::INFEASIBLE)) {
     // We finished. Tell PDLP to stop if it is still running.
     settings.concurrent_halt->store(1, std::memory_order_release);
   }
@@ -398,7 +407,8 @@ optimization_problem_solution_t<i_t, f_t> run_pdlp(detail::problem_t<i_t, f_t>&
     sol.copy_from(problem.handle_ptr, sol_crossover);
     CUOPT_LOG_INFO("Crossover status %s", sol.get_termination_status_string().c_str());
   }
-  if (crossover_info == 0 && settings.concurrent_halt != nullptr) {
+  if (settings.concurrent_halt != nullptr && crossover_info == 0 &&
+      sol.get_termination_status() == pdlp_termination_status_t::Optimal) {
     // We finished. Tell dual simplex to stop if it is still running.
     settings.concurrent_halt->store(1, std::memory_order_release);
   }
@@ -511,9 +521,6 @@ optimization_problem_solution_t<i_t, f_t> solve_lp(optimization_problem_t<i_t, f
   try {
     // Create log stream for file logging and add it to default logger
     init_logger_t log(settings.log_file, settings.log_to_console);
-#if CUOPT_LOG_ACTIVE_LEVEL >= RAPIDS_LOGGER_LOG_LEVEL_INFO
-    cuopt::default_logger().set_pattern("%v");
-#endif
 
     // Init libraies before to not include it in solve time
     // This needs to be called before pdlp is initialized

cpp/src/math_optimization/solver_settings.cu

@@ -16,6 +16,7 @@
  */
 
 #include <cuopt/linear_programming/solver_settings.hpp>
+#include <cuopt/logger.hpp>
 #include <mip/mip_constants.hpp>
 
 namespace cuopt::linear_programming {
@@ -119,7 +120,8 @@ template <typename i_t, typename f_t>
 void solver_settings_t<i_t, f_t>::set_parameter_from_string(const std::string& name,
                                                             const std::string& value)
 {
-  bool found = false;
+  bool found  = false;
+  bool output = false;
   for (auto& param : int_parameters) {
     if (param.param_name == name) {
       i_t value_int;
@@ -129,6 +131,10 @@ void solver_settings_t<i_t, f_t>::set_parameter_from_string(const std::string& n
         }
         *param.value_ptr = value_int;
         found            = true;
+        if (!output) {
+          CUOPT_LOG_INFO("Setting parameter %s to %d", name.c_str(), value_int);
+          output = true;
+        }
       } else {
         throw std::invalid_argument("Parameter " + name + " value " + value + " is not an integer");
       }
@@ -143,6 +149,10 @@ void solver_settings_t<i_t, f_t>::set_parameter_from_string(const std::string& n
         }
         *param.value_ptr = value_float;
         found            = true;
+        if (!output) {
+          CUOPT_LOG_INFO("Setting parameter %s to %e", name.c_str(), value_float);
+          output = true;
+        }
       } else {
         throw std::invalid_argument("Parameter " + name + " value " + value + " is not a float");
       }
@@ -154,6 +164,10 @@ void solver_settings_t<i_t, f_t>::set_parameter_from_string(const std::string& n
       if (string_to_bool(value, value_bool)) {
         *param.value_ptr = value_bool;
         found            = true;
+        if (!output) {
+          CUOPT_LOG_INFO("Setting parameter %s to %s", name.c_str(), value_bool ? "true" : "false");
+          output = true;
+        }
       } else {
         throw std::invalid_argument("Parameter " + name + " value " + value +
                                     " must be true or false");
@@ -164,7 +178,11 @@ void solver_settings_t<i_t, f_t>::set_parameter_from_string(const std::string& n
   for (auto& param : string_parameters) {
     if (param.param_name == name) {
       *param.value_ptr = value;
-      found            = true;
+      if (!output) {
+        CUOPT_LOG_INFO("Setting parameter %s to %s", name.c_str(), value.c_str());
+        output = true;
+      }
+      found = true;
     }
   }
   if (!found) { throw std::invalid_argument("Parameter " + name + " not found"); }
@@ -174,15 +192,20 @@ template <typename i_t, typename f_t>
 template <typename T>
 void solver_settings_t<i_t, f_t>::set_parameter(const std::string& name, T value)
 {
-  bool found = false;
+  bool found  = false;
+  bool output = false;
   if constexpr (std::is_same_v<T, i_t>) {
     for (auto& param : int_parameters) {
       if (param.param_name == name) {
         if (value < param.min_value || value > param.max_value) {
           throw std::invalid_argument("Parameter " + name + " out of range");
         }
         *param.value_ptr = value;
-        found            = true;
+        if (!output) {
+          CUOPT_LOG_INFO("Setting parameter %s to %d", name.c_str(), value);
+          output = true;
+        }
+        found = true;
       }
     }
   }
@@ -193,23 +216,35 @@ void solver_settings_t<i_t, f_t>::set_parameter(const std::string& name, T value
           throw std::invalid_argument("Parameter " + name + " out of range");
         }
         *param.value_ptr = value;
-        found            = true;
+        if (!output) {
+          CUOPT_LOG_INFO("Setting parameter %s to %e", name.c_str(), value);
+          output = true;
+        }
+        found = true;
       }
     }
   }
   if constexpr (std::is_same_v<T, bool>) {
     for (auto& param : bool_parameters) {
       if (param.param_name == name) {
         *param.value_ptr = value;
-        found            = true;
+        if (!output) {
+          CUOPT_LOG_INFO("Setting parameter %s to %s", name.c_str(), value ? "true" : "false");
+          output = true;
+        }
+        found = true;
       }
     }
   }
   if constexpr (std::is_same_v<T, std::string>) {
     for (auto& param : string_parameters) {
       if (param.param_name == name) {
         *param.value_ptr = value;
-        found            = true;
+        if (!output) {
+          CUOPT_LOG_INFO("Setting parameter %s to %s", name.c_str(), value.c_str());
+          output = true;
+        }
+        found = true;
       }
     }
   }

cpp/src/mip/solve.cu

@@ -159,9 +159,6 @@ mip_solution_t<i_t, f_t> solve_mip(optimization_problem_t<i_t, f_t>& op_problem,
   try {
     // Create log stream for file logging and add it to default logger
     init_logger_t log(settings.log_file, settings.log_to_console);
-#if CUOPT_LOG_ACTIVE_LEVEL >= RAPIDS_LOGGER_LOG_LEVEL_INFO
-    cuopt::default_logger().set_pattern("%v");
-#endif
     // Init libraies before to not include it in solve time
     // This needs to be called before pdlp is initialized
     init_handler(op_problem.get_handle_ptr());

python/cuopt/cuopt/linear_programming/solver/solver.py

@@ -54,7 +54,7 @@ def Solve(data_model, solver_settings=None, log_file=""):
     --------
     >>> from cuopt import linear_programming
     >>> from cuopt.linear_programming.solver_settings import PDLPSolverMode
-    >>> from cuopt.linear_programming.solver_parameters import *
+    >>> from cuopt.linear_programming.solver.solver_parameters import *
     >>>
     >>> data_model = linear_programming.DataModel()
     >>>
@@ -140,7 +140,7 @@ def BatchSolve(data_model_list, solver_settings=None, log_file=""):
     --------
     >>> from cuopt import linear_programming
     >>> from cuopt.linear_programming.solver_settings import PDLPSolverMode
-    >>> from cuopt.linear_programming.solver_parameters import *
+    >>> from cuopt.linear_programming.solver.solver_parameters import *
     >>> import cuopt_mps_parser
     >>>
     >>> data_models = []