Merge branch 'main' into fix-qcqp-nonconvex-reject

Signed-off-by: YUWEN Chen <yuwchen@nvidia.com>

# Conflicts:
#	cpp/tests/socp/general_quadratic_test.cu

Author: yuwenchen95

.coderabbit.yaml

@@ -71,7 +71,7 @@ reviews:
         - Suggest documenting thread-safety, GPU requirements, numerical behavior
         - For breaking changes, recommend migration notes
 
-    - path: "cpp/include/cuopt/linear_programming/cuopt_c.h"
+    - path: "cpp/include/cuopt/mathematical_optimization/cuopt_c.h"
       instructions: |
         This is the C ABI surface. Flag ANY change to struct layout, function
         signatures, enum values, or typedef shape as potentially ABI-breaking.

.github/.coderabbit_review_guide.md

@@ -54,7 +54,7 @@ from the actual code and from `.clang-format`.
   - Private/protected member variables: trailing underscore (e.g. `error_type_`)
   - Project macros: `SCREAMING_SNAKE_CASE` with `CUOPT_` prefix (e.g. `CUOPT_EXPECTS`)
 - **File extensions**: `.hpp`/`.cpp` for C++ host code; `.cuh`/`.cu` for CUDA;
-  `.h` reserved for the C ABI surface (`cpp/include/cuopt/linear_programming/cuopt_c.h`).
+  `.h` reserved for the C ABI surface (`cpp/include/cuopt/mathematical_optimization/cuopt_c.h`).
 - **Column limit**: 100 (set in `.clang-format`).
 - **Error handling**: `throw` + `cuopt_expects(...)` / `CUOPT_EXPECTS(...)`
   macros from `cpp/include/cuopt/error.hpp`, which throw `cuopt::logic_error`.
@@ -113,7 +113,7 @@ CodeRabbit should focus on what they do *not* cover:
 
 ### C API
 
-The C API surface is intentionally narrow — `cpp/include/cuopt/linear_programming/cuopt_c.h`.
+The C API surface is intentionally narrow — `cpp/include/cuopt/mathematical_optimization/cuopt_c.h`.
 
 - **Any change to `cuopt_c.h` should be flagged for maintainer awareness** (ABI-sensitive). There is no formal ABI-versioning macro today, so phrase it as "this changes the C ABI surface — confirm this is intentional and documented."
 
@@ -149,7 +149,7 @@ Bug Patterns" section to avoid duplication.
 - Missing RAII in exception paths (cuOpt uses exceptions)
 
 **API surface**
-- Any change to `cpp/include/cuopt/linear_programming/cuopt_c.h` — flag as ABI-sensitive
+- Any change to `cpp/include/cuopt/mathematical_optimization/cuopt_c.h` — flag as ABI-sensitive
 - Python API changes without `DeprecationWarning`
 - Server API endpoint changes without deprecation path
 

.github/workflows/pr.yaml

@@ -34,6 +34,7 @@ jobs:
       - wheel-tests-cuopt-server
       - wheel-build-cuopt-sh-client
       - test-self-hosted-server
+      - pr-test-summary
     permissions:
       contents: read
     uses: rapidsai/shared-workflows/.github/workflows/pr-builder.yaml@main
@@ -623,3 +624,25 @@ jobs:
     with:
       build_type: pull-request
       script: ci/test_self_hosted_service.sh
+  pr-test-summary:
+    needs:
+      - conda-cpp-tests
+      - conda-python-tests
+      - wheel-tests-cuopt
+      - wheel-tests-cuopt-server
+      - test-self-hosted-server
+    if: always()
+    continue-on-error: true
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      pull-requests: write
+    steps:
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
+          sparse-checkout: ci/utils/pr_test_summary.py
+          sparse-checkout-cone-mode: false
+      - run: python3 ci/utils/pr_test_summary.py
+        env:
+          GH_TOKEN: ${{ github.token }}

.gitignore

@@ -12,6 +12,7 @@ __pycache__
 *.dylib
 .cache
 .vscode
+.cursor/
 *.swp
 *.pytest_cache
 *.manifest

benchmarks/linear_programming/cuopt/benchmark_helper.hpp

@@ -7,11 +7,11 @@
 
 #pragma once
 
-#include <cuopt/linear_programming/io/parser.hpp>
-#include <cuopt/linear_programming/optimization_problem_interface.hpp>
-#include <cuopt/linear_programming/pdlp/pdlp_hyper_params.cuh>
-#include <cuopt/linear_programming/pdlp/solver_solution.hpp>
-#include <cuopt/linear_programming/solve.hpp>
+#include <cuopt/mathematical_optimization/io/parser.hpp>
+#include <cuopt/mathematical_optimization/optimization_problem_interface.hpp>
+#include <cuopt/mathematical_optimization/pdlp/pdlp_hyper_params.cuh>
+#include <cuopt/mathematical_optimization/pdlp/solver_solution.hpp>
+#include <cuopt/mathematical_optimization/solve.hpp>
 
 #include <raft/sparse/detail/cusparse_wrappers.h>
 #include <raft/core/cusparse_macros.hpp>
@@ -57,9 +57,8 @@ void parse_value(std::istringstream& iss, bool& value)
   iss >> std::boolalpha >> value;
 }
 
-void fill_pdlp_hyper_params(
-  const std::string& pdlp_hyper_params_path,
-  cuopt::linear_programming::pdlp_hyper_params::pdlp_hyper_params_t& params)
+void fill_pdlp_hyper_params(const std::string& pdlp_hyper_params_path,
+                            cuopt::mathematical_optimization::pdlp::pdlp_hyper_params_t& params)
 {
   if (!std::filesystem::exists(pdlp_hyper_params_path)) {
     std::cerr << "PDLP config file path is not a valid: " << pdlp_hyper_params_path << std::endl;
@@ -205,8 +204,9 @@ std::vector<T> read_vector_from_file(const std::string& filename)
 }
 
 template <typename i_t, typename f_t>
-void write_problem_info(const cuopt::linear_programming::io::mps_data_model_t<i_t, f_t>& op_problem,
-                        const std::string& filename)
+void write_problem_info(
+  const cuopt::mathematical_optimization::io::mps_data_model_t<i_t, f_t>& op_problem,
+  const std::string& filename)
 {
   std::ofstream file(filename);
   if (!file) {
@@ -222,8 +222,9 @@ void write_problem_info(const cuopt::linear_programming::io::mps_data_model_t<i_
 }
 
 template <typename i_t, typename f_t>
-void read_problem_info(cuopt::linear_programming::optimization_problem_t<i_t, f_t>& op_problem,
-                       const std::string& filename)
+void read_problem_info(
+  cuopt::mathematical_optimization::optimization_problem_t<i_t, f_t>& op_problem,
+  const std::string& filename)
 {
   std::ifstream file(filename);
   if (!file) {
@@ -274,8 +275,8 @@ void mps_file_to_binary(const std::filesystem::path& filename)
 
   std::string p = std::string(filename);
 
-  cuopt::linear_programming::io::mps_data_model_t<int, double> op_problem =
-    cuopt::linear_programming::io::read_mps<int, double>(p);
+  cuopt::mathematical_optimization::io::mps_data_model_t<int, double> op_problem =
+    cuopt::mathematical_optimization::io::read_mps<int, double>(p);
 
   auto filename_string = filename.filename().string();
 

benchmarks/linear_programming/cuopt/initial_problem_check.hpp

@@ -30,7 +30,7 @@ struct violation {
 };
 
 bool test_constraint_and_variable_sanity(
-  const cuopt::linear_programming::io::mps_data_model_t<int, double>& op_problem,
+  const cuopt::mathematical_optimization::io::mps_data_model_t<int, double>& op_problem,
   const std::vector<double>& primal_vars,
   double abs_tol,
   double rel_tol,

benchmarks/linear_programming/cuopt/run_mip.cpp

@@ -9,11 +9,11 @@
 #include "miplib2017_bks.hpp"
 
 #include <cstdio>
-#include <cuopt/linear_programming/io/parser.hpp>
-#include <cuopt/linear_programming/mip/solver_settings.hpp>
-#include <cuopt/linear_programming/mip/solver_solution.hpp>
-#include <cuopt/linear_programming/optimization_problem_interface.hpp>
-#include <cuopt/linear_programming/solve.hpp>
+#include <cuopt/mathematical_optimization/io/parser.hpp>
+#include <cuopt/mathematical_optimization/mip/solver_settings.hpp>
+#include <cuopt/mathematical_optimization/mip/solver_solution.hpp>
+#include <cuopt/mathematical_optimization/optimization_problem_interface.hpp>
+#include <cuopt/mathematical_optimization/solve.hpp>
 #include <utilities/logger.hpp>
 
 #include <raft/core/handle.hpp>
@@ -152,7 +152,7 @@ int run_single_file(std::string file_path,
                     bool deterministic)
 {
   const raft::handle_t handle_{};
-  cuopt::linear_programming::mip_solver_settings_t<int, double> settings;
+  cuopt::mathematical_optimization::mip_solver_settings_t<int, double> settings;
   std::string base_filename = file_path.substr(file_path.find_last_of("/\\") + 1);
   // if output directory is given, set the log file
   if (write_log_file) {
@@ -167,13 +167,13 @@ int run_single_file(std::string file_path,
   }
 
   constexpr bool input_mps_strict = false;
-  cuopt::linear_programming::io::mps_data_model_t<int, double> mps_data_model;
+  cuopt::mathematical_optimization::io::mps_data_model_t<int, double> mps_data_model;
   bool parsing_failed = false;
   {
     CUOPT_LOG_INFO("running file %s on gpu : %d", base_filename.c_str(), device);
     try {
       mps_data_model =
-        cuopt::linear_programming::io::read_mps<int, double>(file_path, input_mps_strict);
+        cuopt::mathematical_optimization::io::read_mps<int, double>(file_path, input_mps_strict);
     } catch (const std::logic_error& e) {
       CUOPT_LOG_ERROR("MPS parser execption: %s", e.what());
       parsing_failed = true;
@@ -211,14 +211,14 @@ int run_single_file(std::string file_path,
   settings.determinism_mode = deterministic ? CUOPT_MODE_DETERMINISTIC : CUOPT_MODE_OPPORTUNISTIC;
   settings.tolerances.relative_tolerance = 1e-12;
   settings.tolerances.absolute_tolerance = 1e-6;
-  settings.presolver                     = cuopt::linear_programming::presolver_t::Default;
+  settings.presolver                     = cuopt::mathematical_optimization::presolver_t::Default;
   settings.reliability_branching         = reliability_branching;
   settings.clique_cuts                   = -1;
   settings.seed                          = 42;
-  cuopt::linear_programming::benchmark_info_t benchmark_info;
+  cuopt::mathematical_optimization::benchmark_info_t benchmark_info;
   settings.benchmark_info_ptr = &benchmark_info;
   auto start_run_solver       = std::chrono::high_resolution_clock::now();
-  auto solution = cuopt::linear_programming::solve_mip(&handle_, mps_data_model, settings);
+  auto solution = cuopt::mathematical_optimization::solve_mip(&handle_, mps_data_model, settings);
   CUOPT_LOG_INFO(
     "first obj: %f last improvement of best feasible: %f last improvement after recombination: %f",
     benchmark_info.objective_of_initial_population,
@@ -231,9 +231,9 @@ int run_single_file(std::string file_path,
   CUOPT_LOG_INFO("run_solver %d", duration.count());
   handle_.sync_stream();
   int sol_found  = int(solution.get_termination_status() ==
-                        cuopt::linear_programming::mip_termination_status_t::FeasibleFound ||
+                        cuopt::mathematical_optimization::mip_termination_status_t::FeasibleFound ||
                       solution.get_termination_status() ==
-                        cuopt::linear_programming::mip_termination_status_t::Optimal);
+                        cuopt::mathematical_optimization::mip_termination_status_t::Optimal);
   double obj_val = sol_found ? solution.get_objective_value() : std::numeric_limits<double>::max();
   if (sol_found) {
     CUOPT_LOG_INFO("%s: solution found, obj: %f", base_filename.c_str(), obj_val);
@@ -254,16 +254,16 @@ int run_single_file(std::string file_path,
                                 1000.0;
     std::string _status_str;
     switch (solution.get_termination_status()) {
-      case cuopt::linear_programming::mip_termination_status_t::Optimal:
+      case cuopt::mathematical_optimization::mip_termination_status_t::Optimal:
         _status_str = "Optimal";
         break;
-      case cuopt::linear_programming::mip_termination_status_t::FeasibleFound:
+      case cuopt::mathematical_optimization::mip_termination_status_t::FeasibleFound:
         _status_str = "FeasibleFound";
         break;
-      case cuopt::linear_programming::mip_termination_status_t::TimeLimit:
+      case cuopt::mathematical_optimization::mip_termination_status_t::TimeLimit:
         _status_str = "TimeLimit";
         break;
-      case cuopt::linear_programming::mip_termination_status_t::Infeasible:
+      case cuopt::mathematical_optimization::mip_termination_status_t::Infeasible:
         _status_str = "Infeasible";
         break;
       default: _status_str = "Other"; break;
@@ -281,7 +281,7 @@ int run_single_file(std::string file_path,
   int decimal_places = 2;
   double mip_gap     = solution.get_mip_gap();
   int is_optimal     = solution.get_termination_status() ==
-                       cuopt::linear_programming::mip_termination_status_t::Optimal
+                       cuopt::mathematical_optimization::mip_termination_status_t::Optimal
                          ? 1
                          : 0;
   ss << std::fixed << std::setprecision(decimal_places) << base_filename << "," << sol_found << ","

benchmarks/linear_programming/cuopt/run_pdlp.cu

@@ -5,11 +5,11 @@
  */
 /* clang-format on */
 
-#include <cuopt/linear_programming/io/parser.hpp>
-#include <cuopt/linear_programming/optimization_problem_interface.hpp>
-#include <cuopt/linear_programming/pdlp/solver_solution.hpp>
-#include <cuopt/linear_programming/solve.hpp>
-#include <cuopt/linear_programming/solver_settings.hpp>
+#include <cuopt/mathematical_optimization/io/parser.hpp>
+#include <cuopt/mathematical_optimization/optimization_problem_interface.hpp>
+#include <cuopt/mathematical_optimization/pdlp/solver_solution.hpp>
+#include <cuopt/mathematical_optimization/solve.hpp>
+#include <cuopt/mathematical_optimization/solver_settings.hpp>
 
 #include <raft/sparse/detail/cusparse_wrappers.h>
 #include <raft/core/cusparse_macros.hpp>
@@ -85,50 +85,55 @@ static void parse_arguments(argparse::ArgumentParser& program)
     .choices("default", "single", "double", "mixed");
 }
 
-static cuopt::linear_programming::presolver_t string_to_presolver(const std::string& presolver)
+static cuopt::mathematical_optimization::presolver_t string_to_presolver(
+  const std::string& presolver)
 {
-  if (presolver == "None") return cuopt::linear_programming::presolver_t::None;
-  if (presolver == "Papilo") return cuopt::linear_programming::presolver_t::Papilo;
-  if (presolver == "PSLP") return cuopt::linear_programming::presolver_t::PSLP;
-  if (presolver == "Default") return cuopt::linear_programming::presolver_t::Default;
-  return cuopt::linear_programming::presolver_t::Default;
+  if (presolver == "None") return cuopt::mathematical_optimization::presolver_t::None;
+  if (presolver == "Papilo") return cuopt::mathematical_optimization::presolver_t::Papilo;
+  if (presolver == "PSLP") return cuopt::mathematical_optimization::presolver_t::PSLP;
+  if (presolver == "Default") return cuopt::mathematical_optimization::presolver_t::Default;
+  return cuopt::mathematical_optimization::presolver_t::Default;
 }
 
-static cuopt::linear_programming::pdlp_precision_t string_to_pdlp_precision(
+static cuopt::mathematical_optimization::pdlp_precision_t string_to_pdlp_precision(
   const std::string& precision)
 {
-  if (precision == "single") return cuopt::linear_programming::pdlp_precision_t::SinglePrecision;
-  if (precision == "double") return cuopt::linear_programming::pdlp_precision_t::DoublePrecision;
-  if (precision == "mixed") return cuopt::linear_programming::pdlp_precision_t::MixedPrecision;
-  return cuopt::linear_programming::pdlp_precision_t::DefaultPrecision;
+  if (precision == "single")
+    return cuopt::mathematical_optimization::pdlp_precision_t::SinglePrecision;
+  if (precision == "double")
+    return cuopt::mathematical_optimization::pdlp_precision_t::DoublePrecision;
+  if (precision == "mixed")
+    return cuopt::mathematical_optimization::pdlp_precision_t::MixedPrecision;
+  return cuopt::mathematical_optimization::pdlp_precision_t::DefaultPrecision;
 }
 
-static cuopt::linear_programming::pdlp_solver_mode_t string_to_pdlp_solver_mode(
+static cuopt::mathematical_optimization::pdlp_solver_mode_t string_to_pdlp_solver_mode(
   const std::string& mode)
 {
-  if (mode == "Stable1") return cuopt::linear_programming::pdlp_solver_mode_t::Stable1;
+  if (mode == "Stable1") return cuopt::mathematical_optimization::pdlp_solver_mode_t::Stable1;
   if (mode == "Stable2")
-    return cuopt::linear_programming::pdlp_solver_mode_t::Stable2;
+    return cuopt::mathematical_optimization::pdlp_solver_mode_t::Stable2;
   else if (mode == "Methodical1")
-    return cuopt::linear_programming::pdlp_solver_mode_t::Methodical1;
+    return cuopt::mathematical_optimization::pdlp_solver_mode_t::Methodical1;
   else if (mode == "Fast1")
-    return cuopt::linear_programming::pdlp_solver_mode_t::Fast1;
+    return cuopt::mathematical_optimization::pdlp_solver_mode_t::Fast1;
   else if (mode == "Stable3")
-    return cuopt::linear_programming::pdlp_solver_mode_t::Stable3;
-  return cuopt::linear_programming::pdlp_solver_mode_t::Stable3;
+    return cuopt::mathematical_optimization::pdlp_solver_mode_t::Stable3;
+  return cuopt::mathematical_optimization::pdlp_solver_mode_t::Stable3;
 }
 
-static cuopt::linear_programming::pdlp_solver_settings_t<int, double> create_solver_settings(
+static cuopt::mathematical_optimization::pdlp_solver_settings_t<int, double> create_solver_settings(
   const argparse::ArgumentParser& program)
 {
-  cuopt::linear_programming::pdlp_solver_settings_t<int, double> settings{};
+  cuopt::mathematical_optimization::pdlp_solver_settings_t<int, double> settings{};
 
   settings.time_limit      = program.get<double>("--time-limit");
   settings.iteration_limit = program.get<int>("--iteration-limit");
   settings.set_optimality_tolerance(program.get<double>("--optimality-tolerance"));
   settings.pdlp_solver_mode =
     string_to_pdlp_solver_mode(program.get<std::string>("--pdlp-solver-mode"));
-  settings.method = static_cast<cuopt::linear_programming::method_t>(program.get<int>("--method"));
+  settings.method =
+    static_cast<cuopt::mathematical_optimization::method_t>(program.get<int>("--method"));
   settings.crossover      = program.get<int>("--crossover");
   settings.presolver      = string_to_presolver(program.get<std::string>("--presolver"));
   settings.pdlp_precision = string_to_pdlp_precision(program.get<std::string>("--pdlp-precision"));
@@ -148,13 +153,13 @@ static int run_solver(const argparse::ArgumentParser& program, const raft::handl
   }
 
   // Parse MPS file
-  cuopt::linear_programming::io::mps_data_model_t<int, double> op_problem =
-    cuopt::linear_programming::io::read_mps<int, double>(program.get<std::string>("--path"));
+  cuopt::mathematical_optimization::io::mps_data_model_t<int, double> op_problem =
+    cuopt::mathematical_optimization::io::read_mps<int, double>(program.get<std::string>("--path"));
 
   // Solve LP problem
   bool problem_checking = true;
-  cuopt::linear_programming::optimization_problem_solution_t<int, double> solution =
-    cuopt::linear_programming::solve_lp(
+  cuopt::mathematical_optimization::optimization_problem_solution_t<int, double> solution =
+    cuopt::mathematical_optimization::solve_lp(
       &handle_, op_problem, settings, problem_checking, use_pdlp_solver_mode);
 
   // Write solution to file if requested