diff --git a/.coderabbit.yaml b/.coderabbit.yaml index 1fe59b5032..bd3f2ae279 100644 --- a/.coderabbit.yaml +++ b/.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. diff --git a/.github/.coderabbit_review_guide.md b/.github/.coderabbit_review_guide.md index 0c6001332e..2e3a2cb0a9 100644 --- a/.github/.coderabbit_review_guide.md +++ b/.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 diff --git a/benchmarks/linear_programming/cuopt/benchmark_helper.hpp b/benchmarks/linear_programming/cuopt/benchmark_helper.hpp index 2f6de22c6b..53c1b4b594 100644 --- a/benchmarks/linear_programming/cuopt/benchmark_helper.hpp +++ b/benchmarks/linear_programming/cuopt/benchmark_helper.hpp @@ -7,11 +7,11 @@ #pragma once -#include -#include -#include -#include -#include +#include +#include +#include +#include +#include #include #include @@ -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 read_vector_from_file(const std::string& filename) } template -void write_problem_info(const cuopt::linear_programming::io::mps_data_model_t& op_problem, - const std::string& filename) +void write_problem_info( + const cuopt::mathematical_optimization::io::mps_data_model_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 -void read_problem_info(cuopt::linear_programming::optimization_problem_t& op_problem, - const std::string& filename) +void read_problem_info( + cuopt::mathematical_optimization::optimization_problem_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 op_problem = - cuopt::linear_programming::io::read_mps(p); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(p); auto filename_string = filename.filename().string(); diff --git a/benchmarks/linear_programming/cuopt/initial_problem_check.hpp b/benchmarks/linear_programming/cuopt/initial_problem_check.hpp index ac35c6f3cf..a90a6f2bc6 100644 --- a/benchmarks/linear_programming/cuopt/initial_problem_check.hpp +++ b/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& op_problem, + const cuopt::mathematical_optimization::io::mps_data_model_t& op_problem, const std::vector& primal_vars, double abs_tol, double rel_tol, diff --git a/benchmarks/linear_programming/cuopt/run_mip.cpp b/benchmarks/linear_programming/cuopt/run_mip.cpp index 274e491a16..98cd9a56d2 100644 --- a/benchmarks/linear_programming/cuopt/run_mip.cpp +++ b/benchmarks/linear_programming/cuopt/run_mip.cpp @@ -9,11 +9,11 @@ #include "miplib2017_bks.hpp" #include -#include -#include -#include -#include -#include +#include +#include +#include +#include +#include #include #include @@ -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 settings; + cuopt::mathematical_optimization::mip_solver_settings_t 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 mps_data_model; + cuopt::mathematical_optimization::io::mps_data_model_t 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(file_path, input_mps_strict); + cuopt::mathematical_optimization::io::read_mps(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::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 << "," diff --git a/benchmarks/linear_programming/cuopt/run_pdlp.cu b/benchmarks/linear_programming/cuopt/run_pdlp.cu index c88e5657df..91662b5717 100644 --- a/benchmarks/linear_programming/cuopt/run_pdlp.cu +++ b/benchmarks/linear_programming/cuopt/run_pdlp.cu @@ -5,11 +5,11 @@ */ /* clang-format on */ -#include -#include -#include -#include -#include +#include +#include +#include +#include +#include #include #include @@ -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 create_solver_settings( +static cuopt::mathematical_optimization::pdlp_solver_settings_t create_solver_settings( const argparse::ArgumentParser& program) { - cuopt::linear_programming::pdlp_solver_settings_t settings{}; + cuopt::mathematical_optimization::pdlp_solver_settings_t settings{}; settings.time_limit = program.get("--time-limit"); settings.iteration_limit = program.get("--iteration-limit"); settings.set_optimality_tolerance(program.get("--optimality-tolerance")); settings.pdlp_solver_mode = string_to_pdlp_solver_mode(program.get("--pdlp-solver-mode")); - settings.method = static_cast(program.get("--method")); + settings.method = + static_cast(program.get("--method")); settings.crossover = program.get("--crossover"); settings.presolver = string_to_presolver(program.get("--presolver")); settings.pdlp_precision = string_to_pdlp_precision(program.get("--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 op_problem = - cuopt::linear_programming::io::read_mps(program.get("--path")); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(program.get("--path")); // Solve LP problem bool problem_checking = true; - cuopt::linear_programming::optimization_problem_solution_t solution = - cuopt::linear_programming::solve_lp( + cuopt::mathematical_optimization::optimization_problem_solution_t solution = + cuopt::mathematical_optimization::solve_lp( &handle_, op_problem, settings, problem_checking, use_pdlp_solver_mode); // Write solution to file if requested diff --git a/ci/test_doc_examples.sh b/ci/test_doc_examples.sh index 4bf7243d89..325205840b 100755 --- a/ci/test_doc_examples.sh +++ b/ci/test_doc_examples.sh @@ -1,6 +1,6 @@ #!/bin/bash -# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. # SPDX-License-Identifier: Apache-2.0 # Bash strict mode @@ -470,16 +470,16 @@ find_cuopt_libraries() { if [ -z "${include_path}" ]; then # Search for cuopt_c.h local found_header - found_header=$(find "${search_dir}" -name "cuopt_c.h" -path "*/linear_programming/*" 2>/dev/null | head -1) + found_header=$(find "${search_dir}" -name "cuopt_c.h" -path "*/mathematical_optimization/*" 2>/dev/null | head -1) if [ -n "${found_header}" ]; then # Check if this is a Python package installation (contains libcuopt/include) if echo "${found_header}" | grep -q "/libcuopt/include/"; then - # Python package structure: /path/to/libcuopt/include/cuopt/linear_programming/cuopt_c.h + # Python package structure: /path/to/libcuopt/include/cuopt/mathematical_optimization/cuopt_c.h # Extract the include directory by going up 3 directories from the header file include_path=$(dirname "$(dirname "$(dirname "${found_header}")")") else - # Standard installation: /path/to/include/cuopt/linear_programming/cuopt_c.h + # Standard installation: /path/to/include/cuopt/mathematical_optimization/cuopt_c.h # Extract the include directory by going up 2 directories include_path=$(dirname "$(dirname "${found_header}")") fi diff --git a/cpp/cuopt_cli.cpp b/cpp/cuopt_cli.cpp index 37876cac7a..bf16e9e9da 100644 --- a/cpp/cuopt_cli.cpp +++ b/cpp/cuopt_cli.cpp @@ -5,13 +5,13 @@ */ /* clang-format on */ -#include -#include -#include -#include -#include -#include -#include +#include +#include +#include +#include +#include +#include +#include #include #include @@ -77,7 +77,7 @@ inline auto make_async() { return std::make_shared& settings) + const cuopt::mathematical_optimization::solver_settings_t& settings) { return cuopt::init_logger_t(settings.template get_parameter(CUOPT_LOG_FILE), settings.template get_parameter(CUOPT_LOG_TO_CONSOLE)); @@ -95,20 +95,20 @@ inline cuopt::init_logger_t dummy_logger( int run_single_file(const std::string& file_path, const std::string& initial_solution_file, bool solve_relaxation, - cuopt::linear_programming::solver_settings_t& settings) + cuopt::mathematical_optimization::solver_settings_t& settings) { cuopt::init_logger_t log(settings.get_parameter(CUOPT_LOG_FILE), settings.get_parameter(CUOPT_LOG_TO_CONSOLE)); std::string base_filename = file_path.substr(file_path.find_last_of("/\\") + 1); - cuopt::linear_programming::io::mps_data_model_t mps_data_model; + cuopt::mathematical_optimization::io::mps_data_model_t mps_data_model; bool parsing_failed = false; auto timer = cuopt::timer_t(settings.get_parameter(CUOPT_TIME_LIMIT)); { CUOPT_LOG_INFO("Reading file %s", base_filename.c_str()); try { - mps_data_model = cuopt::linear_programming::io::read(file_path); + mps_data_model = cuopt::mathematical_optimization::io::read(file_path); } catch (const std::logic_error& e) { CUOPT_LOG_ERROR("Parser exception: %s", e.what()); parsing_failed = true; @@ -123,34 +123,35 @@ int run_single_file(const std::string& file_path, // Determine memory backend and create problem using interface // Create handle only for GPU memory backend (avoid CUDA init on CPU-only hosts) - auto memory_backend = cuopt::linear_programming::get_memory_backend_type(); + auto memory_backend = cuopt::mathematical_optimization::get_memory_backend_type(); std::unique_ptr handle_ptr; - std::unique_ptr> + std::unique_ptr> problem_interface; - if (memory_backend == cuopt::linear_programming::memory_backend_t::GPU) { + if (memory_backend == cuopt::mathematical_optimization::memory_backend_t::GPU) { handle_ptr = std::make_unique(); problem_interface = - std::make_unique>( + std::make_unique>( handle_ptr.get()); } else { problem_interface = - std::make_unique>(); + std::make_unique>(); } - cuopt::linear_programming::populate_from_mps_data_model(problem_interface.get(), mps_data_model); + cuopt::mathematical_optimization::populate_from_mps_data_model(problem_interface.get(), + mps_data_model); const bool is_mip = (problem_interface->get_problem_category() == - cuopt::linear_programming::problem_category_t::MIP || + cuopt::mathematical_optimization::problem_category_t::MIP || problem_interface->get_problem_category() == - cuopt::linear_programming::problem_category_t::IP) && + cuopt::mathematical_optimization::problem_category_t::IP) && !solve_relaxation; try { auto initial_solution = initial_solution_file.empty() ? std::vector() - : cuopt::linear_programming::solution_reader_t::get_variable_values_from_sol_file( + : cuopt::mathematical_optimization::solution_reader_t::get_variable_values_from_sol_file( initial_solution_file, mps_data_model.get_variable_names()); if (is_mip) { @@ -173,10 +174,12 @@ int run_single_file(const std::string& file_path, try { if (is_mip) { auto& mip_settings = settings.get_mip_settings(); - auto solution = cuopt::linear_programming::solve_mip(problem_interface.get(), mip_settings); + auto solution = + cuopt::mathematical_optimization::solve_mip(problem_interface.get(), mip_settings); } else { auto& lp_settings = settings.get_pdlp_settings(); - auto solution = cuopt::linear_programming::solve_lp(problem_interface.get(), lp_settings); + auto solution = + cuopt::mathematical_optimization::solve_lp(problem_interface.get(), lp_settings); } } catch (const std::exception& e) { fprintf(stderr, "cuopt_cli error: %s\n", e.what()); @@ -259,12 +262,12 @@ int main(int argc, char* argv[]) for (int i = 1; i < argc; ++i) { std::string arg = argv[i]; if (arg == "--dump-hyper-params") { - cuopt::linear_programming::solver_settings_t settings; + cuopt::mathematical_optimization::solver_settings_t settings; settings.dump_parameters_to_file("/dev/stdout", true); return 0; } if (arg == "--dump-params") { - cuopt::linear_programming::solver_settings_t settings; + cuopt::mathematical_optimization::solver_settings_t settings; settings.dump_parameters_to_file("/dev/stdout", false); return 0; } @@ -327,7 +330,7 @@ int main(int argc, char* argv[]) { // Add all solver settings as arguments - cuopt::linear_programming::solver_settings_t dummy_settings; + cuopt::mathematical_optimization::solver_settings_t dummy_settings; auto int_params = dummy_settings.get_int_parameters(); auto double_params = dummy_settings.get_float_parameters(); @@ -404,7 +407,7 @@ int main(int argc, char* argv[]) const auto solve_relaxation = program.get("--relaxation"); const auto params_file = program.get("--params-file"); - cuopt::linear_programming::solver_settings_t settings; + cuopt::mathematical_optimization::solver_settings_t settings; try { if (!params_file.empty()) { settings.load_parameters_from_file(params_file); } for (auto& [key, val] : settings_strings) { @@ -417,10 +420,10 @@ int main(int argc, char* argv[]) } // Only initialize CUDA resources if using GPU memory backend (not remote execution) - auto memory_backend = cuopt::linear_programming::get_memory_backend_type(); + auto memory_backend = cuopt::mathematical_optimization::get_memory_backend_type(); std::vector memory_resources; - if (memory_backend == cuopt::linear_programming::memory_backend_t::GPU) { + if (memory_backend == cuopt::mathematical_optimization::memory_backend_t::GPU) { const int num_gpus = settings.get_parameter(CUOPT_NUM_GPUS); memory_resources.reserve(std::min(raft::device_setter::get_device_count(), num_gpus)); diff --git a/cpp/doxygen/Doxyfile b/cpp/doxygen/Doxyfile index caa2c7befd..a810fcb43d 100644 --- a/cpp/doxygen/Doxyfile +++ b/cpp/doxygen/Doxyfile @@ -772,8 +772,8 @@ WARN_LOGFILE = # Note: If this tag is empty the current directory is searched. INPUT = main_page.md \ - ../include/cuopt/linear_programming/cuopt_c.h \ - ../include/cuopt/linear_programming/constants.h \ + ../include/cuopt/mathematical_optimization/cuopt_c.h \ + ../include/cuopt/mathematical_optimization/constants.h \ /usr/include/stdint.h # This tag can be used to specify the character encoding of the source files diff --git a/cpp/include/cuopt/error.hpp b/cpp/include/cuopt/error.hpp index 9a8f62a428..95179c5ec4 100644 --- a/cpp/include/cuopt/error.hpp +++ b/cpp/include/cuopt/error.hpp @@ -6,7 +6,7 @@ /* clang-format on */ #pragma once -#include "cuopt/linear_programming/constants.h" +#include "cuopt/mathematical_optimization/constants.h" #include diff --git a/cpp/include/cuopt/linear_programming/cuopt_c.h b/cpp/include/cuopt/linear_programming/cuopt_c.h index 4426b640de..9b0e01f6e6 100644 --- a/cpp/include/cuopt/linear_programming/cuopt_c.h +++ b/cpp/include/cuopt/linear_programming/cuopt_c.h @@ -1,1062 +1,27 @@ /* clang-format off */ /* - * SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. * SPDX-License-Identifier: Apache-2.0 */ /* clang-format on */ -#ifndef CUOPT_C_API_H -#define CUOPT_C_API_H - -#include - -#include - -#ifdef __cplusplus - -extern "C" { -#endif - -/** - * @brief A ``cuOptOptimizationProblem`` object contains a representation of - * an LP, MIP, QP, or QCQP. It is created by ``cuOptCreateProblem``, - * ``cuOptCreateRangedProblem``, or the quadratic create functions. Quadratic objectives and - * quadratic objectives and constraints may be set via ``cuOptSetQuadraticObjective`` and - * added via ``cuOptAddQuadraticConstraint``. It is passed to ``cuOptSolve`` and destroyed with - * ``cuOptDestroyProblem``. - */ -typedef void* cuOptOptimizationProblem; - -/** - * @brief A ``cuOptSolverSettings`` object contains parameter settings and other information - * for an LP or MIP solve. It is created by ``cuOptCreateSolverSettings``. It is passed to - * ``cuOptSolve``. It should be destroyed using ``cuOptDestroySolverSettings``. - */ -typedef void* cuOptSolverSettings; - -/** - * @brief A ``cuOptSolution`` object contains the solution to an LP or MIP. It is created by - * ``cuOptSolve``. It should be destroyed using ``cuOptDestroySolution``. - */ -typedef void* cuOptSolution; - -#if CUOPT_INSTANTIATE_FLOAT - -/** - * @brief The type of the floating point number used by the solver. Use ``cuOptGetFloatSize`` - * to get the number of bytes in the floating point type. - */ -typedef float cuopt_float_t; - -#endif - -#if CUOPT_INSTANTIATE_DOUBLE -/** - * @brief The type of the floating point number used by the solver. Use ``cuOptGetFloatSize`` - * to get the size of the floating point type. - */ -typedef double cuopt_float_t; -#endif - -#if CUOPT_INSTANTIATE_INT32 -/** - * @brief The type of the integer number used by the solver. Use ``cuOptGetIntSize`` - * to get the size of the integer type. - */ -typedef int32_t cuopt_int_t; -#endif - -#if CUOPT_INSTANTIATE_INT64 -/** - * @brief The type of the integer number used by the solver. Use ``cuOptGetIntSize`` - * to get the size of the integer type. - */ -typedef int64_t cuopt_int_t; -#endif - -/** - * @brief Get the size of the float type. - * - * @return The size in bytes of the float type. - */ -int8_t cuOptGetFloatSize(); - -/** @brief Get the size of the integer type used by the library. - * @return The size of the integer type in bytes. - */ -int8_t cuOptGetIntSize(); - -/** - * @brief Get the version of the library. - * - * @param[out] version_major - A pointer to a cuopt_int_t that will contain the major version - * number. - * @param[out] version_minor - A pointer to a cuopt_int_t that will contain the minor version - * number. - * @param[out] version_patch - A pointer to a cuopt_int_t that will contain the patch version - * number. - * - * @return A status code indicating success or failure. - */ -cuopt_int_t cuOptGetVersion(cuopt_int_t* version_major, - cuopt_int_t* version_minor, - cuopt_int_t* version_patch); - -/** - * @brief Read an optimization problem from an MPS, QPS, or LP file. - * - * The file format is dispatched on the filename extension - * (case-insensitive): - * - ".lp", ".lp.gz", ".lp.bz2" → LP parser - * - ".mps", ".mps.gz", ".mps.bz2", ".qps", ".qps.gz", ".qps.bz2" → MPS parser - * - anything else (including no extension) is rejected. - * - * @param[in] filename - The path to the MPS, QPS, or LP file. Must be a - * non-null, non-empty C string. - * - * @param[out] problem_ptr - A non-null pointer to a cuOptOptimizationProblem. - * On output the problem will be created and initialized with the data from - * the input file. - * - * @return A status code indicating success or failure. Returns - * CUOPT_INVALID_ARGUMENT if filename is null or empty, or if problem_ptr is - * null. - */ -cuopt_int_t cuOptReadProblem(const char* filename, cuOptOptimizationProblem* problem_ptr); - -/** - * @brief Write an optimization problem to a file. - * - * @param[in] problem - The optimization problem to write. - * @param[in] filename - The path to the output file. - * @param[in] format - The file format to use. Currently only CUOPT_FILE_FORMAT_MPS is supported. - * - * @return A status code indicating success or failure. Returns CUOPT_INVALID_ARGUMENT - * if an unsupported format is specified. - */ -cuopt_int_t cuOptWriteProblem(cuOptOptimizationProblem problem, - const char* filename, - cuopt_int_t format); - -/** @brief Create an optimization problem of the form - * - * @verbatim - * minimize/maximize c^T x + offset - * subject to A x {=, <=, >=} b - * l <= x <= u - * x_i integer for some i - * @endverbatim - * - * @param[in] num_constraints The number of constraints - * @param[in] num_variables The number of variables - * @param[in] objective_sense The objective sense (CUOPT_MINIMIZE for - * minimization or CUOPT_MAXIMIZE for maximization) - * @param[in] objective_offset An offset to add to the linear objective - * @param[in] objective_coefficients A pointer to an array of type cuopt_float_t - * of size num_variables containing the coefficients of the linear objective - * @param[in] constraint_matrix_row_offsets A pointer to an array of type - * cuopt_int_t of size num_constraints + 1. constraint_matrix_row_offsets[i] is the - * index of the first non-zero element of the i-th constraint in - * constraint_matrix_column_indices and constraint_matrix_coefficent_values. This is - * part of the compressed sparse row representation of the constraint matrix - * @param[in] constraint_matrix_column_indices A pointer to an array of type - * cuopt_int_t of size constraint_matrix_row_offsets[num_constraints] containing - * the column indices of the non-zero elements of the constraint matrix. This is - * part of the compressed sparse row representation of the constraint matrix - * @param[in] constraint_matrix_coefficent_values A pointer to an array of type - * cuopt_float_t of size constraint_matrix_row_offsets[num_constraints] containing - * the values of the non-zero elements of the constraint matrix. This is - * part of the compressed sparse row representation of the constraint matrix - * @param[in] constraint_sense A pointer to an array of type char of size - * num_constraints containing the sense of the constraints (CUOPT_LESS_THAN, - * CUOPT_GREATER_THAN, or CUOPT_EQUAL) - * @param[in] rhs A pointer to an array of type cuopt_float_t of size num_constraints - * containing the right-hand side of the constraints - * @param[in] lower_bounds A pointer to an array of type cuopt_float_t of size num_variables - * containing the lower bounds of the variables - * @param[in] upper_bounds A pointer to an array of type cuopt_float_t of size num_variables - * containing the upper bounds of the variables - * @param[in] variable_types A pointer to an array of type char of size num_variables - * containing the types of the variables (CUOPT_CONTINUOUS, CUOPT_INTEGER, or - * CUOPT_SEMI_CONTINUOUS) - * @param[out] problem_ptr Pointer to store the created optimization problem - * @return CUOPT_SUCCESS if successful, CUOPT_ERROR otherwise - */ -cuopt_int_t cuOptCreateProblem(cuopt_int_t num_constraints, - cuopt_int_t num_variables, - cuopt_int_t objective_sense, - cuopt_float_t objective_offset, - const cuopt_float_t* objective_coefficients, - const cuopt_int_t* constraint_matrix_row_offsets, - const cuopt_int_t* constraint_matrix_column_indices, - const cuopt_float_t* constraint_matrix_coefficent_values, - const char* constraint_sense, - const cuopt_float_t* rhs, - const cuopt_float_t* lower_bounds, - const cuopt_float_t* upper_bounds, - const char* variable_types, - cuOptOptimizationProblem* problem_ptr); - -/** @brief Create an optimization problem of the form * - * @verbatim - * minimize/maximize c^T x + offset - * subject to bl <= A*x <= bu - * l <= x <= u - * x_i integer for some i - * @endverbatim - * - * @param[in] num_constraints - The number of constraints. - * - * @param[in] num_variables - The number of variables. - * - * @param[in] objective_sense - The objective sense (CUOPT_MINIMIZE for - * minimization or CUOPT_MAXIMIZE for maximization) - * - * @param[in] objective_offset - An offset to add to the linear objective. - * - * @param[in] objective_coefficients - A pointer to an array of type cuopt_float_t - * of size num_variables containing the coefficients of the linear objective. - * - * @param[in] constraint_matrix_row_offsets - A pointer to an array of type - * cuopt_int_t of size num_constraints + 1. constraint_matrix_row_offsets[i] is the - * index of the first non-zero element of the i-th constraint in - * constraint_matrix_column_indices and constraint_matrix_coefficients. - * - * @param[in] constraint_matrix_column_indices - A pointer to an array of type - * cuopt_int_t of size constraint_matrix_row_offsets[num_constraints] containing - * the column indices of the non-zero elements of the constraint matrix. - * - * @param[in] constraint_matrix_coefficients - A pointer to an array of type - * cuopt_float_t of size constraint_matrix_row_offsets[num_constraints] containing - * the values of the non-zero elements of the constraint matrix. - * - * @param[in] constraint_lower_bounds - A pointer to an array of type - * cuopt_float_t of size num_constraints containing the lower bounds of the constraints. - * - * @param[in] constraint_upper_bounds - A pointer to an array of type - * cuopt_float_t of size num_constraints containing the upper bounds of the constraints. - * - * @param[in] variable_lower_bounds - A pointer to an array of type - * cuopt_float_t of size num_variables containing the lower bounds of the variables. - * - * @param[in] variable_upper_bounds - A pointer to an array of type - * cuopt_float_t of size num_variables containing the upper bounds of the variables. - * - * @param[in] variable_types - A pointer to an array of type char of size - * num_variables containing the types of the variables (CUOPT_CONTINUOUS, - * CUOPT_INTEGER, or CUOPT_SEMI_CONTINUOUS). - * - * @param[out] problem_ptr - A pointer to a cuOptOptimizationProblem. - * On output the problem will be created and initialized with the provided data. - * - * @return A status code indicating success or failure. - */ -cuopt_int_t cuOptCreateRangedProblem(cuopt_int_t num_constraints, - cuopt_int_t num_variables, - cuopt_int_t objective_sense, - cuopt_float_t objective_offset, - const cuopt_float_t* objective_coefficients, - const cuopt_int_t* constraint_matrix_row_offsets, - const cuopt_int_t* constraint_matrix_column_indices, - const cuopt_float_t* constraint_matrix_coefficients, - const cuopt_float_t* constraint_lower_bounds, - const cuopt_float_t* constraint_upper_bounds, - const cuopt_float_t* variable_lower_bounds, - const cuopt_float_t* variable_upper_bounds, - const char* variable_types, - cuOptOptimizationProblem* problem_ptr); - -/** @brief Create an optimization problem of the form - * - * @note **Deprecated:** Use ``cuOptCreateProblem`` to set up the linear problem, then - * ``cuOptSetQuadraticObjective`` to specify the quadratic objective terms. - * - * @verbatim - * minimize/maximize c^T x + x^T Q x + offset - * subject to A x {=, <=, >=} b - * l ≤ x ≤ u - * @endverbatim - * - * @param[in] num_constraints The number of constraints - * @param[in] num_variables The number of variables - * @param[in] objective_sense The objective sense (CUOPT_MINIMIZE for - * minimization or CUOPT_MAXIMIZE for maximization) - * @param[in] objective_offset An offset to add to the linear objective - * @param[in] objective_coefficients A pointer to an array of type cuopt_float_t - * of size num_variables containing the coefficients of the linear objective - * @param[in] quadratic_objective_matrix_row_offsets A pointer to an array of type - * cuopt_int_t of size num_variables + 1. quadratic_objective_matrix_row_offsets[i] is - * the index of the first non-zero element of the i-th row of the quadratic objective matrix in - * quadratic_objective_matrix_column_indices and - * quadratic_objective_matrix_coefficent_values. This is part of the compressed sparse row - * representation of the quadratic objective matrix. - * @param[in] quadratic_objective_matrix_column_indices A pointer to an array of type - * cuopt_int_t of size quadratic_objective_matrix_row_offsets[num_variables] containing - * the column indices of the non-zero elements of the quadratic objective matrix. - * This is part of the compressed sparse row representation of the quadratic objective - * matrix. - * @param[in] quadratic_objective_matrix_coefficent_values A pointer to an array of type - * cuopt_float_t of size quadratic_objective_matrix_row_offsets[num_variables] containing - * the values of the non-zero elements of the quadratic objective matrix. - * @param[in] constraint_matrix_row_offsets A pointer to an array of type - * cuopt_int_t of size num_constraints + 1. constraint_matrix_row_offsets[i] is the - * index of the first non-zero element of the i-th constraint in - * constraint_matrix_column_indices and constraint_matrix_coefficent_values. This is - * part of the compressed sparse row representation of the constraint matrix - * @param[in] constraint_matrix_column_indices A pointer to an array of type - * cuopt_int_t of size constraint_matrix_row_offsets[num_constraints] containing - * the column indices of the non-zero elements of the constraint matrix. This is - * part of the compressed sparse row representation of the constraint matrix - * @param[in] constraint_matrix_coefficent_values A pointer to an array of type - * cuopt_float_t of size constraint_matrix_row_offsets[num_constraints] containing - * the values of the non-zero elements of the constraint matrix. This is - * part of the compressed sparse row representation of the constraint matrix - * @param[in] constraint_sense A pointer to an array of type char of size - * num_constraints containing the sense of the constraints (CUOPT_LESS_THAN, - * CUOPT_GREATER_THAN, or CUOPT_EQUAL) - * @param[in] rhs A pointer to an array of type cuopt_float_t of size num_constraints - * containing the right-hand side of the constraints - * @param[in] lower_bounds A pointer to an array of type cuopt_float_t of size num_variables - * containing the lower bounds of the variables - * @param[in] upper_bounds A pointer to an array of type cuopt_float_t of size num_variables - * containing the upper bounds of the variables - * @param[out] problem_ptr Pointer to store the created optimization problem - * @return CUOPT_SUCCESS if successful, CUOPT_ERROR otherwise - */ -cuopt_int_t cuOptCreateQuadraticProblem( - cuopt_int_t num_constraints, - cuopt_int_t num_variables, - cuopt_int_t objective_sense, - cuopt_float_t objective_offset, - const cuopt_float_t* objective_coefficients, - const cuopt_int_t* quadratic_objective_matrix_row_offsets, - const cuopt_int_t* quadratic_objective_matrix_column_indices, - const cuopt_float_t* quadratic_objective_matrix_coefficent_values, - const cuopt_int_t* constraint_matrix_row_offsets, - const cuopt_int_t* constraint_matrix_column_indices, - const cuopt_float_t* constraint_matrix_coefficent_values, - const char* constraint_sense, - const cuopt_float_t* rhs, - const cuopt_float_t* lower_bounds, - const cuopt_float_t* upper_bounds, - cuOptOptimizationProblem* problem_ptr); - -/** @brief Create an optimization problem of the form * - * - * @note **Deprecated:** Use ``cuOptCreateRangedProblem`` to set up the linear problem, then - * ``cuOptSetQuadraticObjective`` to specify the quadratic objective terms. - * For QCQP models, use ``cuOptAddQuadraticConstraint`` for each quadratic constraint. - * - * @verbatim - * minimize/maximize c^T x + x^T Q x + offset - * subject to bl <= A*x <= bu - * l <= x <= u - * @endverbatim - * - * @param[in] num_constraints - The number of constraints. - * - * @param[in] num_variables - The number of variables. - * - * @param[in] objective_sense - The objective sense (CUOPT_MINIMIZE for - * minimization or CUOPT_MAXIMIZE for maximization) - * - * @param[in] objective_offset - An offset to add to the linear objective. - * - * @param[in] objective_coefficients - A pointer to an array of type cuopt_float_t - * of size num_variables containing the coefficients of the linear objective. - * - * @param[in] quadratic_objective_matrix_row_offsets - A pointer to an array of type - * cuopt_int_t of size num_variables + 1. quadratic_objective_matrix_row_offsets[i] is the - * index of the first non-zero element of the i-th row of the quadratic objective matrix in - * quadratic_objective_matrix_column_indices and quadratic_objective_matrix_coefficent_values. - * This is part of the compressed sparse row representation of the quadratic objective matrix. - * - * @param[in] quadratic_objective_matrix_column_indices - A pointer to an array of type - * cuopt_int_t of size quadratic_objective_matrix_row_offsets[num_variables] containing - * the column indices of the non-zero elements of the quadratic objective matrix. - * This is part of the compressed sparse row representation of the quadratic objective matrix. - * - * @param[in] quadratic_objective_matrix_coefficent_values - A pointer to an array of type - * cuopt_float_t of size quadratic_objective_matrix_row_offsets[num_variables] containing - * the values of the non-zero elements of the quadratic objective matrix. - * - * @param[in] constraint_matrix_row_offsets - A pointer to an array of type - * cuopt_int_t of size num_constraints + 1. constraint_matrix_row_offsets[i] is the - * index of the first non-zero element of the i-th constraint in - * constraint_matrix_column_indices and constraint_matrix_coefficients. - * - * @param[in] constraint_matrix_column_indices - A pointer to an array of type - * cuopt_int_t of size constraint_matrix_row_offsets[num_constraints] containing - * the column indices of the non-zero elements of the constraint matrix. - * - * @param[in] constraint_matrix_coefficients - A pointer to an array of type - * cuopt_float_t of size constraint_matrix_row_offsets[num_constraints] containing - * the values of the non-zero elements of the constraint matrix. - * - * @param[in] constraint_lower_bounds - A pointer to an array of type - * cuopt_float_t of size num_constraints containing the lower bounds of the constraints. - * - * @param[in] constraint_upper_bounds - A pointer to an array of type - * cuopt_float_t of size num_constraints containing the upper bounds of the constraints. - * - * @param[in] variable_lower_bounds - A pointer to an array of type - * cuopt_float_t of size num_variables containing the lower bounds of the variables. - * - * @param[in] variable_upper_bounds - A pointer to an array of type - * cuopt_float_t of size num_variables containing the upper bounds of the variables. - * - * @param[out] problem_ptr - A pointer to a cuOptOptimizationProblem. - * On output the problem will be created and initialized with the provided data. - * - * @return A status code indicating success or failure. - */ -cuopt_int_t cuOptCreateQuadraticRangedProblem( - cuopt_int_t num_constraints, - cuopt_int_t num_variables, - cuopt_int_t objective_sense, - cuopt_float_t objective_offset, - const cuopt_float_t* objective_coefficients, - const cuopt_int_t* quadratic_objective_matrix_row_offsets, - const cuopt_int_t* quadratic_objective_matrix_column_indices, - const cuopt_float_t* quadratic_objective_matrix_coefficent_values, - const cuopt_int_t* constraint_matrix_row_offsets, - const cuopt_int_t* constraint_matrix_column_indices, - const cuopt_float_t* constraint_matrix_coefficients, - const cuopt_float_t* constraint_lower_bounds, - const cuopt_float_t* constraint_upper_bounds, - const cuopt_float_t* variable_lower_bounds, - const cuopt_float_t* variable_upper_bounds, - cuOptOptimizationProblem* problem_ptr); - -/** @brief Set the quadratic objective term x^T Q x on an existing problem. - * - * The matrix Q is specified in coordinate (triplet) format. This function may be called - * after ``cuOptCreateProblem`` or ``cuOptCreateRangedProblem`` to build a QP or QCQP model - * without using ``cuOptCreateQuadraticProblem`` or ``cuOptCreateQuadraticRangedProblem``. - * Each call replaces any previously set quadratic objective. Duplicate (row, col) indices - * in the triplet arrays are summed. - * - * @param[in] problem The optimization problem created by ``cuOptCreateProblem`` or - * ``cuOptCreateRangedProblem``. - * @param[in] num_entries Number of non-zero entries in Q. - * @param[in] row_index Array of length num_entries with row indices (0-based). - * @param[in] col_index Array of length num_entries with column indices (0-based). - * @param[in] coeff Array of length num_entries with matrix coefficients. - * - * @return A status code indicating success or failure. - */ -cuopt_int_t cuOptSetQuadraticObjective(cuOptOptimizationProblem problem, - cuopt_int_t num_entries, - const cuopt_int_t* row_index, - const cuopt_int_t* col_index, - const cuopt_float_t* coeff); - -/** @brief Add a quadratic constraint x^T Q x + d^T x {<=, >=} rhs to an existing problem. - * - * The quadratic matrix Q is specified in coordinate (triplet) format. The linear term d - * is specified by parallel arrays of variable indices and coefficients. This function may be - * called after ``cuOptCreateProblem`` or ``cuOptCreateRangedProblem`` to build a QCQP model. - * Each call appends one quadratic constraint. - * - * @param[in] problem The optimization problem created by ``cuOptCreateProblem`` or - * ``cuOptCreateRangedProblem``. - * @param[in] quad_num_entries Number of non-zero entries in the quadratic part. - * @param[in] row_index Array of length quad_num_entries with row indices (0-based). - * @param[in] col_index Array of length quad_num_entries with column indices (0-based). - * @param[in] coeff Array of length quad_num_entries with quadratic matrix coefficients. - * @param[in] num_lin_entries Number of non-zero entries in the linear part. - * @param[in] linear_index Array of length num_lin_entries with variable indices (0-based). - * @param[in] linear_coeff Array of length num_lin_entries with linear coefficients. - * @param[in] sense Constraint sense: ``CUOPT_LESS_THAN`` ('L') for <= or - * ``CUOPT_GREATER_THAN`` ('G') for >=. - * @param[in] rhs Right-hand side of the constraint. - * - * @return A status code indicating success or failure. - */ -cuopt_int_t cuOptAddQuadraticConstraint(cuOptOptimizationProblem problem, - cuopt_int_t quad_num_entries, - const cuopt_int_t* row_index, - const cuopt_int_t* col_index, - const cuopt_float_t* coeff, - cuopt_int_t num_lin_entries, - const cuopt_int_t* linear_index, - const cuopt_float_t* linear_coeff, - char sense, - cuopt_float_t rhs); - -/** @brief Destroy an optimization problem - * - * @param[in, out] problem_ptr - A pointer to a cuOptOptimizationProblem. On - * output the problem will be destroyed, and the pointer will be set to NULL. - */ -void cuOptDestroyProblem(cuOptOptimizationProblem* problem_ptr); - -/** @brief Get the number of constraints of an optimization problem. - * - * @param[in] problem - The optimization problem. - * - * @param[out] num_constraints_ptr - A pointer to a cuopt_int_t that will contain the - * number of constraints on output. - * - * @return A status code indicating success or failure. - */ -cuopt_int_t cuOptGetNumConstraints(cuOptOptimizationProblem problem, - cuopt_int_t* num_constraints_ptr); - -/** @brief Get the number of variables of an optimization problem. - * - * @param[in] problem - The optimization problem. - * - * @param[out] num_variables_ptr - A pointer to a cuopt_int_t that will contain the - * number of variables on output. - * - * @return A status code indicating success or failure. - */ -cuopt_int_t cuOptGetNumVariables(cuOptOptimizationProblem problem, cuopt_int_t* num_variables_ptr); - -/** @brief Get the objective sense of an optimization problem. - * - * @param[in] problem - The optimization problem. - * - * @param[out] objective_sense_ptr - A pointer to a cuopt_int_t that on output - * will contain the objective sense. - * - * @return A status code indicating success or failure. - */ -cuopt_int_t cuOptGetObjectiveSense(cuOptOptimizationProblem problem, - cuopt_int_t* objective_sense_ptr); - -/** @brief Get the objective offset of an optimization problem. - * - * @param[in] problem - The optimization problem. - * - * @param[out] objective_offset_ptr - A pointer to a cuopt_float_t that on output - * will contain the objective offset. - * - * @return A status code indicating success or failure. - */ -cuopt_int_t cuOptGetObjectiveOffset(cuOptOptimizationProblem problem, - cuopt_float_t* objective_offset_ptr); - -/** @brief Get the objective coefficients of an optimization problem. - * - * @param[in] problem - The optimization problem. - * - * @param[out] objective_coefficients_ptr - A pointer to an array of type - * cuopt_float_t of size num_variables that on output will contain the objective - * coefficients. - * - * @return A status code indicating success or failure. - */ -cuopt_int_t cuOptGetObjectiveCoefficients(cuOptOptimizationProblem problem, - cuopt_float_t* objective_coefficients_ptr); - -/** @brief Get the number of non-zero elements in the constraint matrix of an - * optimization problem. - * - * @param[in] problem - The optimization problem. - * - * @param[out] num_non_zeros_ptr - A pointer to a cuopt_int_t that on output - * will contain the number of non-zeros in the constraint matrix. - * - * @return A status code indicating success or failure. - */ -cuopt_int_t cuOptGetNumNonZeros(cuOptOptimizationProblem problem, cuopt_int_t* num_non_zeros_ptr); - -/** @brief Get the constraint matrix of an optimization problem in compressed sparse row format. - * - * @param[in] problem - The optimization problem. - * - * @param[out] constraint_matrix_row_offsets_ptr - A pointer to an array of type - * cuopt_int_t of size num_constraints + 1 that on output will contain the row - * offsets of the constraint matrix. - * - * @param[out] constraint_matrix_column_indices_ptr - A pointer to an array of type - * cuopt_int_t of size equal to the number of nonzeros that on output will contain the - * column indices of the non-zero entries of the constraint matrix. - * - * @param[out] constraint_matrix_coefficients_ptr - A pointer to an array of type - * cuopt_float_t of size equal to the number of nonzeros that on output will contain the - * coefficients of the non-zero entries of the constraint matrix. - * - * @return A status code indicating success or failure. - */ -cuopt_int_t cuOptGetConstraintMatrix(cuOptOptimizationProblem problem, - cuopt_int_t* constraint_matrix_row_offsets_ptr, - cuopt_int_t* constraint_matrix_column_indices_ptr, - cuopt_float_t* constraint_matrix_coefficients_ptr); - -/** @brief Get the constraint sense of an optimization problem. - * - * @param[in] problem - The optimization problem. - * - * @param[out] constraint_sense_ptr - A pointer to an array of type char of size - * num_constraints that on output will contain the sense of the constraints. - * - * @return A status code indicating success or failure. - */ -cuopt_int_t cuOptGetConstraintSense(cuOptOptimizationProblem problem, char* constraint_sense_ptr); - -/** @brief Get the right-hand side of an optimization problem. - * - * @param[in] problem - The optimization problem. - * - * @param[out] rhs_ptr - A pointer to an array of type cuopt_float_t of size - * num_constraints that on output will contain the right-hand side of the constraints. - * - * @return A status code indicating success or failure. - */ -cuopt_int_t cuOptGetConstraintRightHandSide(cuOptOptimizationProblem problem, - cuopt_float_t* rhs_ptr); - -/** @brief Get the lower bounds of an optimization problem. - * - * @param[in] problem - The optimization problem. - * - * @param[out] lower_bounds_ptr - A pointer to an array of type cuopt_float_t of size - * num_constraints that on output will contain the lower bounds of the constraints. - * - * @return A status code indicating success or failure. - */ -cuopt_int_t cuOptGetConstraintLowerBounds(cuOptOptimizationProblem problem, - cuopt_float_t* lower_bounds_ptr); - -/** @brief Get the upper bounds of an optimization problem. - * - * @param[in] problem - The optimization problem. - * - * @param[out] upper_bounds_ptr - A pointer to an array of type cuopt_float_t of size - * num_constraints that on output will contain the upper bounds of the constraints. - * - * @return A status code indicating success or failure. - */ -cuopt_int_t cuOptGetConstraintUpperBounds(cuOptOptimizationProblem problem, - cuopt_float_t* upper_bounds_ptr); - -/** @brief Get the lower bounds of an optimization problem. - * - * @param[in] problem - The optimization problem. - * - * @param[out] lower_bounds_ptr - A pointer to an array of type cuopt_float_t of size - * num_variables that on output will contain the lower bounds of the variables. - * - * @return A status code indicating success or failure. - */ -cuopt_int_t cuOptGetVariableLowerBounds(cuOptOptimizationProblem problem, - cuopt_float_t* lower_bounds_ptr); - -/** @brief Get the upper bounds of an optimization problem. - * - * @param[in] problem - The optimization problem. - * - * @param[out] upper_bounds_ptr - A pointer to an array of type cuopt_float_t of size - * num_variables that on output will contain the upper bounds of the variables. - * - * @return A status code indicating success or failure. - */ -cuopt_int_t cuOptGetVariableUpperBounds(cuOptOptimizationProblem problem, - cuopt_float_t* upper_bounds_ptr); - -/** @brief Get the variable types of an optimization problem. - * - * @param[in] problem - The optimization problem. - * - * @param[out] variable_types_ptr - A pointer to an array of type char of size - * num_variables that on output will contain the types of the variables - * (CUOPT_CONTINUOUS, CUOPT_INTEGER, or CUOPT_SEMI_CONTINUOUS). - * - * @return A status code indicating success or failure. - */ -cuopt_int_t cuOptGetVariableTypes(cuOptOptimizationProblem problem, char* variable_types_ptr); - -/** @brief Create a solver settings object. - * - * @param[out] settings_ptr - A pointer to a cuOptSolverSettings object. On output - * the solver settings will be created and initialized. - * - * @return A status code indicating success or failure. - */ -cuopt_int_t cuOptCreateSolverSettings(cuOptSolverSettings* settings_ptr); - -/** @brief Destroy a solver settings object. - * - * @param[in, out] settings_ptr - A pointer to a cuOptSolverSettings object. On output - * the solver settings will be destroyed and the pointer will be set to NULL. - */ -void cuOptDestroySolverSettings(cuOptSolverSettings* settings_ptr); - -/** @brief Set a parameter of a solver settings object. - * - * @param[in] settings - The solver settings object. - * - * @param[in] parameter_name - The name of the parameter to set. - * - * @param[in] parameter_value - The value of the parameter to set. - */ -cuopt_int_t cuOptSetParameter(cuOptSolverSettings settings, - const char* parameter_name, - const char* parameter_value); - -/** @brief Get a parameter of a solver settings object. - * - * @param[in] settings - The solver settings object. - * - * @param[in] parameter_name - The name of the parameter to get. - * - * @param[in] parameter_value_size - The size of the parameter value buffer. - * - * @param[out] parameter_value - A pointer to an array of characters that on output will contain the - * value of the parameter. - * - * @return A status code indicating success or failure. - */ -cuopt_int_t cuOptGetParameter(cuOptSolverSettings settings, - const char* parameter_name, - cuopt_int_t parameter_value_size, - char* parameter_value); - -/** @brief Set an integer parameter of a solver settings object. - * - * @param[in] settings - The solver settings object. - * - * @param[in] parameter_name - The name of the parameter to set. - * - * @param[in] parameter_value - The value of the parameter to set. - * - * @return A status code indicating success or failure. - */ -cuopt_int_t cuOptSetIntegerParameter(cuOptSolverSettings settings, - const char* parameter_name, - cuopt_int_t parameter_value); - -/** @brief Get an integer parameter of a solver settings object. - * - * @param[in] settings - The solver settings object. - * - * @param[in] parameter_name - The name of the parameter to get. - * - * @param[out] parameter_value - A pointer to a cuopt_int_t that on output will contain the - * value of the parameter. - * - * @return A status code indicating success or failure. - */ -cuopt_int_t cuOptGetIntegerParameter(cuOptSolverSettings settings, - const char* parameter_name, - cuopt_int_t* parameter_value); - -/** @brief Set a float parameter of a solver settings object. - * - * @param[in] settings - The solver settings object. - * - * @param[in] parameter_name - The name of the parameter to set. - * - * @param[in] parameter_value - The value of the parameter to set. - * - * @return A status code indicating success or failure. - */ -cuopt_int_t cuOptSetFloatParameter(cuOptSolverSettings settings, - const char* parameter_name, - cuopt_float_t parameter_value); - -/** @brief Get a float parameter of a solver settings object. - * - * @param[in] settings - The solver settings object. - * - * @param[in] parameter_name - The name of the parameter to get. - * - * @param[out] parameter_value - A pointer to a cuopt_float_t that on output will contain the - * value of the parameter. - * - * @return A status code indicating success or failure. - */ -cuopt_int_t cuOptGetFloatParameter(cuOptSolverSettings settings, - const char* parameter_name, - cuopt_float_t* parameter_value); - -/** - * @brief Type of callback for receiving incumbent MIP solutions with user context. - * - * @param[in] solution - Pointer to incumbent solution values. - * The allocated array for solution pointer must be at least the number of variables in the original - * problem. - * @param[in] objective_value - Pointer to incumbent objective value. - * @param[in] solution_bound - Pointer to current solution (dual/user) bound. - * @param[in] user_data - Pointer to user data. - * @note All pointer arguments (solution, objective_value, solution_bound, user_data) refer to host - * memory and are only valid during the callback invocation. Do not pass device/GPU pointers. - * Copy any data you need to keep after the callback returns. - */ -typedef void (*cuOptMIPGetSolutionCallback)(const cuopt_float_t* solution, - const cuopt_float_t* objective_value, - const cuopt_float_t* solution_bound, - void* user_data); - -/** - * @brief Type of callback for injecting MIP solutions with user context. - * - * @param[out] solution - Pointer to solution values to set. - * The allocated array for solution pointer must be at least the number of variables in the original - * problem. - * @param[out] objective_value - Pointer to objective value to set. - * @param[in] solution_bound - Pointer to current solution (dual/user) bound. - * @param[in] user_data - Pointer to user data. - * @note All pointer arguments (solution, objective_value, solution_bound, user_data) refer to host - * memory and are only valid during the callback invocation. Do not pass device/GPU pointers. - * Copy any data you need to keep after the callback returns. - */ -typedef void (*cuOptMIPSetSolutionCallback)(cuopt_float_t* solution, - cuopt_float_t* objective_value, - const cuopt_float_t* solution_bound, - void* user_data); - -/** - * @brief Register a callback to receive incumbent MIP solutions. - * - * @param[in] settings - The solver settings object. - * @param[in] callback - Callback function to receive incumbent solutions. - * @param[in] user_data - User-defined pointer passed through to the callback. - * It will be forwarded to ``cuOptMIPGetSolutionCallback`` when invoked. - * @note The callback arguments refer to host memory and are only valid during the callback - * invocation. Do not pass device/GPU pointers. Copy any data you need to keep after the callback - * returns. - * - * @return A status code indicating success or failure. - */ -cuopt_int_t cuOptSetMIPGetSolutionCallback(cuOptSolverSettings settings, - cuOptMIPGetSolutionCallback callback, - void* user_data); - -/** - * @brief Register a callback to inject MIP solutions. - * - * @param[in] settings - The solver settings object. - * @param[in] callback - Callback function to inject solutions. - * @param[in] user_data - User-defined pointer passed through to the callback. - * It will be forwarded to ``cuOptMIPSetSolutionCallback`` when invoked. - * @note Registering a set-solution callback disables presolve. - * @note The callback arguments refer to host memory and are only valid during the callback - * invocation. Do not pass device/GPU pointers. Copy any data you need to keep after the callback - * returns. - * - * @return A status code indicating success or failure. - */ -cuopt_int_t cuOptSetMIPSetSolutionCallback(cuOptSolverSettings settings, - cuOptMIPSetSolutionCallback callback, - void* user_data); -/** - * @brief Set the initial primal solution for an LP solve. - * - * @note This function is only supported for PDLP. - * - * @param[in] settings - The solver settings object. - * @param[in] primal_solution - A pointer to an array of type cuopt_float_t - * of size num_variables containing the initial primal values. - * @param[in] num_variables - The number of variables (size of the primal_solution array). - * - * @note All pointer arguments (primal_solution) refer to host memory. - * @return A status code indicating success or failure. - */ -cuopt_int_t cuOptSetInitialPrimalSolution(cuOptSolverSettings settings, - const cuopt_float_t* primal_solution, - cuopt_int_t num_variables); - -/** - * @brief Set the initial dual solution for an LP solve. - * - * @note This function is only supported for PDLP. - * - * @param[in] settings - The solver settings object. - * @param[in] dual_solution - A pointer to an array of type cuopt_float_t - * of size num_constraints containing the initial dual values. - * @param[in] num_constraints - The number of constraints (size of the dual_solution array). - * - * @note All pointer arguments (dual_solution) refer to host memory. - * @return A status code indicating success or failure. - */ -cuopt_int_t cuOptSetInitialDualSolution(cuOptSolverSettings settings, - const cuopt_float_t* dual_solution, - cuopt_int_t num_constraints); - -/** - * @brief Add an initial solution (MIP start) for MIP solving. - * - * This function can be called multiple times to add multiple MIP starts. - * The solver will use these as starting points for the MIP search. - * - * @param[in] settings - The solver settings object. - * @param[in] solution - A pointer to an array of type cuopt_float_t - * of size num_variables containing the solution values. - * @param[in] num_variables - The number of variables (size of the solution array). - * - * @attention Currently unsupported with presolve on. - * - * @note All pointer arguments (solution) refer to host memory. - * @return A status code indicating success or failure. - */ -cuopt_int_t cuOptAddMIPStart(cuOptSolverSettings settings, - const cuopt_float_t* solution, - cuopt_int_t num_variables); - -/** @brief Check if an optimization problem is a mixed integer programming problem. - * - * @param[in] problem - The optimization problem. - * - * @param[out] is_mip_ptr - A pointer to a cuopt_int_t that on output will be 0 if the problem - * contains only continuous variables, or 1 if the problem contains integer variables. - * - * @return A status code indicating success or failure. - */ -cuopt_int_t cuOptIsMIP(cuOptOptimizationProblem problem, cuopt_int_t* is_mip_ptr); - -/** @brief Solve an optimization problem. - * - * @param[in] problem - The optimization problem. - * - * @param[in] settings - The solver settings. - * - * @param[out] solution_ptr - A pointer to a cuOptSolution object. On output - * the solution will be created. - * - * @return A status code indicating success or failure. - */ -cuopt_int_t cuOptSolve(cuOptOptimizationProblem problem, - cuOptSolverSettings settings, - cuOptSolution* solution_ptr); - -/** @brief Destroy a solution object. - * - * @param[in, out] solution_ptr - A pointer to a cuOptSolution object. On output - * the solution will be destroyed and the pointer will be set to NULL. - */ -void cuOptDestroySolution(cuOptSolution* solution_ptr); - -/** @brief Get the termination reason of an optimization problem. - * - * @param[in] solution - The solution object. - * - * @param[out] termination_reason_ptr - A pointer to a cuopt_int_t that on output will contain the - * termination reason. - * - * @return A status code indicating success or failure. - */ -cuopt_int_t cuOptGetTerminationStatus(cuOptSolution solution, cuopt_int_t* termination_status_ptr); - -/* @brief Get the error status of a solution object. - * - * @param[in] solution - The solution object. - * - * @param[out] error_status_ptr - A pointer to a cuopt_int_t that on output will contain the - * error status. - * - * @return A status code indicating success or failure. - */ -cuopt_int_t cuOptGetErrorStatus(cuOptSolution solution, cuopt_int_t* error_status_ptr); - -/* @brief Get the error string of a solution object. - * - * @param[in] solution - The solution object. - * - * @param[out] error_string_ptr - A pointer to a char that on output will contain the - * error string. - * - * @param[in] error_string_size - Size of the char buffer/ - * - * @return A status code indicating success or failure. - */ -cuopt_int_t cuOptGetErrorString(cuOptSolution solution, - char* error_string_ptr, - cuopt_int_t error_string_size); - -/* @brief Get the solution of an optimization problem. - * - * @param[in] solution - The solution object. - * - * @param[in, out] solution_values - A pointer to an array of type cuopt_float_t of size - * num_variables that will contain the solution values. - * - * @return A status code indicating success or failure. - */ -cuopt_int_t cuOptGetPrimalSolution(cuOptSolution solution, cuopt_float_t* solution_values); - -/** @brief Get the objective value of an optimization problem. - * - * @param[in] solution - The solution object. - * - * @param[in,out] objective_value_ptr - A pointer to a cuopt_float_t that will contain the objective - * value. - * - * @return A status code indicating success or failure. - */ -cuopt_int_t cuOptGetObjectiveValue(cuOptSolution solution, cuopt_float_t* objective_value_ptr); - -/** @brief Get the solve time of an optimization problem. - * - * @param[in] solution - The solution object. - * - * @param[in,out] solve_time_ptr - A pointer to a cuopt_float_t that will contain the solve time. - * - * @return A status code indicating success or failure. - */ -cuopt_int_t cuOptGetSolveTime(cuOptSolution solution, cuopt_float_t* solve_time_ptr); - -/** @brief Get the relative MIP gap of an optimization problem. - * - * @param[in] solution - The solution object. - * - * @param[in, out] mip_gap_ptr - A pointer to a cuopt_float_t that will contain the relative MIP - * gap. - * - * @return A status code indicating success or failure. - */ -cuopt_int_t cuOptGetMIPGap(cuOptSolution solution, cuopt_float_t* mip_gap_ptr); - -/** @brief Get the solution bound of an optimization problem. - * - * @param[in] solution - The solution object. - * - * @param[in, out] solution_bound_ptr - A pointer to a cuopt_float_t that will contain the solution - * bound. - * - * @return A status code indicating success or failure. - */ -cuopt_int_t cuOptGetSolutionBound(cuOptSolution solution, cuopt_float_t* solution_bound_ptr); - -/** @brief Get the dual solution of an optimization problem. - * - * @param[in] solution - The solution object. - * - * @param[in, out] dual_solution_ptr - A pointer to an array of type cuopt_float_t of size - * num_constraints that will contain the dual solution. - * - * @return A status code indicating success or failure. - */ -cuopt_int_t cuOptGetDualSolution(cuOptSolution solution, cuopt_float_t* dual_solution_ptr); - -/** @brief Get the dual objective value of an optimization problem. - * - * @param[in] solution - The solution object. +/* + * Compatibility forwarder. * - * @param[in, out] dual_objective_value_ptr - A pointer to a cuopt_float_t that will contain the - * dual objective value. + * The cuOpt C API header moved to as part of + * the cuopt::linear_programming -> cuopt::mathematical_optimization rename. The C API + * itself is unchanged (same symbols, C linkage) -- only the include path moved. * - * @return A status code indicating success or failure. + * This shim keeps the legacy include path working. Please update includes to + * ; this forwarder may be removed in a future + * release. */ -cuopt_int_t cuOptGetDualObjectiveValue(cuOptSolution solution, - cuopt_float_t* dual_objective_value_ptr); +#ifndef CUOPT_LINEAR_PROGRAMMING_C_API_COMPAT_H +#define CUOPT_LINEAR_PROGRAMMING_C_API_COMPAT_H -/** @brief Get the reduced costs of an optimization problem. - * - * @param[in] solution - The solution object. - * - * @param[in,out] reduced_cost_ptr - A pointer to an array of type cuopt_float_t of size - * num_variables that will contain the reduced cost. - * - * @return A status code indicating success or failure. - */ -cuopt_int_t cuOptGetReducedCosts(cuOptSolution solution, cuopt_float_t* reduced_cost_ptr); +#pragma message( \ + " is deprecated; include instead.") -#ifdef __cplusplus -} -#endif +#include -#endif // CUOPT_C_API_H +#endif /* CUOPT_LINEAR_PROGRAMMING_C_API_COMPAT_H */ diff --git a/cpp/include/cuopt/linear_programming/backend_selection.hpp b/cpp/include/cuopt/mathematical_optimization/backend_selection.hpp similarity index 94% rename from cpp/include/cuopt/linear_programming/backend_selection.hpp rename to cpp/include/cuopt/mathematical_optimization/backend_selection.hpp index 26bcd942a3..4f684e3756 100644 --- a/cpp/include/cuopt/linear_programming/backend_selection.hpp +++ b/cpp/include/cuopt/mathematical_optimization/backend_selection.hpp @@ -7,7 +7,7 @@ #pragma once -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { /** * @brief Enum for execution mode (local vs remote solve) @@ -61,4 +61,4 @@ bool use_cpu_memory_for_local(); */ memory_backend_t get_memory_backend_type(); -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/include/cuopt/linear_programming/constants.h b/cpp/include/cuopt/mathematical_optimization/constants.h similarity index 100% rename from cpp/include/cuopt/linear_programming/constants.h rename to cpp/include/cuopt/mathematical_optimization/constants.h diff --git a/cpp/include/cuopt/linear_programming/cpu_optimization_problem.hpp b/cpp/include/cuopt/mathematical_optimization/cpu_optimization_problem.hpp similarity index 98% rename from cpp/include/cuopt/linear_programming/cpu_optimization_problem.hpp rename to cpp/include/cuopt/mathematical_optimization/cpu_optimization_problem.hpp index 76258ec0bd..fd4c50fa75 100644 --- a/cpp/include/cuopt/linear_programming/cpu_optimization_problem.hpp +++ b/cpp/include/cuopt/mathematical_optimization/cpu_optimization_problem.hpp @@ -7,7 +7,7 @@ #pragma once -#include +#include #include #include @@ -18,7 +18,7 @@ #include #include -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { // Forward declarations template @@ -226,4 +226,4 @@ class cpu_optimization_problem_t : public optimization_problem_interface_t row_names_{}; }; -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/include/cuopt/linear_programming/cpu_optimization_problem_solution.hpp b/cpp/include/cuopt/mathematical_optimization/cpu_optimization_problem_solution.hpp similarity index 96% rename from cpp/include/cuopt/linear_programming/cpu_optimization_problem_solution.hpp rename to cpp/include/cuopt/mathematical_optimization/cpu_optimization_problem_solution.hpp index e86dd0341a..b4e5edec44 100644 --- a/cpp/include/cuopt/linear_programming/cpu_optimization_problem_solution.hpp +++ b/cpp/include/cuopt/mathematical_optimization/cpu_optimization_problem_solution.hpp @@ -7,18 +7,18 @@ #pragma once -#include -#include -#include -#include -#include -#include +#include +#include +#include +#include +#include +#include #include #include -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { /** * @brief CPU-backed LP solution (uses std::vector instead of rmm::device_uvector) @@ -389,4 +389,4 @@ class cpu_mip_solution_t : public mip_solution_interface_t { i_t num_simplex_iterations_; }; -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/include/cuopt/linear_programming/cpu_pdlp_warm_start_data.hpp b/cpp/include/cuopt/mathematical_optimization/cpu_pdlp_warm_start_data.hpp similarity index 96% rename from cpp/include/cuopt/linear_programming/cpu_pdlp_warm_start_data.hpp rename to cpp/include/cuopt/mathematical_optimization/cpu_pdlp_warm_start_data.hpp index 51e98275ed..9cf4740c96 100644 --- a/cpp/include/cuopt/linear_programming/cpu_pdlp_warm_start_data.hpp +++ b/cpp/include/cuopt/mathematical_optimization/cpu_pdlp_warm_start_data.hpp @@ -7,10 +7,10 @@ #pragma once -#include +#include #include -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { // CPU version of pdlp_warm_start_data_t using std::vector for remote execution template @@ -118,4 +118,4 @@ template pdlp_warm_start_data_t convert_to_gpu_warmstart( const cpu_pdlp_warm_start_data_t& cpu_data, rmm::cuda_stream_view stream); -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/include/cuopt/linear_programming/csr_matrix_utils.hpp b/cpp/include/cuopt/mathematical_optimization/csr_matrix_utils.hpp similarity index 97% rename from cpp/include/cuopt/linear_programming/csr_matrix_utils.hpp rename to cpp/include/cuopt/mathematical_optimization/csr_matrix_utils.hpp index cd93dc96fe..9615d828dc 100644 --- a/cpp/include/cuopt/linear_programming/csr_matrix_utils.hpp +++ b/cpp/include/cuopt/mathematical_optimization/csr_matrix_utils.hpp @@ -12,7 +12,7 @@ #include #include -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { /** * @brief Compare two CSR matrices under row and column permutations (host-side). @@ -85,4 +85,4 @@ inline bool csr_matrices_equivalent_with_permutation_host(const std::vector return true; } -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/include/cuopt/mathematical_optimization/cuopt_c.h b/cpp/include/cuopt/mathematical_optimization/cuopt_c.h new file mode 100644 index 0000000000..4589859aa4 --- /dev/null +++ b/cpp/include/cuopt/mathematical_optimization/cuopt_c.h @@ -0,0 +1,1062 @@ +/* clang-format off */ +/* + * SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + */ +/* clang-format on */ + +#ifndef CUOPT_C_API_H +#define CUOPT_C_API_H + +#include + +#include + +#ifdef __cplusplus + +extern "C" { +#endif + +/** + * @brief A ``cuOptOptimizationProblem`` object contains a representation of + * an LP, MIP, QP, or QCQP. It is created by ``cuOptCreateProblem``, + * ``cuOptCreateRangedProblem``, or the quadratic create functions. Quadratic objectives and + * quadratic objectives and constraints may be set via ``cuOptSetQuadraticObjective`` and + * added via ``cuOptAddQuadraticConstraint``. It is passed to ``cuOptSolve`` and destroyed with + * ``cuOptDestroyProblem``. + */ +typedef void* cuOptOptimizationProblem; + +/** + * @brief A ``cuOptSolverSettings`` object contains parameter settings and other information + * for an LP or MIP solve. It is created by ``cuOptCreateSolverSettings``. It is passed to + * ``cuOptSolve``. It should be destroyed using ``cuOptDestroySolverSettings``. + */ +typedef void* cuOptSolverSettings; + +/** + * @brief A ``cuOptSolution`` object contains the solution to an LP or MIP. It is created by + * ``cuOptSolve``. It should be destroyed using ``cuOptDestroySolution``. + */ +typedef void* cuOptSolution; + +#if CUOPT_INSTANTIATE_FLOAT + +/** + * @brief The type of the floating point number used by the solver. Use ``cuOptGetFloatSize`` + * to get the number of bytes in the floating point type. + */ +typedef float cuopt_float_t; + +#endif + +#if CUOPT_INSTANTIATE_DOUBLE +/** + * @brief The type of the floating point number used by the solver. Use ``cuOptGetFloatSize`` + * to get the size of the floating point type. + */ +typedef double cuopt_float_t; +#endif + +#if CUOPT_INSTANTIATE_INT32 +/** + * @brief The type of the integer number used by the solver. Use ``cuOptGetIntSize`` + * to get the size of the integer type. + */ +typedef int32_t cuopt_int_t; +#endif + +#if CUOPT_INSTANTIATE_INT64 +/** + * @brief The type of the integer number used by the solver. Use ``cuOptGetIntSize`` + * to get the size of the integer type. + */ +typedef int64_t cuopt_int_t; +#endif + +/** + * @brief Get the size of the float type. + * + * @return The size in bytes of the float type. + */ +int8_t cuOptGetFloatSize(); + +/** @brief Get the size of the integer type used by the library. + * @return The size of the integer type in bytes. + */ +int8_t cuOptGetIntSize(); + +/** + * @brief Get the version of the library. + * + * @param[out] version_major - A pointer to a cuopt_int_t that will contain the major version + * number. + * @param[out] version_minor - A pointer to a cuopt_int_t that will contain the minor version + * number. + * @param[out] version_patch - A pointer to a cuopt_int_t that will contain the patch version + * number. + * + * @return A status code indicating success or failure. + */ +cuopt_int_t cuOptGetVersion(cuopt_int_t* version_major, + cuopt_int_t* version_minor, + cuopt_int_t* version_patch); + +/** + * @brief Read an optimization problem from an MPS, QPS, or LP file. + * + * The file format is dispatched on the filename extension + * (case-insensitive): + * - ".lp", ".lp.gz", ".lp.bz2" → LP parser + * - ".mps", ".mps.gz", ".mps.bz2", ".qps", ".qps.gz", ".qps.bz2" → MPS parser + * - anything else (including no extension) is rejected. + * + * @param[in] filename - The path to the MPS, QPS, or LP file. Must be a + * non-null, non-empty C string. + * + * @param[out] problem_ptr - A non-null pointer to a cuOptOptimizationProblem. + * On output the problem will be created and initialized with the data from + * the input file. + * + * @return A status code indicating success or failure. Returns + * CUOPT_INVALID_ARGUMENT if filename is null or empty, or if problem_ptr is + * null. + */ +cuopt_int_t cuOptReadProblem(const char* filename, cuOptOptimizationProblem* problem_ptr); + +/** + * @brief Write an optimization problem to a file. + * + * @param[in] problem - The optimization problem to write. + * @param[in] filename - The path to the output file. + * @param[in] format - The file format to use. Currently only CUOPT_FILE_FORMAT_MPS is supported. + * + * @return A status code indicating success or failure. Returns CUOPT_INVALID_ARGUMENT + * if an unsupported format is specified. + */ +cuopt_int_t cuOptWriteProblem(cuOptOptimizationProblem problem, + const char* filename, + cuopt_int_t format); + +/** @brief Create an optimization problem of the form + * + * @verbatim + * minimize/maximize c^T x + offset + * subject to A x {=, <=, >=} b + * l <= x <= u + * x_i integer for some i + * @endverbatim + * + * @param[in] num_constraints The number of constraints + * @param[in] num_variables The number of variables + * @param[in] objective_sense The objective sense (CUOPT_MINIMIZE for + * minimization or CUOPT_MAXIMIZE for maximization) + * @param[in] objective_offset An offset to add to the linear objective + * @param[in] objective_coefficients A pointer to an array of type cuopt_float_t + * of size num_variables containing the coefficients of the linear objective + * @param[in] constraint_matrix_row_offsets A pointer to an array of type + * cuopt_int_t of size num_constraints + 1. constraint_matrix_row_offsets[i] is the + * index of the first non-zero element of the i-th constraint in + * constraint_matrix_column_indices and constraint_matrix_coefficent_values. This is + * part of the compressed sparse row representation of the constraint matrix + * @param[in] constraint_matrix_column_indices A pointer to an array of type + * cuopt_int_t of size constraint_matrix_row_offsets[num_constraints] containing + * the column indices of the non-zero elements of the constraint matrix. This is + * part of the compressed sparse row representation of the constraint matrix + * @param[in] constraint_matrix_coefficent_values A pointer to an array of type + * cuopt_float_t of size constraint_matrix_row_offsets[num_constraints] containing + * the values of the non-zero elements of the constraint matrix. This is + * part of the compressed sparse row representation of the constraint matrix + * @param[in] constraint_sense A pointer to an array of type char of size + * num_constraints containing the sense of the constraints (CUOPT_LESS_THAN, + * CUOPT_GREATER_THAN, or CUOPT_EQUAL) + * @param[in] rhs A pointer to an array of type cuopt_float_t of size num_constraints + * containing the right-hand side of the constraints + * @param[in] lower_bounds A pointer to an array of type cuopt_float_t of size num_variables + * containing the lower bounds of the variables + * @param[in] upper_bounds A pointer to an array of type cuopt_float_t of size num_variables + * containing the upper bounds of the variables + * @param[in] variable_types A pointer to an array of type char of size num_variables + * containing the types of the variables (CUOPT_CONTINUOUS, CUOPT_INTEGER, or + * CUOPT_SEMI_CONTINUOUS) + * @param[out] problem_ptr Pointer to store the created optimization problem + * @return CUOPT_SUCCESS if successful, CUOPT_ERROR otherwise + */ +cuopt_int_t cuOptCreateProblem(cuopt_int_t num_constraints, + cuopt_int_t num_variables, + cuopt_int_t objective_sense, + cuopt_float_t objective_offset, + const cuopt_float_t* objective_coefficients, + const cuopt_int_t* constraint_matrix_row_offsets, + const cuopt_int_t* constraint_matrix_column_indices, + const cuopt_float_t* constraint_matrix_coefficent_values, + const char* constraint_sense, + const cuopt_float_t* rhs, + const cuopt_float_t* lower_bounds, + const cuopt_float_t* upper_bounds, + const char* variable_types, + cuOptOptimizationProblem* problem_ptr); + +/** @brief Create an optimization problem of the form * + * @verbatim + * minimize/maximize c^T x + offset + * subject to bl <= A*x <= bu + * l <= x <= u + * x_i integer for some i + * @endverbatim + * + * @param[in] num_constraints - The number of constraints. + * + * @param[in] num_variables - The number of variables. + * + * @param[in] objective_sense - The objective sense (CUOPT_MINIMIZE for + * minimization or CUOPT_MAXIMIZE for maximization) + * + * @param[in] objective_offset - An offset to add to the linear objective. + * + * @param[in] objective_coefficients - A pointer to an array of type cuopt_float_t + * of size num_variables containing the coefficients of the linear objective. + * + * @param[in] constraint_matrix_row_offsets - A pointer to an array of type + * cuopt_int_t of size num_constraints + 1. constraint_matrix_row_offsets[i] is the + * index of the first non-zero element of the i-th constraint in + * constraint_matrix_column_indices and constraint_matrix_coefficients. + * + * @param[in] constraint_matrix_column_indices - A pointer to an array of type + * cuopt_int_t of size constraint_matrix_row_offsets[num_constraints] containing + * the column indices of the non-zero elements of the constraint matrix. + * + * @param[in] constraint_matrix_coefficients - A pointer to an array of type + * cuopt_float_t of size constraint_matrix_row_offsets[num_constraints] containing + * the values of the non-zero elements of the constraint matrix. + * + * @param[in] constraint_lower_bounds - A pointer to an array of type + * cuopt_float_t of size num_constraints containing the lower bounds of the constraints. + * + * @param[in] constraint_upper_bounds - A pointer to an array of type + * cuopt_float_t of size num_constraints containing the upper bounds of the constraints. + * + * @param[in] variable_lower_bounds - A pointer to an array of type + * cuopt_float_t of size num_variables containing the lower bounds of the variables. + * + * @param[in] variable_upper_bounds - A pointer to an array of type + * cuopt_float_t of size num_variables containing the upper bounds of the variables. + * + * @param[in] variable_types - A pointer to an array of type char of size + * num_variables containing the types of the variables (CUOPT_CONTINUOUS, + * CUOPT_INTEGER, or CUOPT_SEMI_CONTINUOUS). + * + * @param[out] problem_ptr - A pointer to a cuOptOptimizationProblem. + * On output the problem will be created and initialized with the provided data. + * + * @return A status code indicating success or failure. + */ +cuopt_int_t cuOptCreateRangedProblem(cuopt_int_t num_constraints, + cuopt_int_t num_variables, + cuopt_int_t objective_sense, + cuopt_float_t objective_offset, + const cuopt_float_t* objective_coefficients, + const cuopt_int_t* constraint_matrix_row_offsets, + const cuopt_int_t* constraint_matrix_column_indices, + const cuopt_float_t* constraint_matrix_coefficients, + const cuopt_float_t* constraint_lower_bounds, + const cuopt_float_t* constraint_upper_bounds, + const cuopt_float_t* variable_lower_bounds, + const cuopt_float_t* variable_upper_bounds, + const char* variable_types, + cuOptOptimizationProblem* problem_ptr); + +/** @brief Create an optimization problem of the form + * + * @note **Deprecated:** Use ``cuOptCreateProblem`` to set up the linear problem, then + * ``cuOptSetQuadraticObjective`` to specify the quadratic objective terms. + * + * @verbatim + * minimize/maximize c^T x + x^T Q x + offset + * subject to A x {=, <=, >=} b + * l ≤ x ≤ u + * @endverbatim + * + * @param[in] num_constraints The number of constraints + * @param[in] num_variables The number of variables + * @param[in] objective_sense The objective sense (CUOPT_MINIMIZE for + * minimization or CUOPT_MAXIMIZE for maximization) + * @param[in] objective_offset An offset to add to the linear objective + * @param[in] objective_coefficients A pointer to an array of type cuopt_float_t + * of size num_variables containing the coefficients of the linear objective + * @param[in] quadratic_objective_matrix_row_offsets A pointer to an array of type + * cuopt_int_t of size num_variables + 1. quadratic_objective_matrix_row_offsets[i] is + * the index of the first non-zero element of the i-th row of the quadratic objective matrix in + * quadratic_objective_matrix_column_indices and + * quadratic_objective_matrix_coefficent_values. This is part of the compressed sparse row + * representation of the quadratic objective matrix. + * @param[in] quadratic_objective_matrix_column_indices A pointer to an array of type + * cuopt_int_t of size quadratic_objective_matrix_row_offsets[num_variables] containing + * the column indices of the non-zero elements of the quadratic objective matrix. + * This is part of the compressed sparse row representation of the quadratic objective + * matrix. + * @param[in] quadratic_objective_matrix_coefficent_values A pointer to an array of type + * cuopt_float_t of size quadratic_objective_matrix_row_offsets[num_variables] containing + * the values of the non-zero elements of the quadratic objective matrix. + * @param[in] constraint_matrix_row_offsets A pointer to an array of type + * cuopt_int_t of size num_constraints + 1. constraint_matrix_row_offsets[i] is the + * index of the first non-zero element of the i-th constraint in + * constraint_matrix_column_indices and constraint_matrix_coefficent_values. This is + * part of the compressed sparse row representation of the constraint matrix + * @param[in] constraint_matrix_column_indices A pointer to an array of type + * cuopt_int_t of size constraint_matrix_row_offsets[num_constraints] containing + * the column indices of the non-zero elements of the constraint matrix. This is + * part of the compressed sparse row representation of the constraint matrix + * @param[in] constraint_matrix_coefficent_values A pointer to an array of type + * cuopt_float_t of size constraint_matrix_row_offsets[num_constraints] containing + * the values of the non-zero elements of the constraint matrix. This is + * part of the compressed sparse row representation of the constraint matrix + * @param[in] constraint_sense A pointer to an array of type char of size + * num_constraints containing the sense of the constraints (CUOPT_LESS_THAN, + * CUOPT_GREATER_THAN, or CUOPT_EQUAL) + * @param[in] rhs A pointer to an array of type cuopt_float_t of size num_constraints + * containing the right-hand side of the constraints + * @param[in] lower_bounds A pointer to an array of type cuopt_float_t of size num_variables + * containing the lower bounds of the variables + * @param[in] upper_bounds A pointer to an array of type cuopt_float_t of size num_variables + * containing the upper bounds of the variables + * @param[out] problem_ptr Pointer to store the created optimization problem + * @return CUOPT_SUCCESS if successful, CUOPT_ERROR otherwise + */ +cuopt_int_t cuOptCreateQuadraticProblem( + cuopt_int_t num_constraints, + cuopt_int_t num_variables, + cuopt_int_t objective_sense, + cuopt_float_t objective_offset, + const cuopt_float_t* objective_coefficients, + const cuopt_int_t* quadratic_objective_matrix_row_offsets, + const cuopt_int_t* quadratic_objective_matrix_column_indices, + const cuopt_float_t* quadratic_objective_matrix_coefficent_values, + const cuopt_int_t* constraint_matrix_row_offsets, + const cuopt_int_t* constraint_matrix_column_indices, + const cuopt_float_t* constraint_matrix_coefficent_values, + const char* constraint_sense, + const cuopt_float_t* rhs, + const cuopt_float_t* lower_bounds, + const cuopt_float_t* upper_bounds, + cuOptOptimizationProblem* problem_ptr); + +/** @brief Create an optimization problem of the form * + * + * @note **Deprecated:** Use ``cuOptCreateRangedProblem`` to set up the linear problem, then + * ``cuOptSetQuadraticObjective`` to specify the quadratic objective terms. + * For QCQP models, use ``cuOptAddQuadraticConstraint`` for each quadratic constraint. + * + * @verbatim + * minimize/maximize c^T x + x^T Q x + offset + * subject to bl <= A*x <= bu + * l <= x <= u + * @endverbatim + * + * @param[in] num_constraints - The number of constraints. + * + * @param[in] num_variables - The number of variables. + * + * @param[in] objective_sense - The objective sense (CUOPT_MINIMIZE for + * minimization or CUOPT_MAXIMIZE for maximization) + * + * @param[in] objective_offset - An offset to add to the linear objective. + * + * @param[in] objective_coefficients - A pointer to an array of type cuopt_float_t + * of size num_variables containing the coefficients of the linear objective. + * + * @param[in] quadratic_objective_matrix_row_offsets - A pointer to an array of type + * cuopt_int_t of size num_variables + 1. quadratic_objective_matrix_row_offsets[i] is the + * index of the first non-zero element of the i-th row of the quadratic objective matrix in + * quadratic_objective_matrix_column_indices and quadratic_objective_matrix_coefficent_values. + * This is part of the compressed sparse row representation of the quadratic objective matrix. + * + * @param[in] quadratic_objective_matrix_column_indices - A pointer to an array of type + * cuopt_int_t of size quadratic_objective_matrix_row_offsets[num_variables] containing + * the column indices of the non-zero elements of the quadratic objective matrix. + * This is part of the compressed sparse row representation of the quadratic objective matrix. + * + * @param[in] quadratic_objective_matrix_coefficent_values - A pointer to an array of type + * cuopt_float_t of size quadratic_objective_matrix_row_offsets[num_variables] containing + * the values of the non-zero elements of the quadratic objective matrix. + * + * @param[in] constraint_matrix_row_offsets - A pointer to an array of type + * cuopt_int_t of size num_constraints + 1. constraint_matrix_row_offsets[i] is the + * index of the first non-zero element of the i-th constraint in + * constraint_matrix_column_indices and constraint_matrix_coefficients. + * + * @param[in] constraint_matrix_column_indices - A pointer to an array of type + * cuopt_int_t of size constraint_matrix_row_offsets[num_constraints] containing + * the column indices of the non-zero elements of the constraint matrix. + * + * @param[in] constraint_matrix_coefficients - A pointer to an array of type + * cuopt_float_t of size constraint_matrix_row_offsets[num_constraints] containing + * the values of the non-zero elements of the constraint matrix. + * + * @param[in] constraint_lower_bounds - A pointer to an array of type + * cuopt_float_t of size num_constraints containing the lower bounds of the constraints. + * + * @param[in] constraint_upper_bounds - A pointer to an array of type + * cuopt_float_t of size num_constraints containing the upper bounds of the constraints. + * + * @param[in] variable_lower_bounds - A pointer to an array of type + * cuopt_float_t of size num_variables containing the lower bounds of the variables. + * + * @param[in] variable_upper_bounds - A pointer to an array of type + * cuopt_float_t of size num_variables containing the upper bounds of the variables. + * + * @param[out] problem_ptr - A pointer to a cuOptOptimizationProblem. + * On output the problem will be created and initialized with the provided data. + * + * @return A status code indicating success or failure. + */ +cuopt_int_t cuOptCreateQuadraticRangedProblem( + cuopt_int_t num_constraints, + cuopt_int_t num_variables, + cuopt_int_t objective_sense, + cuopt_float_t objective_offset, + const cuopt_float_t* objective_coefficients, + const cuopt_int_t* quadratic_objective_matrix_row_offsets, + const cuopt_int_t* quadratic_objective_matrix_column_indices, + const cuopt_float_t* quadratic_objective_matrix_coefficent_values, + const cuopt_int_t* constraint_matrix_row_offsets, + const cuopt_int_t* constraint_matrix_column_indices, + const cuopt_float_t* constraint_matrix_coefficients, + const cuopt_float_t* constraint_lower_bounds, + const cuopt_float_t* constraint_upper_bounds, + const cuopt_float_t* variable_lower_bounds, + const cuopt_float_t* variable_upper_bounds, + cuOptOptimizationProblem* problem_ptr); + +/** @brief Set the quadratic objective term x^T Q x on an existing problem. + * + * The matrix Q is specified in coordinate (triplet) format. This function may be called + * after ``cuOptCreateProblem`` or ``cuOptCreateRangedProblem`` to build a QP or QCQP model + * without using ``cuOptCreateQuadraticProblem`` or ``cuOptCreateQuadraticRangedProblem``. + * Each call replaces any previously set quadratic objective. Duplicate (row, col) indices + * in the triplet arrays are summed. + * + * @param[in] problem The optimization problem created by ``cuOptCreateProblem`` or + * ``cuOptCreateRangedProblem``. + * @param[in] num_entries Number of non-zero entries in Q. + * @param[in] row_index Array of length num_entries with row indices (0-based). + * @param[in] col_index Array of length num_entries with column indices (0-based). + * @param[in] coeff Array of length num_entries with matrix coefficients. + * + * @return A status code indicating success or failure. + */ +cuopt_int_t cuOptSetQuadraticObjective(cuOptOptimizationProblem problem, + cuopt_int_t num_entries, + const cuopt_int_t* row_index, + const cuopt_int_t* col_index, + const cuopt_float_t* coeff); + +/** @brief Add a quadratic constraint x^T Q x + d^T x {<=, >=} rhs to an existing problem. + * + * The quadratic matrix Q is specified in coordinate (triplet) format. The linear term d + * is specified by parallel arrays of variable indices and coefficients. This function may be + * called after ``cuOptCreateProblem`` or ``cuOptCreateRangedProblem`` to build a QCQP model. + * Each call appends one quadratic constraint. + * + * @param[in] problem The optimization problem created by ``cuOptCreateProblem`` or + * ``cuOptCreateRangedProblem``. + * @param[in] quad_num_entries Number of non-zero entries in the quadratic part. + * @param[in] row_index Array of length quad_num_entries with row indices (0-based). + * @param[in] col_index Array of length quad_num_entries with column indices (0-based). + * @param[in] coeff Array of length quad_num_entries with quadratic matrix coefficients. + * @param[in] num_lin_entries Number of non-zero entries in the linear part. + * @param[in] linear_index Array of length num_lin_entries with variable indices (0-based). + * @param[in] linear_coeff Array of length num_lin_entries with linear coefficients. + * @param[in] sense Constraint sense: ``CUOPT_LESS_THAN`` ('L') for <= or + * ``CUOPT_GREATER_THAN`` ('G') for >=. + * @param[in] rhs Right-hand side of the constraint. + * + * @return A status code indicating success or failure. + */ +cuopt_int_t cuOptAddQuadraticConstraint(cuOptOptimizationProblem problem, + cuopt_int_t quad_num_entries, + const cuopt_int_t* row_index, + const cuopt_int_t* col_index, + const cuopt_float_t* coeff, + cuopt_int_t num_lin_entries, + const cuopt_int_t* linear_index, + const cuopt_float_t* linear_coeff, + char sense, + cuopt_float_t rhs); + +/** @brief Destroy an optimization problem + * + * @param[in, out] problem_ptr - A pointer to a cuOptOptimizationProblem. On + * output the problem will be destroyed, and the pointer will be set to NULL. + */ +void cuOptDestroyProblem(cuOptOptimizationProblem* problem_ptr); + +/** @brief Get the number of constraints of an optimization problem. + * + * @param[in] problem - The optimization problem. + * + * @param[out] num_constraints_ptr - A pointer to a cuopt_int_t that will contain the + * number of constraints on output. + * + * @return A status code indicating success or failure. + */ +cuopt_int_t cuOptGetNumConstraints(cuOptOptimizationProblem problem, + cuopt_int_t* num_constraints_ptr); + +/** @brief Get the number of variables of an optimization problem. + * + * @param[in] problem - The optimization problem. + * + * @param[out] num_variables_ptr - A pointer to a cuopt_int_t that will contain the + * number of variables on output. + * + * @return A status code indicating success or failure. + */ +cuopt_int_t cuOptGetNumVariables(cuOptOptimizationProblem problem, cuopt_int_t* num_variables_ptr); + +/** @brief Get the objective sense of an optimization problem. + * + * @param[in] problem - The optimization problem. + * + * @param[out] objective_sense_ptr - A pointer to a cuopt_int_t that on output + * will contain the objective sense. + * + * @return A status code indicating success or failure. + */ +cuopt_int_t cuOptGetObjectiveSense(cuOptOptimizationProblem problem, + cuopt_int_t* objective_sense_ptr); + +/** @brief Get the objective offset of an optimization problem. + * + * @param[in] problem - The optimization problem. + * + * @param[out] objective_offset_ptr - A pointer to a cuopt_float_t that on output + * will contain the objective offset. + * + * @return A status code indicating success or failure. + */ +cuopt_int_t cuOptGetObjectiveOffset(cuOptOptimizationProblem problem, + cuopt_float_t* objective_offset_ptr); + +/** @brief Get the objective coefficients of an optimization problem. + * + * @param[in] problem - The optimization problem. + * + * @param[out] objective_coefficients_ptr - A pointer to an array of type + * cuopt_float_t of size num_variables that on output will contain the objective + * coefficients. + * + * @return A status code indicating success or failure. + */ +cuopt_int_t cuOptGetObjectiveCoefficients(cuOptOptimizationProblem problem, + cuopt_float_t* objective_coefficients_ptr); + +/** @brief Get the number of non-zero elements in the constraint matrix of an + * optimization problem. + * + * @param[in] problem - The optimization problem. + * + * @param[out] num_non_zeros_ptr - A pointer to a cuopt_int_t that on output + * will contain the number of non-zeros in the constraint matrix. + * + * @return A status code indicating success or failure. + */ +cuopt_int_t cuOptGetNumNonZeros(cuOptOptimizationProblem problem, cuopt_int_t* num_non_zeros_ptr); + +/** @brief Get the constraint matrix of an optimization problem in compressed sparse row format. + * + * @param[in] problem - The optimization problem. + * + * @param[out] constraint_matrix_row_offsets_ptr - A pointer to an array of type + * cuopt_int_t of size num_constraints + 1 that on output will contain the row + * offsets of the constraint matrix. + * + * @param[out] constraint_matrix_column_indices_ptr - A pointer to an array of type + * cuopt_int_t of size equal to the number of nonzeros that on output will contain the + * column indices of the non-zero entries of the constraint matrix. + * + * @param[out] constraint_matrix_coefficients_ptr - A pointer to an array of type + * cuopt_float_t of size equal to the number of nonzeros that on output will contain the + * coefficients of the non-zero entries of the constraint matrix. + * + * @return A status code indicating success or failure. + */ +cuopt_int_t cuOptGetConstraintMatrix(cuOptOptimizationProblem problem, + cuopt_int_t* constraint_matrix_row_offsets_ptr, + cuopt_int_t* constraint_matrix_column_indices_ptr, + cuopt_float_t* constraint_matrix_coefficients_ptr); + +/** @brief Get the constraint sense of an optimization problem. + * + * @param[in] problem - The optimization problem. + * + * @param[out] constraint_sense_ptr - A pointer to an array of type char of size + * num_constraints that on output will contain the sense of the constraints. + * + * @return A status code indicating success or failure. + */ +cuopt_int_t cuOptGetConstraintSense(cuOptOptimizationProblem problem, char* constraint_sense_ptr); + +/** @brief Get the right-hand side of an optimization problem. + * + * @param[in] problem - The optimization problem. + * + * @param[out] rhs_ptr - A pointer to an array of type cuopt_float_t of size + * num_constraints that on output will contain the right-hand side of the constraints. + * + * @return A status code indicating success or failure. + */ +cuopt_int_t cuOptGetConstraintRightHandSide(cuOptOptimizationProblem problem, + cuopt_float_t* rhs_ptr); + +/** @brief Get the lower bounds of an optimization problem. + * + * @param[in] problem - The optimization problem. + * + * @param[out] lower_bounds_ptr - A pointer to an array of type cuopt_float_t of size + * num_constraints that on output will contain the lower bounds of the constraints. + * + * @return A status code indicating success or failure. + */ +cuopt_int_t cuOptGetConstraintLowerBounds(cuOptOptimizationProblem problem, + cuopt_float_t* lower_bounds_ptr); + +/** @brief Get the upper bounds of an optimization problem. + * + * @param[in] problem - The optimization problem. + * + * @param[out] upper_bounds_ptr - A pointer to an array of type cuopt_float_t of size + * num_constraints that on output will contain the upper bounds of the constraints. + * + * @return A status code indicating success or failure. + */ +cuopt_int_t cuOptGetConstraintUpperBounds(cuOptOptimizationProblem problem, + cuopt_float_t* upper_bounds_ptr); + +/** @brief Get the lower bounds of an optimization problem. + * + * @param[in] problem - The optimization problem. + * + * @param[out] lower_bounds_ptr - A pointer to an array of type cuopt_float_t of size + * num_variables that on output will contain the lower bounds of the variables. + * + * @return A status code indicating success or failure. + */ +cuopt_int_t cuOptGetVariableLowerBounds(cuOptOptimizationProblem problem, + cuopt_float_t* lower_bounds_ptr); + +/** @brief Get the upper bounds of an optimization problem. + * + * @param[in] problem - The optimization problem. + * + * @param[out] upper_bounds_ptr - A pointer to an array of type cuopt_float_t of size + * num_variables that on output will contain the upper bounds of the variables. + * + * @return A status code indicating success or failure. + */ +cuopt_int_t cuOptGetVariableUpperBounds(cuOptOptimizationProblem problem, + cuopt_float_t* upper_bounds_ptr); + +/** @brief Get the variable types of an optimization problem. + * + * @param[in] problem - The optimization problem. + * + * @param[out] variable_types_ptr - A pointer to an array of type char of size + * num_variables that on output will contain the types of the variables + * (CUOPT_CONTINUOUS, CUOPT_INTEGER, or CUOPT_SEMI_CONTINUOUS). + * + * @return A status code indicating success or failure. + */ +cuopt_int_t cuOptGetVariableTypes(cuOptOptimizationProblem problem, char* variable_types_ptr); + +/** @brief Create a solver settings object. + * + * @param[out] settings_ptr - A pointer to a cuOptSolverSettings object. On output + * the solver settings will be created and initialized. + * + * @return A status code indicating success or failure. + */ +cuopt_int_t cuOptCreateSolverSettings(cuOptSolverSettings* settings_ptr); + +/** @brief Destroy a solver settings object. + * + * @param[in, out] settings_ptr - A pointer to a cuOptSolverSettings object. On output + * the solver settings will be destroyed and the pointer will be set to NULL. + */ +void cuOptDestroySolverSettings(cuOptSolverSettings* settings_ptr); + +/** @brief Set a parameter of a solver settings object. + * + * @param[in] settings - The solver settings object. + * + * @param[in] parameter_name - The name of the parameter to set. + * + * @param[in] parameter_value - The value of the parameter to set. + */ +cuopt_int_t cuOptSetParameter(cuOptSolverSettings settings, + const char* parameter_name, + const char* parameter_value); + +/** @brief Get a parameter of a solver settings object. + * + * @param[in] settings - The solver settings object. + * + * @param[in] parameter_name - The name of the parameter to get. + * + * @param[in] parameter_value_size - The size of the parameter value buffer. + * + * @param[out] parameter_value - A pointer to an array of characters that on output will contain the + * value of the parameter. + * + * @return A status code indicating success or failure. + */ +cuopt_int_t cuOptGetParameter(cuOptSolverSettings settings, + const char* parameter_name, + cuopt_int_t parameter_value_size, + char* parameter_value); + +/** @brief Set an integer parameter of a solver settings object. + * + * @param[in] settings - The solver settings object. + * + * @param[in] parameter_name - The name of the parameter to set. + * + * @param[in] parameter_value - The value of the parameter to set. + * + * @return A status code indicating success or failure. + */ +cuopt_int_t cuOptSetIntegerParameter(cuOptSolverSettings settings, + const char* parameter_name, + cuopt_int_t parameter_value); + +/** @brief Get an integer parameter of a solver settings object. + * + * @param[in] settings - The solver settings object. + * + * @param[in] parameter_name - The name of the parameter to get. + * + * @param[out] parameter_value - A pointer to a cuopt_int_t that on output will contain the + * value of the parameter. + * + * @return A status code indicating success or failure. + */ +cuopt_int_t cuOptGetIntegerParameter(cuOptSolverSettings settings, + const char* parameter_name, + cuopt_int_t* parameter_value); + +/** @brief Set a float parameter of a solver settings object. + * + * @param[in] settings - The solver settings object. + * + * @param[in] parameter_name - The name of the parameter to set. + * + * @param[in] parameter_value - The value of the parameter to set. + * + * @return A status code indicating success or failure. + */ +cuopt_int_t cuOptSetFloatParameter(cuOptSolverSettings settings, + const char* parameter_name, + cuopt_float_t parameter_value); + +/** @brief Get a float parameter of a solver settings object. + * + * @param[in] settings - The solver settings object. + * + * @param[in] parameter_name - The name of the parameter to get. + * + * @param[out] parameter_value - A pointer to a cuopt_float_t that on output will contain the + * value of the parameter. + * + * @return A status code indicating success or failure. + */ +cuopt_int_t cuOptGetFloatParameter(cuOptSolverSettings settings, + const char* parameter_name, + cuopt_float_t* parameter_value); + +/** + * @brief Type of callback for receiving incumbent MIP solutions with user context. + * + * @param[in] solution - Pointer to incumbent solution values. + * The allocated array for solution pointer must be at least the number of variables in the original + * problem. + * @param[in] objective_value - Pointer to incumbent objective value. + * @param[in] solution_bound - Pointer to current solution (dual/user) bound. + * @param[in] user_data - Pointer to user data. + * @note All pointer arguments (solution, objective_value, solution_bound, user_data) refer to host + * memory and are only valid during the callback invocation. Do not pass device/GPU pointers. + * Copy any data you need to keep after the callback returns. + */ +typedef void (*cuOptMIPGetSolutionCallback)(const cuopt_float_t* solution, + const cuopt_float_t* objective_value, + const cuopt_float_t* solution_bound, + void* user_data); + +/** + * @brief Type of callback for injecting MIP solutions with user context. + * + * @param[out] solution - Pointer to solution values to set. + * The allocated array for solution pointer must be at least the number of variables in the original + * problem. + * @param[out] objective_value - Pointer to objective value to set. + * @param[in] solution_bound - Pointer to current solution (dual/user) bound. + * @param[in] user_data - Pointer to user data. + * @note All pointer arguments (solution, objective_value, solution_bound, user_data) refer to host + * memory and are only valid during the callback invocation. Do not pass device/GPU pointers. + * Copy any data you need to keep after the callback returns. + */ +typedef void (*cuOptMIPSetSolutionCallback)(cuopt_float_t* solution, + cuopt_float_t* objective_value, + const cuopt_float_t* solution_bound, + void* user_data); + +/** + * @brief Register a callback to receive incumbent MIP solutions. + * + * @param[in] settings - The solver settings object. + * @param[in] callback - Callback function to receive incumbent solutions. + * @param[in] user_data - User-defined pointer passed through to the callback. + * It will be forwarded to ``cuOptMIPGetSolutionCallback`` when invoked. + * @note The callback arguments refer to host memory and are only valid during the callback + * invocation. Do not pass device/GPU pointers. Copy any data you need to keep after the callback + * returns. + * + * @return A status code indicating success or failure. + */ +cuopt_int_t cuOptSetMIPGetSolutionCallback(cuOptSolverSettings settings, + cuOptMIPGetSolutionCallback callback, + void* user_data); + +/** + * @brief Register a callback to inject MIP solutions. + * + * @param[in] settings - The solver settings object. + * @param[in] callback - Callback function to inject solutions. + * @param[in] user_data - User-defined pointer passed through to the callback. + * It will be forwarded to ``cuOptMIPSetSolutionCallback`` when invoked. + * @note Registering a set-solution callback disables presolve. + * @note The callback arguments refer to host memory and are only valid during the callback + * invocation. Do not pass device/GPU pointers. Copy any data you need to keep after the callback + * returns. + * + * @return A status code indicating success or failure. + */ +cuopt_int_t cuOptSetMIPSetSolutionCallback(cuOptSolverSettings settings, + cuOptMIPSetSolutionCallback callback, + void* user_data); +/** + * @brief Set the initial primal solution for an LP solve. + * + * @note This function is only supported for PDLP. + * + * @param[in] settings - The solver settings object. + * @param[in] primal_solution - A pointer to an array of type cuopt_float_t + * of size num_variables containing the initial primal values. + * @param[in] num_variables - The number of variables (size of the primal_solution array). + * + * @note All pointer arguments (primal_solution) refer to host memory. + * @return A status code indicating success or failure. + */ +cuopt_int_t cuOptSetInitialPrimalSolution(cuOptSolverSettings settings, + const cuopt_float_t* primal_solution, + cuopt_int_t num_variables); + +/** + * @brief Set the initial dual solution for an LP solve. + * + * @note This function is only supported for PDLP. + * + * @param[in] settings - The solver settings object. + * @param[in] dual_solution - A pointer to an array of type cuopt_float_t + * of size num_constraints containing the initial dual values. + * @param[in] num_constraints - The number of constraints (size of the dual_solution array). + * + * @note All pointer arguments (dual_solution) refer to host memory. + * @return A status code indicating success or failure. + */ +cuopt_int_t cuOptSetInitialDualSolution(cuOptSolverSettings settings, + const cuopt_float_t* dual_solution, + cuopt_int_t num_constraints); + +/** + * @brief Add an initial solution (MIP start) for MIP solving. + * + * This function can be called multiple times to add multiple MIP starts. + * The solver will use these as starting points for the MIP search. + * + * @param[in] settings - The solver settings object. + * @param[in] solution - A pointer to an array of type cuopt_float_t + * of size num_variables containing the solution values. + * @param[in] num_variables - The number of variables (size of the solution array). + * + * @attention Currently unsupported with presolve on. + * + * @note All pointer arguments (solution) refer to host memory. + * @return A status code indicating success or failure. + */ +cuopt_int_t cuOptAddMIPStart(cuOptSolverSettings settings, + const cuopt_float_t* solution, + cuopt_int_t num_variables); + +/** @brief Check if an optimization problem is a mixed integer programming problem. + * + * @param[in] problem - The optimization problem. + * + * @param[out] is_mip_ptr - A pointer to a cuopt_int_t that on output will be 0 if the problem + * contains only continuous variables, or 1 if the problem contains integer variables. + * + * @return A status code indicating success or failure. + */ +cuopt_int_t cuOptIsMIP(cuOptOptimizationProblem problem, cuopt_int_t* is_mip_ptr); + +/** @brief Solve an optimization problem. + * + * @param[in] problem - The optimization problem. + * + * @param[in] settings - The solver settings. + * + * @param[out] solution_ptr - A pointer to a cuOptSolution object. On output + * the solution will be created. + * + * @return A status code indicating success or failure. + */ +cuopt_int_t cuOptSolve(cuOptOptimizationProblem problem, + cuOptSolverSettings settings, + cuOptSolution* solution_ptr); + +/** @brief Destroy a solution object. + * + * @param[in, out] solution_ptr - A pointer to a cuOptSolution object. On output + * the solution will be destroyed and the pointer will be set to NULL. + */ +void cuOptDestroySolution(cuOptSolution* solution_ptr); + +/** @brief Get the termination reason of an optimization problem. + * + * @param[in] solution - The solution object. + * + * @param[out] termination_reason_ptr - A pointer to a cuopt_int_t that on output will contain the + * termination reason. + * + * @return A status code indicating success or failure. + */ +cuopt_int_t cuOptGetTerminationStatus(cuOptSolution solution, cuopt_int_t* termination_status_ptr); + +/* @brief Get the error status of a solution object. + * + * @param[in] solution - The solution object. + * + * @param[out] error_status_ptr - A pointer to a cuopt_int_t that on output will contain the + * error status. + * + * @return A status code indicating success or failure. + */ +cuopt_int_t cuOptGetErrorStatus(cuOptSolution solution, cuopt_int_t* error_status_ptr); + +/* @brief Get the error string of a solution object. + * + * @param[in] solution - The solution object. + * + * @param[out] error_string_ptr - A pointer to a char that on output will contain the + * error string. + * + * @param[in] error_string_size - Size of the char buffer/ + * + * @return A status code indicating success or failure. + */ +cuopt_int_t cuOptGetErrorString(cuOptSolution solution, + char* error_string_ptr, + cuopt_int_t error_string_size); + +/* @brief Get the solution of an optimization problem. + * + * @param[in] solution - The solution object. + * + * @param[in, out] solution_values - A pointer to an array of type cuopt_float_t of size + * num_variables that will contain the solution values. + * + * @return A status code indicating success or failure. + */ +cuopt_int_t cuOptGetPrimalSolution(cuOptSolution solution, cuopt_float_t* solution_values); + +/** @brief Get the objective value of an optimization problem. + * + * @param[in] solution - The solution object. + * + * @param[in,out] objective_value_ptr - A pointer to a cuopt_float_t that will contain the objective + * value. + * + * @return A status code indicating success or failure. + */ +cuopt_int_t cuOptGetObjectiveValue(cuOptSolution solution, cuopt_float_t* objective_value_ptr); + +/** @brief Get the solve time of an optimization problem. + * + * @param[in] solution - The solution object. + * + * @param[in,out] solve_time_ptr - A pointer to a cuopt_float_t that will contain the solve time. + * + * @return A status code indicating success or failure. + */ +cuopt_int_t cuOptGetSolveTime(cuOptSolution solution, cuopt_float_t* solve_time_ptr); + +/** @brief Get the relative MIP gap of an optimization problem. + * + * @param[in] solution - The solution object. + * + * @param[in, out] mip_gap_ptr - A pointer to a cuopt_float_t that will contain the relative MIP + * gap. + * + * @return A status code indicating success or failure. + */ +cuopt_int_t cuOptGetMIPGap(cuOptSolution solution, cuopt_float_t* mip_gap_ptr); + +/** @brief Get the solution bound of an optimization problem. + * + * @param[in] solution - The solution object. + * + * @param[in, out] solution_bound_ptr - A pointer to a cuopt_float_t that will contain the solution + * bound. + * + * @return A status code indicating success or failure. + */ +cuopt_int_t cuOptGetSolutionBound(cuOptSolution solution, cuopt_float_t* solution_bound_ptr); + +/** @brief Get the dual solution of an optimization problem. + * + * @param[in] solution - The solution object. + * + * @param[in, out] dual_solution_ptr - A pointer to an array of type cuopt_float_t of size + * num_constraints that will contain the dual solution. + * + * @return A status code indicating success or failure. + */ +cuopt_int_t cuOptGetDualSolution(cuOptSolution solution, cuopt_float_t* dual_solution_ptr); + +/** @brief Get the dual objective value of an optimization problem. + * + * @param[in] solution - The solution object. + * + * @param[in, out] dual_objective_value_ptr - A pointer to a cuopt_float_t that will contain the + * dual objective value. + * + * @return A status code indicating success or failure. + */ +cuopt_int_t cuOptGetDualObjectiveValue(cuOptSolution solution, + cuopt_float_t* dual_objective_value_ptr); + +/** @brief Get the reduced costs of an optimization problem. + * + * @param[in] solution - The solution object. + * + * @param[in,out] reduced_cost_ptr - A pointer to an array of type cuopt_float_t of size + * num_variables that will contain the reduced cost. + * + * @return A status code indicating success or failure. + */ +cuopt_int_t cuOptGetReducedCosts(cuOptSolution solution, cuopt_float_t* reduced_cost_ptr); + +#ifdef __cplusplus +} +#endif + +#endif // CUOPT_C_API_H diff --git a/cpp/include/cuopt/linear_programming/io/data_model_view.hpp b/cpp/include/cuopt/mathematical_optimization/io/data_model_view.hpp similarity index 99% rename from cpp/include/cuopt/linear_programming/io/data_model_view.hpp rename to cpp/include/cuopt/mathematical_optimization/io/data_model_view.hpp index 4d62458263..d6bed10d51 100644 --- a/cpp/include/cuopt/linear_programming/io/data_model_view.hpp +++ b/cpp/include/cuopt/mathematical_optimization/io/data_model_view.hpp @@ -7,7 +7,7 @@ #pragma once -#include +#include #include #include @@ -15,7 +15,7 @@ #include #include -namespace cuopt::linear_programming::io { +namespace cuopt::mathematical_optimization::io { /** * @brief A representation of a linear programming (LP) optimization problem @@ -478,4 +478,4 @@ class data_model_view_t { std::vector::quadratic_constraint_t> quadratic_constraints_; }; // class data_model_view_t -} // namespace cuopt::linear_programming::io +} // namespace cuopt::mathematical_optimization::io diff --git a/cpp/include/cuopt/linear_programming/io/mps_data_model.hpp b/cpp/include/cuopt/mathematical_optimization/io/mps_data_model.hpp similarity index 99% rename from cpp/include/cuopt/linear_programming/io/mps_data_model.hpp rename to cpp/include/cuopt/mathematical_optimization/io/mps_data_model.hpp index 145dee51ef..9d33e37d58 100644 --- a/cpp/include/cuopt/linear_programming/io/mps_data_model.hpp +++ b/cpp/include/cuopt/mathematical_optimization/io/mps_data_model.hpp @@ -13,7 +13,7 @@ #include #include -namespace cuopt::linear_programming::io { +namespace cuopt::mathematical_optimization::io { /** * @brief A representation of a linear programming (LP) optimization problem @@ -385,4 +385,4 @@ class mps_data_model_t { }; // class mps_data_model_t -} // namespace cuopt::linear_programming::io +} // namespace cuopt::mathematical_optimization::io diff --git a/cpp/include/cuopt/linear_programming/io/mps_writer.hpp b/cpp/include/cuopt/mathematical_optimization/io/mps_writer.hpp similarity index 87% rename from cpp/include/cuopt/linear_programming/io/mps_writer.hpp rename to cpp/include/cuopt/mathematical_optimization/io/mps_writer.hpp index 86350dda2b..6184ce56b6 100644 --- a/cpp/include/cuopt/linear_programming/io/mps_writer.hpp +++ b/cpp/include/cuopt/mathematical_optimization/io/mps_writer.hpp @@ -7,8 +7,8 @@ #pragma once -#include -#include +#include +#include #include #include @@ -18,7 +18,7 @@ #include #include -namespace cuopt::linear_programming::io { +namespace cuopt::mathematical_optimization::io { /** * @brief Main writer class for MPS files @@ -60,4 +60,4 @@ class mps_writer_t { static data_model_view_t create_view(const mps_data_model_t& model); }; // class mps_writer_t -} // namespace cuopt::linear_programming::io +} // namespace cuopt::mathematical_optimization::io diff --git a/cpp/include/cuopt/linear_programming/io/parser.hpp b/cpp/include/cuopt/mathematical_optimization/io/parser.hpp similarity index 97% rename from cpp/include/cuopt/linear_programming/io/parser.hpp rename to cpp/include/cuopt/mathematical_optimization/io/parser.hpp index a63e40f31f..bbdaa1a819 100644 --- a/cpp/include/cuopt/linear_programming/io/parser.hpp +++ b/cpp/include/cuopt/mathematical_optimization/io/parser.hpp @@ -7,7 +7,7 @@ #pragma once -#include +#include #include #include @@ -15,7 +15,7 @@ #include #include -namespace cuopt::linear_programming::io { +namespace cuopt::mathematical_optimization::io { /** * @brief Reads the equation from an MPS or QPS file. @@ -145,4 +145,4 @@ inline mps_data_model_t read(const std::string& path, bool fixed_mps_f path); } -} // namespace cuopt::linear_programming::io +} // namespace cuopt::mathematical_optimization::io diff --git a/cpp/include/cuopt/linear_programming/io/utilities/cython_parser.hpp b/cpp/include/cuopt/mathematical_optimization/io/utilities/cython_parser.hpp similarity index 62% rename from cpp/include/cuopt/linear_programming/io/utilities/cython_parser.hpp rename to cpp/include/cuopt/mathematical_optimization/io/utilities/cython_parser.hpp index 711f1c73b2..a7863199df 100644 --- a/cpp/include/cuopt/linear_programming/io/utilities/cython_parser.hpp +++ b/cpp/include/cuopt/mathematical_optimization/io/utilities/cython_parser.hpp @@ -7,17 +7,17 @@ #pragma once -#include +#include #include namespace cuopt { namespace cython { -std::unique_ptr> call_read( +std::unique_ptr> call_read( const std::string& file_path, bool fixed_mps_format); -std::unique_ptr> call_parse_mps( +std::unique_ptr> call_parse_mps( const std::string& mps_file_path, bool fixed_mps_format); } // namespace cython diff --git a/cpp/include/cuopt/linear_programming/io/writer.hpp b/cpp/include/cuopt/mathematical_optimization/io/writer.hpp similarity index 79% rename from cpp/include/cuopt/linear_programming/io/writer.hpp rename to cpp/include/cuopt/mathematical_optimization/io/writer.hpp index d31f1009ab..032865220e 100644 --- a/cpp/include/cuopt/linear_programming/io/writer.hpp +++ b/cpp/include/cuopt/mathematical_optimization/io/writer.hpp @@ -7,9 +7,9 @@ #pragma once -#include +#include -namespace cuopt::linear_programming::io { +namespace cuopt::mathematical_optimization::io { /** * @brief Writes the problem to an MPS formatted file @@ -23,4 +23,4 @@ namespace cuopt::linear_programming::io { template void write_mps(const data_model_view_t& problem, const std::string& mps_file_path); -} // namespace cuopt::linear_programming::io +} // namespace cuopt::mathematical_optimization::io diff --git a/cpp/include/cuopt/linear_programming/mip/diving_hyper_params.hpp b/cpp/include/cuopt/mathematical_optimization/mip/diving_hyper_params.hpp similarity index 95% rename from cpp/include/cuopt/linear_programming/mip/diving_hyper_params.hpp rename to cpp/include/cuopt/mathematical_optimization/mip/diving_hyper_params.hpp index 19463b9150..ec08fe48dd 100644 --- a/cpp/include/cuopt/linear_programming/mip/diving_hyper_params.hpp +++ b/cpp/include/cuopt/mathematical_optimization/mip/diving_hyper_params.hpp @@ -7,7 +7,7 @@ #pragma once -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { /** * @brief Tuning knobs for the dual-simplex diving heuristics used in MIP B&B. @@ -59,4 +59,4 @@ struct mip_diving_hyper_params_t { bool show_type = false; }; -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/include/cuopt/linear_programming/mip/heuristics_hyper_params.hpp b/cpp/include/cuopt/mathematical_optimization/mip/heuristics_hyper_params.hpp similarity index 95% rename from cpp/include/cuopt/linear_programming/mip/heuristics_hyper_params.hpp rename to cpp/include/cuopt/mathematical_optimization/mip/heuristics_hyper_params.hpp index 71bbbe169a..e3fd891e83 100644 --- a/cpp/include/cuopt/linear_programming/mip/heuristics_hyper_params.hpp +++ b/cpp/include/cuopt/mathematical_optimization/mip/heuristics_hyper_params.hpp @@ -7,7 +7,7 @@ #pragma once -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { /** * @brief Tuning knobs for MIP GPU heuristics. @@ -38,4 +38,4 @@ struct mip_heuristics_hyper_params_t { f_t related_vars_time_limit = 30.0; // time for related-variable structure build }; -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/include/cuopt/linear_programming/mip/solver_settings.hpp b/cpp/include/cuopt/mathematical_optimization/mip/solver_settings.hpp similarity index 93% rename from cpp/include/cuopt/linear_programming/mip/solver_settings.hpp rename to cpp/include/cuopt/mathematical_optimization/mip/solver_settings.hpp index f995d434f0..ba4dce20dc 100644 --- a/cpp/include/cuopt/linear_programming/mip/solver_settings.hpp +++ b/cpp/include/cuopt/mathematical_optimization/mip/solver_settings.hpp @@ -10,18 +10,18 @@ #include #include -#include -#include -#include -#include -#include +#include +#include +#include +#include +#include #include #include #include -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { struct benchmark_info_t { double last_improvement_of_best_feasible = 0; @@ -57,10 +57,8 @@ class solver_settings_t; template class mip_solver_settings_t; -namespace detail { template struct mip_solver_settings_accessor; -} // namespace detail template class mip_solver_settings_t { @@ -182,7 +180,7 @@ class mip_solver_settings_t { benchmark_info_t* benchmark_info_ptr = nullptr; // TODO check with Akif and Alice - pdlp_hyper_params::pdlp_hyper_params_t hyper_params; + pdlp::pdlp_hyper_params_t hyper_params; mip_heuristics_hyper_params_t heuristic_params; @@ -194,11 +192,9 @@ class mip_solver_settings_t { std::vector semi_continuous_binary_to_original_indices_; friend class solver_settings_t; - friend struct detail::mip_solver_settings_accessor; + friend struct mip_solver_settings_accessor; }; -namespace detail { - template struct mip_solver_settings_accessor { static void clear_mip_callbacks(mip_solver_settings_t& settings) @@ -233,6 +229,4 @@ struct mip_solver_settings_accessor { } }; -} // namespace detail - -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/include/cuopt/linear_programming/mip/solver_solution.hpp b/cpp/include/cuopt/mathematical_optimization/mip/solver_solution.hpp similarity index 92% rename from cpp/include/cuopt/linear_programming/mip/solver_solution.hpp rename to cpp/include/cuopt/mathematical_optimization/mip/solver_solution.hpp index b8fa884540..19a8e5e531 100644 --- a/cpp/include/cuopt/linear_programming/mip/solver_solution.hpp +++ b/cpp/include/cuopt/mathematical_optimization/mip/solver_solution.hpp @@ -7,10 +7,10 @@ #pragma once -#include +#include #include -#include -#include +#include +#include #include #include @@ -21,7 +21,7 @@ #include #include -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { enum class mip_termination_status_t : int8_t { NoTermination = CUOPT_TERMINATION_STATUS_NO_TERMINATION, @@ -92,4 +92,4 @@ class mip_solution_t : public base_solution_t { std::vector> solution_pool_; }; -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/include/cuopt/linear_programming/mip/solver_stats.hpp b/cpp/include/cuopt/mathematical_optimization/mip/solver_stats.hpp similarity index 93% rename from cpp/include/cuopt/linear_programming/mip/solver_stats.hpp rename to cpp/include/cuopt/mathematical_optimization/mip/solver_stats.hpp index a546354a65..3434c1a420 100644 --- a/cpp/include/cuopt/linear_programming/mip/solver_stats.hpp +++ b/cpp/include/cuopt/mathematical_optimization/mip/solver_stats.hpp @@ -8,7 +8,7 @@ #include #include -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { template struct solver_stats_t { @@ -40,4 +40,4 @@ struct solver_stats_t { i_t num_simplex_iterations = 0; }; -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/include/cuopt/linear_programming/optimization_problem.hpp b/cpp/include/cuopt/mathematical_optimization/optimization_problem.hpp similarity index 98% rename from cpp/include/cuopt/linear_programming/optimization_problem.hpp rename to cpp/include/cuopt/mathematical_optimization/optimization_problem.hpp index 1b9302978b..5c755281ca 100644 --- a/cpp/include/cuopt/linear_programming/optimization_problem.hpp +++ b/cpp/include/cuopt/mathematical_optimization/optimization_problem.hpp @@ -7,8 +7,8 @@ #pragma once -#include -#include +#include +#include #include #include @@ -20,7 +20,7 @@ #include #include -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { // Forward declarations template @@ -425,4 +425,4 @@ class optimization_problem_t : public optimization_problem_interface_t std::vector row_names_{}; }; -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/include/cuopt/linear_programming/optimization_problem_interface.hpp b/cpp/include/cuopt/mathematical_optimization/optimization_problem_interface.hpp similarity index 99% rename from cpp/include/cuopt/linear_programming/optimization_problem_interface.hpp rename to cpp/include/cuopt/mathematical_optimization/optimization_problem_interface.hpp index e39d180d7a..c1ac8c1869 100644 --- a/cpp/include/cuopt/linear_programming/optimization_problem_interface.hpp +++ b/cpp/include/cuopt/mathematical_optimization/optimization_problem_interface.hpp @@ -7,7 +7,7 @@ #pragma once -#include +#include #include #include @@ -19,7 +19,7 @@ #include #include -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { enum class var_t { CONTINUOUS = 0, INTEGER, SEMI_CONTINUOUS }; enum class problem_category_t : int8_t { LP = 0, MIP = 1, IP = 2 }; @@ -495,4 +495,4 @@ class optimization_problem_interface_t { raft::handle_t const* handle_ptr = nullptr) = 0; }; -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/include/cuopt/linear_programming/optimization_problem_solution.hpp b/cpp/include/cuopt/mathematical_optimization/optimization_problem_solution.hpp similarity index 97% rename from cpp/include/cuopt/linear_programming/optimization_problem_solution.hpp rename to cpp/include/cuopt/mathematical_optimization/optimization_problem_solution.hpp index ac55256973..822bd54de3 100644 --- a/cpp/include/cuopt/linear_programming/optimization_problem_solution.hpp +++ b/cpp/include/cuopt/mathematical_optimization/optimization_problem_solution.hpp @@ -7,16 +7,16 @@ #pragma once -#include -#include -#include -#include -#include +#include +#include +#include +#include +#include #include #include -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { /** * @brief GPU-backed LP solution (wraps optimization_problem_solution_t) @@ -476,4 +476,4 @@ class gpu_mip_solution_t : public mip_solution_interface_t { mip_solution_t solution_; }; -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/include/cuopt/linear_programming/optimization_problem_solution_interface.hpp b/cpp/include/cuopt/mathematical_optimization/optimization_problem_solution_interface.hpp similarity index 96% rename from cpp/include/cuopt/linear_programming/optimization_problem_solution_interface.hpp rename to cpp/include/cuopt/mathematical_optimization/optimization_problem_solution_interface.hpp index 3dc1678c8b..e30474538d 100644 --- a/cpp/include/cuopt/linear_programming/optimization_problem_solution_interface.hpp +++ b/cpp/include/cuopt/mathematical_optimization/optimization_problem_solution_interface.hpp @@ -7,22 +7,22 @@ #pragma once -#include +#include #include -#include // For mip_termination_status_t -#include -#include // For pdlp_termination_status_t +#include // For mip_termination_status_t +#include +#include // For pdlp_termination_status_t #include #include -#include +#include #include #include #include -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { // Forward declarations template @@ -486,4 +486,4 @@ class gpu_mip_solution_t; template class cpu_mip_solution_t; -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/include/cuopt/linear_programming/optimization_problem_utils.hpp b/cpp/include/cuopt/mathematical_optimization/optimization_problem_utils.hpp similarity index 95% rename from cpp/include/cuopt/linear_programming/optimization_problem_utils.hpp rename to cpp/include/cuopt/mathematical_optimization/optimization_problem_utils.hpp index f6599c4ea6..8e2f565337 100644 --- a/cpp/include/cuopt/linear_programming/optimization_problem_utils.hpp +++ b/cpp/include/cuopt/mathematical_optimization/optimization_problem_utils.hpp @@ -8,15 +8,13 @@ #pragma once #include -#include -#include -#include -#include -#include +#include +#include +#include +#include +#include -namespace cuopt::linear_programming { - -namespace detail { +namespace cuopt::mathematical_optimization { inline constexpr bool is_valid_public_var_type_code(char variable_type) { @@ -37,8 +35,6 @@ inline constexpr char var_type_to_char(var_t variable_type) return 'C'; } -} // namespace detail - /** * @brief Helper function to populate optimization_problem_interface_t from mps_data_model_t * @@ -114,7 +110,7 @@ void populate_from_mps_data_model(optimization_problem_interface_t* pr if (!char_variable_types.empty()) { std::vector enum_variable_types(char_variable_types.size()); for (size_t i = 0; i < char_variable_types.size(); ++i) { - enum_variable_types[i] = detail::char_to_var_type(char_variable_types[i]); + enum_variable_types[i] = char_to_var_type(char_variable_types[i]); } problem->set_variable_types(enum_variable_types.data(), enum_variable_types.size()); // Problem category (LP/MIP/IP) is auto-detected by set_variable_types @@ -156,7 +152,7 @@ void populate_from_mps_data_model(optimization_problem_interface_t* pr template void populate_from_data_model_view( optimization_problem_interface_t* problem, - cuopt::linear_programming::io::data_model_view_t* data_model, + cuopt::mathematical_optimization::io::data_model_view_t* data_model, solver_settings_t* solver_settings = nullptr, const raft::handle_t* handle = nullptr) { @@ -282,7 +278,7 @@ void populate_from_data_model_view( data_model->get_variable_types().data(), data_model->get_variable_types().data() + data_model->get_variable_types().size(), enum_variable_types.begin(), - detail::char_to_var_type); + char_to_var_type); problem->set_variable_types(enum_variable_types.data(), enum_variable_types.size()); // Problem category (LP/MIP/IP) is auto-detected by set_variable_types } @@ -300,4 +296,4 @@ void populate_from_data_model_view( } } -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/include/cuopt/linear_programming/pdlp/pdlp_hyper_params.cuh b/cpp/include/cuopt/mathematical_optimization/pdlp/pdlp_hyper_params.cuh similarity index 96% rename from cpp/include/cuopt/linear_programming/pdlp/pdlp_hyper_params.cuh rename to cpp/include/cuopt/mathematical_optimization/pdlp/pdlp_hyper_params.cuh index 282e91d7ef..6aee5213a7 100644 --- a/cpp/include/cuopt/linear_programming/pdlp/pdlp_hyper_params.cuh +++ b/cpp/include/cuopt/mathematical_optimization/pdlp/pdlp_hyper_params.cuh @@ -7,7 +7,7 @@ #pragma once -namespace cuopt::linear_programming::pdlp_hyper_params { +namespace cuopt::mathematical_optimization::pdlp { struct pdlp_hyper_params_t { double initial_step_size_scaling = 1.0; @@ -58,4 +58,4 @@ struct pdlp_hyper_params_t { // TODO most likely we want to get rid of pdlp_solver_mode and just have prebuilt // constpexr version of each (Stable2, Stable1, Methodical1, Fast1, Stable3...) -} // namespace cuopt::linear_programming::pdlp_hyper_params +} // namespace cuopt::mathematical_optimization::pdlp diff --git a/cpp/include/cuopt/linear_programming/pdlp/pdlp_warm_start_data.hpp b/cpp/include/cuopt/mathematical_optimization/pdlp/pdlp_warm_start_data.hpp similarity index 97% rename from cpp/include/cuopt/linear_programming/pdlp/pdlp_warm_start_data.hpp rename to cpp/include/cuopt/mathematical_optimization/pdlp/pdlp_warm_start_data.hpp index c4602b4d48..07f54672f2 100644 --- a/cpp/include/cuopt/linear_programming/pdlp/pdlp_warm_start_data.hpp +++ b/cpp/include/cuopt/mathematical_optimization/pdlp/pdlp_warm_start_data.hpp @@ -11,7 +11,7 @@ #include -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { template struct pdlp_warm_start_data_view_t; @@ -99,4 +99,4 @@ struct pdlp_warm_start_data_view_t { i_t iterations_since_last_restart_{-1}; }; -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/include/cuopt/linear_programming/pdlp/solver_settings.hpp b/cpp/include/cuopt/mathematical_optimization/pdlp/solver_settings.hpp similarity index 96% rename from cpp/include/cuopt/linear_programming/pdlp/solver_settings.hpp rename to cpp/include/cuopt/mathematical_optimization/pdlp/solver_settings.hpp index b30286f9ce..96f548ec32 100644 --- a/cpp/include/cuopt/linear_programming/pdlp/solver_settings.hpp +++ b/cpp/include/cuopt/mathematical_optimization/pdlp/solver_settings.hpp @@ -7,11 +7,11 @@ #pragma once -#include -#include -#include -#include -#include +#include +#include +#include +#include +#include #include #include #include @@ -21,7 +21,7 @@ #include -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { // Forward declare solver_settings_t for friend class template @@ -314,7 +314,7 @@ class pdlp_solver_settings_t { // Shared strong branching solved flags for cooperative DS + PDLP cuda::std::span> shared_sb_solved; static constexpr f_t minimal_absolute_tolerance = 1.0e-12; - pdlp_hyper_params::pdlp_hyper_params_t hyper_params; + pdlp::pdlp_hyper_params_t hyper_params; // Holds per-climber variable-bound overrides in the format: // (climber id, variable index, new lower bound, new upper bound). // Per-climber objective coefficients / offsets / constraint bounds must be pre-expanded directly @@ -351,4 +351,4 @@ class pdlp_solver_settings_t { friend class solver_settings_t; }; -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/include/cuopt/linear_programming/pdlp/solver_solution.hpp b/cpp/include/cuopt/mathematical_optimization/pdlp/solver_solution.hpp similarity index 97% rename from cpp/include/cuopt/linear_programming/pdlp/solver_solution.hpp rename to cpp/include/cuopt/mathematical_optimization/pdlp/solver_solution.hpp index 81e911df62..5bacff1101 100644 --- a/cpp/include/cuopt/linear_programming/pdlp/solver_solution.hpp +++ b/cpp/include/cuopt/mathematical_optimization/pdlp/solver_solution.hpp @@ -7,11 +7,11 @@ #pragma once -#include +#include #include -#include -#include -#include +#include +#include +#include #include #include @@ -22,7 +22,7 @@ #include #include -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { // Possible reasons for terminating enum class pdlp_termination_status_t : int8_t { @@ -310,4 +310,4 @@ class optimization_problem_solution_t : public base_solution_t { /** error struct */ cuopt::logic_error error_status_; }; -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/include/cuopt/linear_programming/solve.hpp b/cpp/include/cuopt/mathematical_optimization/solve.hpp similarity index 87% rename from cpp/include/cuopt/linear_programming/solve.hpp rename to cpp/include/cuopt/mathematical_optimization/solve.hpp index 42325d296c..961fcd29b6 100644 --- a/cpp/include/cuopt/linear_programming/solve.hpp +++ b/cpp/include/cuopt/mathematical_optimization/solve.hpp @@ -7,23 +7,23 @@ #pragma once -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include #include #include #include -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { /** * @brief Linear programming solve function. @@ -71,7 +71,7 @@ optimization_problem_solution_t solve_lp( template optimization_problem_solution_t solve_lp( raft::handle_t const* handle_ptr, - const cuopt::linear_programming::io::mps_data_model_t& mps_data_model, + const cuopt::mathematical_optimization::io::mps_data_model_t& mps_data_model, pdlp_solver_settings_t const& settings = pdlp_solver_settings_t{}, bool problem_checking = true, bool use_pdlp_solver_mode = true); @@ -93,7 +93,7 @@ optimization_problem_solution_t solve_lp( * subject to lb <= A*x <= ub * x_j >= ceil(root_soln[j]) * - * @param[in] user_problem A dual_simplex::user_problem_t object with a + * @param[in] user_problem A simplex::user_problem_t object with a * representation of a linear program. * @param[in] fractional A vector of indexes of the fractional variables. * @param[in] root_soln_x The corresponding root solution values for the fractional variables. Size @@ -107,7 +107,7 @@ optimization_problem_solution_t solve_lp( template optimization_problem_solution_t batch_pdlp_solve( raft::handle_t const* handle_ptr, - const cuopt::linear_programming::io::mps_data_model_t& mps_data_model, + const cuopt::mathematical_optimization::io::mps_data_model_t& mps_data_model, const std::vector& fractional, const std::vector& root_soln_x, pdlp_solver_settings_t const& settings = pdlp_solver_settings_t{}); @@ -140,13 +140,13 @@ mip_solution_t solve_mip( template mip_solution_t solve_mip( raft::handle_t const* handle_ptr, - const cuopt::linear_programming::io::mps_data_model_t& mps_data_model, + const cuopt::mathematical_optimization::io::mps_data_model_t& mps_data_model, mip_solver_settings_t const& settings = mip_solver_settings_t{}); template optimization_problem_t mps_data_model_to_optimization_problem( raft::handle_t const* handle_ptr, - const cuopt::linear_programming::io::mps_data_model_t& data_model); + const cuopt::mathematical_optimization::io::mps_data_model_t& data_model); // ============================================================================ // CPU problem overloads (convert to GPU, solve, convert solution back) @@ -213,4 +213,4 @@ std::unique_ptr> solve_mip( // Remote execution functions are declared in solve_remote.hpp (included above) -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/include/cuopt/linear_programming/solve_remote.hpp b/cpp/include/cuopt/mathematical_optimization/solve_remote.hpp similarity index 88% rename from cpp/include/cuopt/linear_programming/solve_remote.hpp rename to cpp/include/cuopt/mathematical_optimization/solve_remote.hpp index b9e309c89c..3636195660 100644 --- a/cpp/include/cuopt/linear_programming/solve_remote.hpp +++ b/cpp/include/cuopt/mathematical_optimization/solve_remote.hpp @@ -8,11 +8,11 @@ #pragma once // Include the solution interface definitions so unique_ptr can properly delete them -#include +#include #include -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { // Forward declarations (only declaration needed, not definition) template @@ -44,4 +44,4 @@ std::unique_ptr> solve_mip_remote( cpu_optimization_problem_t const& cpu_problem, mip_solver_settings_t const& settings); -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/include/cuopt/linear_programming/solver_settings.hpp b/cpp/include/cuopt/mathematical_optimization/solver_settings.hpp similarity index 91% rename from cpp/include/cuopt/linear_programming/solver_settings.hpp rename to cpp/include/cuopt/mathematical_optimization/solver_settings.hpp index 1720b0e9f9..df373b209d 100644 --- a/cpp/include/cuopt/linear_programming/solver_settings.hpp +++ b/cpp/include/cuopt/mathematical_optimization/solver_settings.hpp @@ -7,22 +7,22 @@ #pragma once -#include +#include #include #include #include -#include -#include -#include -#include +#include +#include +#include +#include #include #include -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { template class solver_settings_t { @@ -109,4 +109,4 @@ class solver_settings_t { std::vector> string_parameters; }; -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/include/cuopt/linear_programming/utilities/callbacks_implems.hpp b/cpp/include/cuopt/mathematical_optimization/utilities/callbacks_implems.hpp similarity index 98% rename from cpp/include/cuopt/linear_programming/utilities/callbacks_implems.hpp rename to cpp/include/cuopt/mathematical_optimization/utilities/callbacks_implems.hpp index ef0fe35b98..69abbb46a3 100644 --- a/cpp/include/cuopt/linear_programming/utilities/callbacks_implems.hpp +++ b/cpp/include/cuopt/mathematical_optimization/utilities/callbacks_implems.hpp @@ -8,7 +8,7 @@ #pragma once #include -#include +#include #include diff --git a/cpp/include/cuopt/linear_programming/utilities/cython_solve.hpp b/cpp/include/cuopt/mathematical_optimization/utilities/cython_solve.hpp similarity index 53% rename from cpp/include/cuopt/linear_programming/utilities/cython_solve.hpp rename to cpp/include/cuopt/mathematical_optimization/utilities/cython_solve.hpp index 9f4fc93923..79ef572d9c 100644 --- a/cpp/include/cuopt/linear_programming/utilities/cython_solve.hpp +++ b/cpp/include/cuopt/mathematical_optimization/utilities/cython_solve.hpp @@ -7,12 +7,12 @@ #pragma once -#include -#include -#include -#include +#include +#include +#include +#include -#include +#include #include #include #include @@ -27,7 +27,7 @@ namespace cython { // Each holds a std::variant internally to support both GPU and CPU solution data. struct solver_ret_t { - linear_programming::problem_category_t problem_type; + mathematical_optimization::problem_category_t problem_type; linear_programming_ret_t lp_ret; mip_ret_t mip_ret; }; @@ -40,30 +40,30 @@ struct solver_ret_t { // call_solve / call_batch_solve -- return unique_ptr; caller owns the result. // The solver_ret_t holds the solution objects and must outlive any raw pointers obtained above. -linear_programming::lp_solution_interface_t* call_solve_lp( - linear_programming::optimization_problem_interface_t* problem_interface, - linear_programming::pdlp_solver_settings_t& solver_settings, +mathematical_optimization::lp_solution_interface_t* call_solve_lp( + mathematical_optimization::optimization_problem_interface_t* problem_interface, + mathematical_optimization::pdlp_solver_settings_t& solver_settings, bool is_batch_mode = false); // Call solve_mip and return solution interface pointer -linear_programming::mip_solution_interface_t* call_solve_mip( - linear_programming::optimization_problem_interface_t* problem_interface, - linear_programming::mip_solver_settings_t& solver_settings); +mathematical_optimization::mip_solution_interface_t* call_solve_mip( + mathematical_optimization::optimization_problem_interface_t* problem_interface, + mathematical_optimization::mip_solver_settings_t& solver_settings); // Main solve entry point from Python std::unique_ptr call_solve( - cuopt::linear_programming::io::data_model_view_t*, - linear_programming::solver_settings_t*, + cuopt::mathematical_optimization::io::data_model_view_t*, + mathematical_optimization::solver_settings_t*, unsigned int flags = cudaStreamNonBlocking, bool is_batch_mode = false); std::pair>, double> solve_batch_remote( - std::vector*>, - linear_programming::solver_settings_t*); + std::vector*>, + mathematical_optimization::solver_settings_t*); std::pair>, double> call_batch_solve( - std::vector*>, - linear_programming::solver_settings_t*); + std::vector*>, + mathematical_optimization::solver_settings_t*); } // namespace cython } // namespace cuopt diff --git a/cpp/include/cuopt/linear_programming/utilities/cython_types.hpp b/cpp/include/cuopt/mathematical_optimization/utilities/cython_types.hpp similarity index 88% rename from cpp/include/cuopt/linear_programming/utilities/cython_types.hpp rename to cpp/include/cuopt/mathematical_optimization/utilities/cython_types.hpp index 20db133512..966018bd9f 100644 --- a/cpp/include/cuopt/linear_programming/utilities/cython_types.hpp +++ b/cpp/include/cuopt/mathematical_optimization/utilities/cython_types.hpp @@ -7,9 +7,9 @@ #pragma once -#include -#include -#include +#include +#include +#include #include @@ -71,7 +71,7 @@ struct linear_programming_ret_t { int iterations_since_last_restart_{}; /* -- /PDLP Warm Start Scalars -- */ - linear_programming::pdlp_termination_status_t termination_status_{}; + mathematical_optimization::pdlp_termination_status_t termination_status_{}; error_type_t error_status_{}; std::string error_message_; @@ -83,7 +83,7 @@ struct linear_programming_ret_t { double gap_{}; int nb_iterations_{}; double solve_time_{}; - linear_programming::method_t solved_by_{}; + mathematical_optimization::method_t solved_by_{}; bool is_gpu() const { return std::holds_alternative(solutions_); } }; @@ -93,7 +93,7 @@ struct linear_programming_ret_t { struct mip_ret_t { std::variant solution_; - linear_programming::mip_termination_status_t termination_status_{}; + mathematical_optimization::mip_termination_status_t termination_status_{}; error_type_t error_status_{}; std::string error_message_; diff --git a/cpp/include/cuopt/linear_programming/utilities/internals.hpp b/cpp/include/cuopt/mathematical_optimization/utilities/internals.hpp similarity index 96% rename from cpp/include/cuopt/linear_programming/utilities/internals.hpp rename to cpp/include/cuopt/mathematical_optimization/utilities/internals.hpp index bdfbb969d2..aaec8ef842 100644 --- a/cpp/include/cuopt/linear_programming/utilities/internals.hpp +++ b/cpp/include/cuopt/mathematical_optimization/utilities/internals.hpp @@ -12,7 +12,7 @@ #include #include -#include +#include namespace cuopt { namespace internals { @@ -69,7 +69,7 @@ class set_solution_callback_t : public base_solution_callback_t { } // namespace internals -namespace linear_programming { +namespace mathematical_optimization { class base_solution_t { public: @@ -142,5 +142,5 @@ enum presolver_t : int { PSLP = CUOPT_PRESOLVE_PSLP }; -} // namespace linear_programming +} // namespace mathematical_optimization } // namespace cuopt diff --git a/cpp/include/cuopt/linear_programming/utilities/segmented_sum_handler.cuh b/cpp/include/cuopt/mathematical_optimization/utilities/segmented_sum_handler.cuh similarity index 97% rename from cpp/include/cuopt/linear_programming/utilities/segmented_sum_handler.cuh rename to cpp/include/cuopt/mathematical_optimization/utilities/segmented_sum_handler.cuh index 0b7e168a76..30cefd910b 100644 --- a/cpp/include/cuopt/linear_programming/utilities/segmented_sum_handler.cuh +++ b/cpp/include/cuopt/mathematical_optimization/utilities/segmented_sum_handler.cuh @@ -21,7 +21,7 @@ #include -namespace cuopt::linear_programming::detail { +namespace cuopt { template struct segmented_sum_handler_t { @@ -83,4 +83,4 @@ struct segmented_sum_handler_t { rmm::cuda_stream_view stream_view_; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt diff --git a/cpp/src/barrier/barrier.cu b/cpp/src/barrier/barrier.cu index 1cbeed5cf3..a1f493823d 100644 --- a/cpp/src/barrier/barrier.cu +++ b/cpp/src/barrier/barrier.cu @@ -50,7 +50,23 @@ #include #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::barrier { + +using simplex::compute_user_objective; +using simplex::csc_matrix_t; +using simplex::csr_matrix_t; +using simplex::device_vector_norm_inf; +using simplex::float64_t; +using simplex::inf; +using simplex::lp_problem_t; +using simplex::lp_solution_t; +using simplex::lp_status_t; +using simplex::matrix_vector_multiply; +using simplex::multiply; +using simplex::simplex_solver_settings_t; +using simplex::tic; +using simplex::toc; +using simplex::vector_norm1; template bool validate_barrier_cone_layout(const lp_problem_t& problem, @@ -1008,9 +1024,9 @@ class iteration_data_t { { if (n_dense_columns == 0) { // Solve ADAT * x = b - if (debug) { settings_.log.printf("||b|| = %.16e\n", vector_norm2(b)); } + if (debug) { settings_.log.printf("||b|| = %.16e\n", simplex::vector_norm2(b)); } i_t solve_status = chol->solve(b, x); - if (debug) { settings_.log.printf("||x|| = %.16e\n", vector_norm2(x)); } + if (debug) { settings_.log.printf("||x|| = %.16e\n", simplex::vector_norm2(x)); } return solve_status; } else { // Use Sherman Morrison followed by PCG @@ -1046,9 +1062,9 @@ class iteration_data_t { dense_vector_t w(AD.m); const bool debug = false; const bool full_debug = false; - if (debug) { settings_.log.printf("||b|| = %.16e\n", vector_norm2(b)); } + if (debug) { settings_.log.printf("||b|| = %.16e\n", simplex::vector_norm2(b)); } i_t solve_status = chol->solve(b, w); - if (debug) { settings_.log.printf("||w|| = %.16e\n", vector_norm2(w)); } + if (debug) { settings_.log.printf("||w|| = %.16e\n", simplex::vector_norm2(w)); } if (solve_status != 0) { settings_.log.printf("Linear solve failed in Sherman Morrison after ADAT solve\n"); return solve_status; @@ -1086,7 +1102,7 @@ class iteration_data_t { matrix_vector_multiply(ADAT, 1.0, M_col, -1.0, M_residual); settings_.log.printf( "|| A_sparse * D_sparse * A_sparse^T * M(:, k) - AD_dense(:, k) ||_2 = %e\n", - vector_norm2(M_residual)); + simplex::vector_norm2(M_residual)); } } // A_sparse * D_sparse * A_sparse^T * M = U = AD_dense @@ -1138,7 +1154,8 @@ class iteration_data_t { if (debug) { dense_vector_t H_residual = g; H.matrix_vector_multiply(1.0, y, -1.0, H_residual); - settings_.log.printf("|| H * y - g ||_2 = %e\n", vector_norm2(H_residual)); + settings_.log.printf("|| H * y - g ||_2 = %e\n", + simplex::vector_norm2(H_residual)); } // x = (A_sparse * D_sparse * A_sparse^T)^{-1} * (b - U * y) @@ -1157,14 +1174,15 @@ class iteration_data_t { dense_vector_t solve_residual = v; matrix_vector_multiply(ADAT, 1.0, x, -1.0, solve_residual); settings_.log.printf("|| A_sparse * D * A_sparse^T * x - v ||_2 = %e\n", - vector_norm2(solve_residual)); + simplex::vector_norm2(solve_residual)); } if (debug) { // Check U^T * x - y = 0; dense_vector_t residual_2 = y; AD_dense.transpose_multiply(1.0, x, -1.0, residual_2); - settings_.log.printf("|| U^T * x - y ||_2 = %e\n", vector_norm2(residual_2)); + settings_.log.printf("|| U^T * x - y ||_2 = %e\n", + simplex::vector_norm2(residual_2)); } if (debug) { @@ -1173,7 +1191,7 @@ class iteration_data_t { AD_dense.matrix_vector_multiply(1.0, y, -1.0, residual_1); matrix_vector_multiply(ADAT, 1.0, x, 1.0, residual_1); settings_.log.printf("|| A_sparse * D_sparse * A_sparse^T * x + U * y - b ||_2 = %e\n", - vector_norm2(residual_1)); + simplex::vector_norm2(residual_1)); } if (full_debug && debug) { @@ -1198,7 +1216,7 @@ class iteration_data_t { adat_multiply(-1.0, ei, 1.0, u); - max_error = std::max(max_error, vector_norm2(u)); + max_error = std::max(max_error, simplex::vector_norm2(u)); } settings_.log.printf("|| ADAT(e_i) - ADA^T * e_i ||_2 = %e\n", max_error); } @@ -1338,7 +1356,7 @@ class iteration_data_t { adat_multiply(-1.0, ei, 1.0, u); - max_error = std::max(max_error, vector_norm2(u)); + max_error = std::max(max_error, simplex::vector_norm2(u)); } settings_.log.printf( "|| (A_sparse * D_sparse * A_sparse^T + U * V^T) * e_i - ADA^T * e_i ||_2 = %e\n", @@ -1349,7 +1367,7 @@ class iteration_data_t { dense_vector_t total_residual = b; adat_multiply(1.0, x, -1.0, total_residual); settings_.log.printf("|| A * D * A^T * x - b ||_2 = %e\n", - vector_norm2(total_residual)); + simplex::vector_norm2(total_residual)); } // Now do some rounds of PCG @@ -1418,7 +1436,7 @@ class iteration_data_t { dense_vector_t dual_res = z_tilde; dual_res.axpy(-1.0, lp.objective, 1.0); cusparse_view.transpose_spmv(1.0, solution.y, 1.0, dual_res); - f_t dual_residual_norm = vector_norm_inf(dual_res, stream_view_); + f_t dual_residual_norm = simplex::vector_norm_inf(dual_res, stream_view_); #ifdef PRINT_INFO settings_.log.printf("Solution Dual residual: %e\n", dual_residual_norm); #endif @@ -1723,13 +1741,13 @@ class iteration_data_t { // v = alpha * A * Dinv * A^T * y + beta * v void gpu_adat_multiply(f_t alpha, const rmm::device_uvector& y, - detail::cusparse_dn_vec_descr_wrapper_t const& cusparse_y, + pdlp::cusparse_dn_vec_descr_wrapper_t const& cusparse_y, f_t beta, rmm::device_uvector& v, - detail::cusparse_dn_vec_descr_wrapper_t const& cusparse_v, + pdlp::cusparse_dn_vec_descr_wrapper_t const& cusparse_v, rmm::device_uvector& u, - detail::cusparse_dn_vec_descr_wrapper_t const& cusparse_u, + pdlp::cusparse_dn_vec_descr_wrapper_t const& cusparse_u, cusparse_view_t& cusparse_view, const rmm::device_uvector& d_inv_diag) const { @@ -1776,20 +1794,20 @@ class iteration_data_t { // u = A^T * y dense_vector_t u(n); - matrix_transpose_vector_multiply(A, 1.0, y, 0.0, u); - if (debug) { printf("||u|| = %.16e\n", vector_norm2(u)); } + simplex::matrix_transpose_vector_multiply(A, 1.0, y, 0.0, u); + if (debug) { printf("||u|| = %.16e\n", simplex::vector_norm2(u)); } // w = Dinv * u dense_vector_t w(n); inv_diag.pairwise_product(u, w); - if (debug) { printf("||inv_diag|| = %.16e\n", vector_norm2(inv_diag)); } + if (debug) { printf("||inv_diag|| = %.16e\n", simplex::vector_norm2(inv_diag)); } // v = alpha * A * w + beta * v = alpha * A * Dinv * A^T * y + beta * v matrix_vector_multiply(A, alpha, w, beta, v); if (debug) { - printf("||A|| = %.16e\n", vector_norm2(A.x)); - printf("||w|| = %.16e\n", vector_norm2(w)); - printf("||v|| = %.16e\n", vector_norm2(v)); + printf("||A|| = %.16e\n", simplex::vector_norm2(A.x)); + printf("||w|| = %.16e\n", simplex::vector_norm2(w)); + printf("||v|| = %.16e\n", simplex::vector_norm2(v)); } } @@ -1968,20 +1986,20 @@ class iteration_data_t { cusparse_info_t cusparse_info; cusparse_view_t cusparse_view_; - detail::cusparse_dn_vec_descr_wrapper_t cusparse_tmp4_; - detail::cusparse_dn_vec_descr_wrapper_t cusparse_h_; - detail::cusparse_dn_vec_descr_wrapper_t cusparse_dx_residual_; - detail::cusparse_dn_vec_descr_wrapper_t cusparse_dy_; - detail::cusparse_dn_vec_descr_wrapper_t cusparse_dx_residual_5_; - detail::cusparse_dn_vec_descr_wrapper_t cusparse_dx_residual_6_; - detail::cusparse_dn_vec_descr_wrapper_t cusparse_dx_; - detail::cusparse_dn_vec_descr_wrapper_t cusparse_dx_residual_3_; - detail::cusparse_dn_vec_descr_wrapper_t cusparse_dx_residual_4_; - detail::cusparse_dn_vec_descr_wrapper_t cusparse_r1_; - detail::cusparse_dn_vec_descr_wrapper_t cusparse_dual_residual_; - detail::cusparse_dn_vec_descr_wrapper_t cusparse_y_residual_; + pdlp::cusparse_dn_vec_descr_wrapper_t cusparse_tmp4_; + pdlp::cusparse_dn_vec_descr_wrapper_t cusparse_h_; + pdlp::cusparse_dn_vec_descr_wrapper_t cusparse_dx_residual_; + pdlp::cusparse_dn_vec_descr_wrapper_t cusparse_dy_; + pdlp::cusparse_dn_vec_descr_wrapper_t cusparse_dx_residual_5_; + pdlp::cusparse_dn_vec_descr_wrapper_t cusparse_dx_residual_6_; + pdlp::cusparse_dn_vec_descr_wrapper_t cusparse_dx_; + pdlp::cusparse_dn_vec_descr_wrapper_t cusparse_dx_residual_3_; + pdlp::cusparse_dn_vec_descr_wrapper_t cusparse_dx_residual_4_; + pdlp::cusparse_dn_vec_descr_wrapper_t cusparse_r1_; + pdlp::cusparse_dn_vec_descr_wrapper_t cusparse_dual_residual_; + pdlp::cusparse_dn_vec_descr_wrapper_t cusparse_y_residual_; // GPU ADAT multiply - detail::cusparse_dn_vec_descr_wrapper_t cusparse_u_; + pdlp::cusparse_dn_vec_descr_wrapper_t cusparse_u_; // Device vectors @@ -2116,7 +2134,7 @@ void cholesky_debug_check(const iteration_data_t& data, template barrier_solver_t::barrier_solver_t(const lp_problem_t& lp, - const presolve_info_t& presolve, + const simplex::presolve_info_t& presolve, const simplex_solver_settings_t& settings) : lp(lp), settings(settings), presolve_info(presolve), stream_view_(lp.handle_ptr->get_stream()) { @@ -2156,8 +2174,8 @@ int barrier_solver_t::initial_point(iteration_data_t& data) // LP block: e = 1, SOC block: e = (sqrt(2), 0, ..., 0) if (data.has_cones()) { const i_t cs = data.cone_start(); - const f_t norm_b = vector_norm_inf(lp.rhs); - const f_t norm_c = vector_norm_inf(lp.objective); + const f_t norm_b = simplex::vector_norm_inf(lp.rhs); + const f_t norm_c = simplex::vector_norm_inf(lp.objective); const f_t mu = std::sqrt((1.0 + norm_b) * (1.0 + norm_c)); const f_t sqrt2 = std::sqrt(2.0); const f_t x_soc = mu * sqrt2; @@ -2263,19 +2281,19 @@ int barrier_solver_t::initial_point(iteration_data_t& data) // rhs_x <- A * Dinv * F * u - b data.cusparse_view_.spmv(1.0, DinvFu, -1.0, rhs_x); #ifdef PRINT_INFO - settings.log.printf("||DinvFu|| = %e\n", vector_norm2(DinvFu)); + settings.log.printf("||DinvFu|| = %e\n", simplex::vector_norm2(DinvFu)); #endif // Solve A*Dinv*A'*q = A*Dinv*F*u - b #ifdef PRINT_INFO - settings.log.printf("||rhs_x|| = %.16e\n", vector_norm2(rhs_x)); + settings.log.printf("||rhs_x|| = %.16e\n", simplex::vector_norm2(rhs_x)); #endif // i_t solve_status = data.chol->solve(rhs_x, q); i_t solve_status = data.solve_adat(rhs_x, q); if (solve_status != 0) { return status; } #ifdef PRINT_INFO settings.log.printf("Initial solve status %d\n", solve_status); - settings.log.printf("||q|| = %.16e\n", vector_norm2(q)); + settings.log.printf("||q|| = %.16e\n", simplex::vector_norm2(q)); #endif // rhs_x <- A*Dinv*A'*q - rhs_x @@ -2283,7 +2301,7 @@ int barrier_solver_t::initial_point(iteration_data_t& data) // matrix_vector_multiply(data.ADAT, 1.0, q, -1.0, rhs_x); #ifdef PRINT_INFO settings.log.printf("|| A*Dinv*A'*q - (A*Dinv*F*u - b) || = %.16e\n", - vector_norm2(rhs_x)); + simplex::vector_norm2(rhs_x)); #endif // x = Dinv*(F*u - A'*q) @@ -2309,7 +2327,8 @@ int barrier_solver_t::initial_point(iteration_data_t& data) data.cusparse_view_.spmv(1.0, data.x, -1.0, init_primal_residual); data.handle_ptr->get_stream().synchronize(); #ifdef PRINT_INFO - settings.log.printf("||b - A * x||: %.16e\n", vector_norm2(init_primal_residual)); + settings.log.printf("||b - A * x||: %.16e\n", + simplex::vector_norm2(init_primal_residual)); #endif if (data.n_upper_bounds > 0) { @@ -2319,7 +2338,8 @@ int barrier_solver_t::initial_point(iteration_data_t& data) init_bound_residual[k] = lp.upper[j] - data.w[k] - data.x[j]; } #ifdef PRINT_INFO - settings.log.printf("|| u - w - x||: %e\n", vector_norm2(init_bound_residual)); + settings.log.printf("|| u - w - x||: %e\n", + simplex::vector_norm2(init_bound_residual)); #endif } @@ -2433,7 +2453,7 @@ int barrier_solver_t::initial_point(iteration_data_t& data) } #ifdef PRINT_INFO settings.log.printf("||A^T y + z - E*v - Q*x - c ||: %e\n", - vector_norm2(init_dual_residual)); + simplex::vector_norm2(init_dual_residual)); #endif // Make sure (w, x, v, z) > 0. Skip free variables being handled directly. data.w.ensure_positive(epsilon_adjust); @@ -2997,7 +3017,7 @@ i_t barrier_solver_t::gpu_compute_search_direction(iteration_data_t( + const f_t dx_residual_2_norm = simplex::device_custom_vector_norm_inf( thrust::make_transform_iterator( thrust::make_zip_iterator(data.d_inv_diag.data(), data.d_r1_.data(), data.d_dx_.data()), [] HD(thrust::tuple t) -> f_t { @@ -3076,7 +3096,7 @@ i_t barrier_solver_t::gpu_compute_search_direction(iteration_data_t(dx_residual_4, stream_view_); + const f_t dx_residual_4_norm = simplex::vector_norm_inf(dx_residual_4, stream_view_); max_residual = std::max(max_residual, dx_residual_4_norm); if (dx_residual_4_norm > 1e-2) { settings.log.printf("|| ADAT * dy - A * D^-1 * r1 - A * dx || = %.2e\n", dx_residual_4_norm); @@ -4107,8 +4127,8 @@ lp_status_t barrier_solver_t::solve(f_t start_time, lp_solution_t(data.b, stream_view_); - f_t norm_c = vector_norm_inf(data.c, stream_view_); + f_t norm_b = simplex::vector_norm_inf(data.b, stream_view_); + f_t norm_c = simplex::vector_norm_inf(data.c, stream_view_); f_t quad_objective = 0.0; if (data.Q.n > 0) { @@ -4448,4 +4468,4 @@ template class sparse_cholesky_cudss_t; template class iteration_data_t; #endif -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::barrier diff --git a/cpp/src/barrier/barrier.hpp b/cpp/src/barrier/barrier.hpp index b17cce3979..bdf3ba3f83 100644 --- a/cpp/src/barrier/barrier.hpp +++ b/cpp/src/barrier/barrier.hpp @@ -16,12 +16,12 @@ #include #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::barrier { -/** Validates SOC layout on an lp_problem_t before barrier presolve/solve. */ +/** Validates SOC layout on an simplex::lp_problem_t before barrier presolve/solve. */ template -bool validate_barrier_cone_layout(const lp_problem_t& problem, - const simplex_solver_settings_t& settings); +bool validate_barrier_cone_layout(const simplex::lp_problem_t& problem, + const simplex::simplex_solver_settings_t& settings); template class iteration_data_t; // Forward declare @@ -29,14 +29,14 @@ class iteration_data_t; // Forward declare template class barrier_solver_t { public: - barrier_solver_t(const lp_problem_t& lp, - const presolve_info_t& presolve, - const simplex_solver_settings_t& settings); - lp_status_t solve(f_t start_time, lp_solution_t& solution); + barrier_solver_t(const simplex::lp_problem_t& lp, + const simplex::presolve_info_t& presolve, + const simplex::simplex_solver_settings_t& settings); + simplex::lp_status_t solve(f_t start_time, simplex::lp_solution_t& solution); private: void my_pop_range(bool debug) const; - void create_Q(const lp_problem_t& lp, csc_matrix_t& Q); + void create_Q(const simplex::lp_problem_t& lp, simplex::csc_matrix_t& Q); int initial_point(iteration_data_t& data); void compute_residual_norms(const dense_vector_t& w, const dense_vector_t& x, @@ -98,22 +98,22 @@ class barrier_solver_t { f_t& max_residual); private: - lp_status_t check_for_suboptimal_solution(iteration_data_t& data, - f_t start_time, - i_t iter, - f_t& primal_objective, - f_t& primal_residual_norm, - f_t& dual_residual_norm, - f_t& complementarity_residual_norm, - f_t& relative_primal_residual, - f_t& relative_dual_residual, - f_t& relative_complementarity_residual, - lp_solution_t& solution); + simplex::lp_status_t check_for_suboptimal_solution(iteration_data_t& data, + f_t start_time, + i_t iter, + f_t& primal_objective, + f_t& primal_residual_norm, + f_t& dual_residual_norm, + f_t& complementarity_residual_norm, + f_t& relative_primal_residual, + f_t& relative_dual_residual, + f_t& relative_complementarity_residual, + simplex::lp_solution_t& solution); - const lp_problem_t& lp; - const simplex_solver_settings_t& settings; - const presolve_info_t& presolve_info; + const simplex::lp_problem_t& lp; + const simplex::simplex_solver_settings_t& settings; + const simplex::presolve_info_t& presolve_info; rmm::cuda_stream_view stream_view_; }; -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::barrier diff --git a/cpp/src/barrier/conjugate_gradient.hpp b/cpp/src/barrier/conjugate_gradient.hpp index ff29a071c3..21fe33ba3d 100644 --- a/cpp/src/barrier/conjugate_gradient.hpp +++ b/cpp/src/barrier/conjugate_gradient.hpp @@ -16,11 +16,11 @@ #include #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::barrier { template i_t preconditioned_conjugate_gradient(const T& op, - const simplex_solver_settings_t& settings, + const simplex::simplex_solver_settings_t& settings, const dense_vector_t& b, f_t tolerance, dense_vector_t& xinout) @@ -42,12 +42,12 @@ i_t preconditioned_conjugate_gradient(const T& op, dense_vector_t Ap(b.size()); i_t iter = 0; - f_t norm_residual = vector_norm2(residual); + f_t norm_residual = simplex::vector_norm2(residual); f_t initial_norm_residual = norm_residual; if (show_pcg_info) { settings.log.printf("PCG initial residual 2-norm %e inf-norm %e\n", norm_residual, - vector_norm_inf(residual)); + simplex::vector_norm_inf(residual)); } f_t rTy = residual.inner_product(y); @@ -62,7 +62,7 @@ i_t preconditioned_conjugate_gradient(const T& op, // Update residual = residual + alpha * Ap residual.axpy(alpha, Ap, 1.0); - f_t new_residual = vector_norm2(residual); + f_t new_residual = simplex::vector_norm2(residual); if (new_residual > 1.1 * norm_residual || new_residual > 1.1 * initial_norm_residual) { if (show_pcg_info) { settings.log.printf( @@ -78,7 +78,7 @@ i_t preconditioned_conjugate_gradient(const T& op, // residual = A*x - b residual = b; op.a_multiply(1.0, x, -1.0, residual); - norm_residual = vector_norm2(residual); + norm_residual = simplex::vector_norm2(residual); // Solve M y = r for y op.m_solve(residual, y); @@ -98,13 +98,13 @@ i_t preconditioned_conjugate_gradient(const T& op, settings.log.printf("PCG iter %3d 2-norm_residual %.2e inf-norm_residual %.2e\n", iter, norm_residual, - vector_norm_inf(residual)); + simplex::vector_norm_inf(residual)); } } residual = b; op.a_multiply(1.0, x, -1.0, residual); - norm_residual = vector_norm2(residual); + norm_residual = simplex::vector_norm2(residual); if (norm_residual < initial_norm_residual) { if (show_pcg_info) { settings.log.printf("PCG improved residual 2-norm %.2e/%.2e in %d iterations\n", @@ -120,4 +120,4 @@ i_t preconditioned_conjugate_gradient(const T& op, return iter; } -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::barrier diff --git a/cpp/src/barrier/cusparse_info.hpp b/cpp/src/barrier/cusparse_info.hpp index 105c470cd7..d88522e79a 100644 --- a/cpp/src/barrier/cusparse_info.hpp +++ b/cpp/src/barrier/cusparse_info.hpp @@ -17,7 +17,7 @@ #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::barrier { template struct cusparse_info_t { @@ -67,4 +67,4 @@ struct cusparse_info_t { size_t buffer_size_5_size; }; -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::barrier diff --git a/cpp/src/barrier/cusparse_view.cu b/cpp/src/barrier/cusparse_view.cu index b7673eacd5..2585084097 100644 --- a/cpp/src/barrier/cusparse_view.cu +++ b/cpp/src/barrier/cusparse_view.cu @@ -22,7 +22,7 @@ #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::barrier { #define CUDA_VER_12_4_UP (CUDART_VERSION >= 12040) @@ -126,7 +126,7 @@ static cusparseSpMVAlg_t get_spmv_alg(int num_rows) template cusparse_view_t::cusparse_view_t(raft::handle_t const* handle_ptr, - const csc_matrix_t& A) + const simplex::csc_matrix_t& A) : handle_ptr_(handle_ptr), A_offsets_(0, handle_ptr->get_stream()), A_indices_(0, handle_ptr->get_stream()), @@ -146,7 +146,7 @@ cusparse_view_t::cusparse_view_t(raft::handle_t const* handle_ptr, // TMP matrix data should already be on the GPU constexpr bool debug = false; if (debug) { printf("A hash: %zu\n", A.hash()); } - csr_matrix_t A_csr(A.m, A.n, 1); + simplex::csr_matrix_t A_csr(A.m, A.n, 1); A.to_compressed_row(A_csr); i_t rows = A_csr.m; i_t cols = A_csr.n; @@ -255,10 +255,10 @@ cusparse_view_t::~cusparse_view_t() } template -detail::cusparse_dn_vec_descr_wrapper_t cusparse_view_t::create_vector( +pdlp::cusparse_dn_vec_descr_wrapper_t cusparse_view_t::create_vector( rmm::device_uvector const& vec) { - detail::cusparse_dn_vec_descr_wrapper_t descr; + pdlp::cusparse_dn_vec_descr_wrapper_t descr; descr.create(vec.size(), const_cast(vec.data())); return descr; } @@ -282,16 +282,16 @@ void cusparse_view_t::spmv(f_t alpha, f_t beta, rmm::device_uvector& y) { - detail::cusparse_dn_vec_descr_wrapper_t x_cusparse = create_vector(x); - detail::cusparse_dn_vec_descr_wrapper_t y_cusparse = create_vector(y); + pdlp::cusparse_dn_vec_descr_wrapper_t x_cusparse = create_vector(x); + pdlp::cusparse_dn_vec_descr_wrapper_t y_cusparse = create_vector(y); spmv(alpha, x_cusparse, beta, y_cusparse); } template void cusparse_view_t::spmv(f_t alpha, - detail::cusparse_dn_vec_descr_wrapper_t const& x, + pdlp::cusparse_dn_vec_descr_wrapper_t const& x, f_t beta, - detail::cusparse_dn_vec_descr_wrapper_t const& y) + pdlp::cusparse_dn_vec_descr_wrapper_t const& y) { // Would be simpler if we could pass host data direclty but other cusparse calls with the same // handler depend on device data @@ -334,17 +334,16 @@ void cusparse_view_t::transpose_spmv(f_t alpha, f_t beta, rmm::device_uvector& y) { - detail::cusparse_dn_vec_descr_wrapper_t x_cusparse = create_vector(x); - detail::cusparse_dn_vec_descr_wrapper_t y_cusparse = create_vector(y); + pdlp::cusparse_dn_vec_descr_wrapper_t x_cusparse = create_vector(x); + pdlp::cusparse_dn_vec_descr_wrapper_t y_cusparse = create_vector(y); transpose_spmv(alpha, x_cusparse, beta, y_cusparse); } template -void cusparse_view_t::transpose_spmv( - f_t alpha, - detail::cusparse_dn_vec_descr_wrapper_t const& x, - f_t beta, - detail::cusparse_dn_vec_descr_wrapper_t const& y) +void cusparse_view_t::transpose_spmv(f_t alpha, + pdlp::cusparse_dn_vec_descr_wrapper_t const& x, + f_t beta, + pdlp::cusparse_dn_vec_descr_wrapper_t const& y) { // Would be simpler if we could pass host data direct;y but other cusparse calls with the same // handler depend on device data @@ -424,4 +423,4 @@ cusparse_view_t::transpose_spmv, std::alloca double beta, std::vector>& y); -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::barrier diff --git a/cpp/src/barrier/cusparse_view.hpp b/cpp/src/barrier/cusparse_view.hpp index 802fc90f8b..6af4813bc2 100644 --- a/cpp/src/barrier/cusparse_view.hpp +++ b/cpp/src/barrier/cusparse_view.hpp @@ -21,15 +21,16 @@ // Only owns data linked to the associated matrix // Associated dense vector should be owned by the calling object // This allows handling many different X Y vector along with one common matrix -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::barrier { + template class cusparse_view_t { public: // TMP matrix data should already be on the GPU and in CSR not CSC - cusparse_view_t(raft::handle_t const* handle_ptr, const csc_matrix_t& A); + cusparse_view_t(raft::handle_t const* handle_ptr, const simplex::csc_matrix_t& A); ~cusparse_view_t(); - detail::cusparse_dn_vec_descr_wrapper_t create_vector(rmm::device_uvector const& vec); + pdlp::cusparse_dn_vec_descr_wrapper_t create_vector(rmm::device_uvector const& vec); template void spmv(f_t alpha, @@ -38,9 +39,9 @@ class cusparse_view_t { std::vector& y); void spmv(f_t alpha, rmm::device_uvector const& x, f_t beta, rmm::device_uvector& y); void spmv(f_t alpha, - detail::cusparse_dn_vec_descr_wrapper_t const& x, + pdlp::cusparse_dn_vec_descr_wrapper_t const& x, f_t beta, - detail::cusparse_dn_vec_descr_wrapper_t const& y); + pdlp::cusparse_dn_vec_descr_wrapper_t const& y); template void transpose_spmv(f_t alpha, const std::vector& x, @@ -51,9 +52,9 @@ class cusparse_view_t { f_t beta, rmm::device_uvector& y); void transpose_spmv(f_t alpha, - detail::cusparse_dn_vec_descr_wrapper_t const& x, + pdlp::cusparse_dn_vec_descr_wrapper_t const& x, f_t beta, - detail::cusparse_dn_vec_descr_wrapper_t const& y); + pdlp::cusparse_dn_vec_descr_wrapper_t const& y); raft::handle_t const* handle_ptr_{nullptr}; @@ -72,4 +73,4 @@ class cusparse_view_t { rmm::device_scalar d_minus_one_; rmm::device_scalar d_zero_; }; -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::barrier diff --git a/cpp/src/barrier/dense_matrix.hpp b/cpp/src/barrier/dense_matrix.hpp index 7fd8258334..260c4a2957 100644 --- a/cpp/src/barrier/dense_matrix.hpp +++ b/cpp/src/barrier/dense_matrix.hpp @@ -12,7 +12,7 @@ #pragma once -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::barrier { template class dense_matrix_t { @@ -32,7 +32,7 @@ class dense_matrix_t { f_t operator()(i_t row, i_t col) const { return values[col * m + row]; } - void from_sparse(const csc_matrix_t& A, i_t sparse_column, i_t dense_column) + void from_sparse(const simplex::csc_matrix_t& A, i_t sparse_column, i_t dense_column) { for (i_t i = 0; i < m; i++) { this->operator()(i, dense_column) = 0.0; @@ -242,4 +242,4 @@ class dense_matrix_t { std::vector values; }; -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::barrier diff --git a/cpp/src/barrier/dense_vector.hpp b/cpp/src/barrier/dense_vector.hpp index 5d6f2b12ec..c444bbc8f0 100644 --- a/cpp/src/barrier/dense_vector.hpp +++ b/cpp/src/barrier/dense_vector.hpp @@ -12,7 +12,7 @@ #include #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::barrier { template > class dense_vector_t : public std::vector { @@ -56,7 +56,7 @@ class dense_vector_t : public std::vector { f_t minimum() const { const i_t n = this->size(); - f_t min_x = inf; + f_t min_x = simplex::inf; for (i_t i = 0; i < n; i++) { min_x = std::min(min_x, (*this)[i]); } @@ -66,7 +66,7 @@ class dense_vector_t : public std::vector { f_t maximum() const { const i_t n = this->size(); - f_t max_x = -inf; + f_t max_x = -simplex::inf; for (i_t i = 0; i < n; i++) { max_x = std::max(max_x, (*this)[i]); } @@ -186,7 +186,7 @@ class dense_vector_t : public std::vector { void ensure_positive(f_t epsilon_adjust, const std::vector& mask) { - f_t min_x = inf; + f_t min_x = simplex::inf; const i_t n = this->size(); for (i_t i = 0; i < n; i++) { if (mask[i]) { min_x = std::min(min_x, (*this)[i]); } @@ -246,4 +246,4 @@ std::vector copy(const std::vector& src) return std::vector(src.begin(), src.end()); } -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::barrier diff --git a/cpp/src/barrier/device_sparse_matrix.cu b/cpp/src/barrier/device_sparse_matrix.cu index 0b315b4846..8016b3466f 100644 --- a/cpp/src/barrier/device_sparse_matrix.cu +++ b/cpp/src/barrier/device_sparse_matrix.cu @@ -10,7 +10,14 @@ #include -namespace cuopt::linear_programming::dual_simplex { +// This translation unit provides out-of-line definitions and explicit +// instantiations of shared simplex sparse-matrix templates (csc_matrix_t, +// matrix_transpose_vector_multiply) specialized with barrier's +// PinnedHostAllocator. They must live in the simplex namespace (where the +// templates are declared), even though the file resides under barrier/. +namespace cuopt::mathematical_optimization::simplex { + +using cuopt::mathematical_optimization::barrier::PinnedHostAllocator; template template @@ -65,4 +72,4 @@ template void csc_matrix_t::scale_columns #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::barrier { template class device_csr_matrix_t; @@ -125,7 +125,7 @@ class device_csc_matrix_t { { } - device_csc_matrix_t(const csc_matrix_t& A, rmm::cuda_stream_view stream) + device_csc_matrix_t(const simplex::csc_matrix_t& A, rmm::cuda_stream_view stream) : m(A.m), n(A.n), nz_max(A.col_start[A.n]), @@ -146,16 +146,16 @@ class device_csc_matrix_t { nz_max = nnz; } - csc_matrix_t to_host(rmm::cuda_stream_view stream) + simplex::csc_matrix_t to_host(rmm::cuda_stream_view stream) { - csc_matrix_t A(m, n, nz_max); + simplex::csc_matrix_t A(m, n, nz_max); A.col_start = cuopt::host_copy(col_start, stream); A.i = cuopt::host_copy(i, stream); A.x = cuopt::host_copy(x, stream); return A; } - void copy(csc_matrix_t& A, rmm::cuda_stream_view stream) + void copy(simplex::csc_matrix_t& A, rmm::cuda_stream_view stream) { m = A.m; n = A.n; @@ -168,7 +168,7 @@ class device_csc_matrix_t { raft::copy(x.data(), A.x.data(), A.x.size(), stream); } - /** Same semantics as csc_matrix_t::to_compressed_row, entirely on device. */ + /** Same semantics as simplex::csc_matrix_t::to_compressed_row, entirely on device. */ void to_compressed_row(device_csr_matrix_t& Arow, rmm::cuda_stream_view stream) const; void form_col_index(rmm::cuda_stream_view stream) @@ -252,7 +252,7 @@ class device_csr_matrix_t { { } - device_csr_matrix_t(const csr_matrix_t& A, rmm::cuda_stream_view stream) + device_csr_matrix_t(const simplex::csr_matrix_t& A, rmm::cuda_stream_view stream) : m(A.m), n(A.n), nz_max(A.row_start[A.m]), @@ -273,16 +273,16 @@ class device_csr_matrix_t { nz_max = nnz; } - csr_matrix_t to_host(rmm::cuda_stream_view stream) + simplex::csr_matrix_t to_host(rmm::cuda_stream_view stream) { - csr_matrix_t A(m, n, nz_max); + simplex::csr_matrix_t A(m, n, nz_max); A.row_start = cuopt::host_copy(row_start, stream); A.j = cuopt::host_copy(j, stream); A.x = cuopt::host_copy(x, stream); return A; } - void copy(csr_matrix_t& A, rmm::cuda_stream_view stream) + void copy(simplex::csr_matrix_t& A, rmm::cuda_stream_view stream) { m = A.m; n = A.n; @@ -388,4 +388,4 @@ void device_csc_matrix_t::to_compressed_row(device_csr_matrix_t #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::barrier { // Functors for device operations (defined at namespace scope to avoid CUDA lambda restrictions) template @@ -413,4 +413,4 @@ f_t iterative_refinement(T& op, const rmm::device_uvector& b, rmm::device_u return iterative_refinement_gmres(op, b, x); } -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::barrier diff --git a/cpp/src/barrier/pinned_host_allocator.cu b/cpp/src/barrier/pinned_host_allocator.cu index 56a372bd46..797d679e2b 100644 --- a/cpp/src/barrier/pinned_host_allocator.cu +++ b/cpp/src/barrier/pinned_host_allocator.cu @@ -1,6 +1,6 @@ /* clang-format off */ /* - * SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. * SPDX-License-Identifier: Apache-2.0 */ /* clang-format on */ @@ -10,7 +10,7 @@ #include #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::barrier { template struct PinnedHostAllocator { @@ -45,8 +45,6 @@ bool operator!=(const PinnedHostAllocator&, const PinnedHostAllocator&) no #ifdef DUAL_SIMPLEX_INSTANTIATE_DOUBLE template class PinnedHostAllocator; -template double vector_norm_inf>( - const std::vector>& x); template bool operator==(const PinnedHostAllocator&, const PinnedHostAllocator&) noexcept; @@ -55,4 +53,19 @@ template bool operator!=(const PinnedHostAllocator&, #endif template class PinnedHostAllocator; -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::barrier + +namespace cuopt::mathematical_optimization::simplex { + +// Explicit instantiation of the shared simplex vector_math template with +// barrier's PinnedHostAllocator must live in simplex (the template's namespace). +#ifdef DUAL_SIMPLEX_INSTANTIATE_DOUBLE +template double +vector_norm_inf>( + const std::vector>& + x); +#endif + +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/barrier/pinned_host_allocator.hpp b/cpp/src/barrier/pinned_host_allocator.hpp index c236783ae7..7ab452cc10 100644 --- a/cpp/src/barrier/pinned_host_allocator.hpp +++ b/cpp/src/barrier/pinned_host_allocator.hpp @@ -9,7 +9,7 @@ #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::barrier { // Custom allocator to build pinned memory vector template @@ -32,4 +32,4 @@ bool operator!=(const PinnedHostAllocator&, const PinnedHostAllocator&) no template using pinned_dense_vector_t = dense_vector_t>; -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::barrier diff --git a/cpp/src/barrier/second_order_cone_kernels.cuh b/cpp/src/barrier/second_order_cone_kernels.cuh index 5a674fef70..39d0270e3a 100644 --- a/cpp/src/barrier/second_order_cone_kernels.cuh +++ b/cpp/src/barrier/second_order_cone_kernels.cuh @@ -52,7 +52,7 @@ // entries [cone_offsets[i], cone_offsets[i + 1]) belong to cone i. // ============================================================================= -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::barrier { inline constexpr int soc_block_size = 256; @@ -1078,4 +1078,4 @@ void compute_combined_cone_rhs_term(raft::device_span dx_aff, apply_w(scratch_cone, out, cones, stream); } -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::barrier diff --git a/cpp/src/barrier/second_order_cone_reduction.cuh b/cpp/src/barrier/second_order_cone_reduction.cuh index ada9fcfb6a..fb511ff622 100644 --- a/cpp/src/barrier/second_order_cone_reduction.cuh +++ b/cpp/src/barrier/second_order_cone_reduction.cuh @@ -32,7 +32,7 @@ #include #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::barrier { template class sparse_cholesky_base_t { public: virtual ~sparse_cholesky_base_t() = default; - virtual i_t analyze(const csc_matrix_t& A_in) = 0; - virtual i_t factorize(const csc_matrix_t& A_in) = 0; + virtual i_t analyze(const simplex::csc_matrix_t& A_in) = 0; + virtual i_t factorize(const simplex::csc_matrix_t& A_in) = 0; virtual i_t analyze(device_csr_matrix_t& A_in) = 0; virtual i_t factorize(device_csr_matrix_t& A_in) = 0; virtual i_t solve(const dense_vector_t& b, dense_vector_t& x) = 0; @@ -135,7 +135,7 @@ template class sparse_cholesky_cudss_t : public sparse_cholesky_base_t { public: sparse_cholesky_cudss_t(raft::handle_t const* handle_ptr, - const simplex_solver_settings_t& settings, + const simplex::simplex_solver_settings_t& settings, i_t size) : handle_ptr_(handle_ptr), n(size), @@ -157,11 +157,10 @@ class sparse_cholesky_cudss_t : public sparse_cholesky_base_t { if (CUDART_VERSION >= 13000 && settings_.concurrent_halt != nullptr && settings_.num_gpus == 1) { - cuGetErrorString_func = cuopt::detail::get_driver_entry_point("cuGetErrorString"); + cuGetErrorString_func = cuopt::get_driver_entry_point("cuGetErrorString"); // 1. Set up the GPU resources CUdevResource initial_device_GPU_resources = {}; - auto cuDeviceGetDevResource_func = - cuopt::detail::get_driver_entry_point("cuDeviceGetDevResource"); + auto cuDeviceGetDevResource_func = cuopt::get_driver_entry_point("cuDeviceGetDevResource"); CU_CHECK(reinterpret_cast(cuDeviceGetDevResource_func)( handle_ptr_->get_device(), &initial_device_GPU_resources, CU_DEV_RESOURCE_TYPE_SM), reinterpret_cast(cuGetErrorString_func)); @@ -180,7 +179,7 @@ class sparse_cholesky_cudss_t : public sparse_cholesky_base_t { auto barrier_sms = raft::alignTo(static_cast(total_SMs * 0.75f), 8); CUdevResource resource; auto cuDevSmResourceSplitByCount_func = - cuopt::detail::get_driver_entry_point("cuDevSmResourceSplitByCount"); + cuopt::get_driver_entry_point("cuDevSmResourceSplitByCount"); auto n_groups = 1u; auto use_flags = CU_DEV_SM_RESOURCE_SPLIT_IGNORE_SM_COSCHEDULING; // or 0 CU_CHECK( @@ -202,7 +201,7 @@ class sparse_cholesky_cudss_t : public sparse_cholesky_base_t { auto constexpr const n_resource_desc = 1; CUdevResourceDesc resource_desc; auto cuDevResourceGenerateDesc_func = - cuopt::detail::get_driver_entry_point("cuDevResourceGenerateDesc"); + cuopt::get_driver_entry_point("cuDevResourceGenerateDesc"); CU_CHECK(reinterpret_cast( cuDevResourceGenerateDesc_func)(&resource_desc, &resource, n_resource_desc), reinterpret_cast(cuGetErrorString_func)); @@ -225,15 +224,14 @@ class sparse_cholesky_cudss_t : public sparse_cholesky_base_t { cudaStream_t cuda_stream = handle_ptr_->get_stream(); cudaError_t priority_result = cudaStreamGetPriority(cuda_stream, &stream_priority); RAFT_CUDA_TRY(priority_result); - auto cuGreenCtxCreate_func = cuopt::detail::get_driver_entry_point("cuGreenCtxCreate"); + auto cuGreenCtxCreate_func = cuopt::get_driver_entry_point("cuGreenCtxCreate"); CU_CHECK(reinterpret_cast(cuGreenCtxCreate_func)( &barrier_green_ctx, resource_desc, handle_ptr_->get_device(), CU_GREEN_CTX_DEFAULT_STREAM), reinterpret_cast(cuGetErrorString_func)); - auto cuGreenCtxStreamCreate_func = - cuopt::detail::get_driver_entry_point("cuGreenCtxStreamCreate"); + auto cuGreenCtxStreamCreate_func = cuopt::get_driver_entry_point("cuGreenCtxStreamCreate"); CU_CHECK(reinterpret_cast(cuGreenCtxStreamCreate_func)( &stream, barrier_green_ctx, CU_STREAM_NON_BLOCKING, stream_priority), reinterpret_cast(cuGetErrorString_func)); @@ -374,10 +372,10 @@ class sparse_cholesky_cudss_t : public sparse_cholesky_base_t { CUDA_CALL_AND_CHECK_EXIT(cudaStreamSynchronize(stream), "cudaStreamSynchronize"); #if CUDART_VERSION >= 13000 if (settings_.concurrent_halt != nullptr && settings_.num_gpus == 1) { - auto cuStreamDestroy_func = cuopt::detail::get_driver_entry_point("cuStreamDestroy"); + auto cuStreamDestroy_func = cuopt::get_driver_entry_point("cuStreamDestroy"); CU_CHECK(reinterpret_cast(cuStreamDestroy_func)(stream), reinterpret_cast(cuGetErrorString_func)); - auto cuGreenCtxDestroy_func = cuopt::detail::get_driver_entry_point("cuGreenCtxDestroy"); + auto cuGreenCtxDestroy_func = cuopt::get_driver_entry_point("cuGreenCtxDestroy"); CU_CHECK( reinterpret_cast(cuGreenCtxDestroy_func)(barrier_green_ctx), reinterpret_cast(cuGetErrorString_func)); @@ -392,8 +390,8 @@ class sparse_cholesky_cudss_t : public sparse_cholesky_base_t { #ifdef WRITE_MATRIX_MARKET { - csr_matrix_t Arow_host = Arow.to_host(Arow.row_start.stream()); - csc_matrix_t A_col(Arow_host.m, Arow_host.n, 1); + simplex::csr_matrix_t Arow_host = Arow.to_host(Arow.row_start.stream()); + simplex::csc_matrix_t A_col(Arow_host.m, Arow_host.n, 1); Arow_host.to_compressed_col(A_col); FILE* fid = fopen("A_to_factorize.mtx", "w"); settings_.log.printf("writing matrix matrix\n"); @@ -475,7 +473,7 @@ class sparse_cholesky_cudss_t : public sparse_cholesky_base_t { } // Perform symbolic analysis - f_t start_symbolic = tic(); + f_t start_symbolic = simplex::tic(); f_t start_symbolic_factor; { @@ -492,9 +490,9 @@ class sparse_cholesky_cudss_t : public sparse_cholesky_base_t { status); return -1; } - f_t reordering_time = toc(start_symbolic); + f_t reordering_time = simplex::toc(start_symbolic); settings_.log.printf("Reordering time : %.2fs\n", reordering_time); - start_symbolic_factor = tic(); + start_symbolic_factor = simplex::tic(); status = cudssExecute( handle, CUDSS_PHASE_SYMBOLIC_FACTORIZATION, solverConfig, solverData, A, cudss_x, cudss_b); @@ -510,9 +508,9 @@ class sparse_cholesky_cudss_t : public sparse_cholesky_base_t { } } RAFT_CUDA_TRY(cudaStreamSynchronize(stream)); - f_t symbolic_factorization_time = toc(start_symbolic_factor); + f_t symbolic_factorization_time = simplex::toc(start_symbolic_factor); settings_.log.printf("Symbolic factorization time : %.2fs\n", symbolic_factorization_time); - settings_.log.printf("Total symbolic time : %.2fs\n", toc(start_symbolic)); + settings_.log.printf("Total symbolic time : %.2fs\n", simplex::toc(start_symbolic)); int64_t lu_nz = 0; size_t size_written = 0; CUDSS_CALL_AND_CHECK( @@ -534,8 +532,8 @@ class sparse_cholesky_cudss_t : public sparse_cholesky_base_t { // #define PRINT_MATRIX_NORM #ifdef PRINT_MATRIX_NORM cudaStreamSynchronize(stream); - csr_matrix_t Arow_host = Arow.to_host(Arow.row_start.stream()); - csc_matrix_t A_col(Arow_host.m, Arow_host.n, 1); + simplex::csr_matrix_t Arow_host = Arow.to_host(Arow.row_start.stream()); + simplex::csc_matrix_t A_col(Arow_host.m, Arow_host.n, 1); Arow_host.to_compressed_col(A_col); settings_.log.printf( "before factorize || A to factor|| = %.16e hash: %zu\n", A_col.norm1(), A_col.hash()); @@ -553,7 +551,7 @@ class sparse_cholesky_cudss_t : public sparse_cholesky_base_t { CUDSS_CALL_AND_CHECK( cudssMatrixSetValues(A, Arow.x.data()), status, "cudssMatrixSetValues for A"); - f_t start_numeric = tic(); + f_t start_numeric = simplex::tic(); status = cudssExecute( handle, CUDSS_PHASE_FACTORIZATION, solverConfig, solverData, A, cudss_x, cudss_b); if (settings_.concurrent_halt != nullptr && *settings_.concurrent_halt == 1) { @@ -571,7 +569,7 @@ class sparse_cholesky_cudss_t : public sparse_cholesky_base_t { RAFT_CUDA_TRY(cudaStreamSynchronize(stream)); #endif - f_t numeric_time = toc(start_numeric); + f_t numeric_time = simplex::toc(start_numeric); if (settings_.concurrent_halt != nullptr && *settings_.concurrent_halt == 1) { return CONCURRENT_HALT_RETURN; } @@ -601,9 +599,9 @@ class sparse_cholesky_cudss_t : public sparse_cholesky_base_t { return 0; } - i_t analyze(const csc_matrix_t& A_in) override + i_t analyze(const simplex::csc_matrix_t& A_in) override { - csr_matrix_t Arow(A_in.n, A_in.m, A_in.col_start[A_in.n]); + simplex::csr_matrix_t Arow(A_in.n, A_in.m, A_in.col_start[A_in.n]); #ifdef WRITE_MATRIX_MARKET FILE* fid = fopen("A.mtx", "w"); @@ -694,18 +692,18 @@ class sparse_cholesky_cudss_t : public sparse_cholesky_base_t { if (settings_.concurrent_halt != nullptr && *settings_.concurrent_halt == 1) { return CONCURRENT_HALT_RETURN; } - f_t start_analysis = tic(); + f_t start_analysis = simplex::tic(); CUDSS_CALL_AND_CHECK( cudssExecute(handle, CUDSS_PHASE_REORDERING, solverConfig, solverData, A, cudss_x, cudss_b), status, "cudssExecute for reordering"); - f_t reorder_time = toc(start_analysis); + f_t reorder_time = simplex::toc(start_analysis); if (settings_.concurrent_halt != nullptr && *settings_.concurrent_halt == 1) { return CONCURRENT_HALT_RETURN; } - f_t start_symbolic = tic(); + f_t start_symbolic = simplex::tic(); CUDSS_CALL_AND_CHECK( cudssExecute( @@ -713,8 +711,8 @@ class sparse_cholesky_cudss_t : public sparse_cholesky_base_t { status, "cudssExecute for symbolic factorization"); - f_t symbolic_time = toc(start_symbolic); - f_t analysis_time = toc(start_analysis); + f_t symbolic_time = simplex::toc(start_symbolic); + f_t analysis_time = simplex::toc(start_analysis); settings_.log.printf("Symbolic factorization time : %.2fs\n", symbolic_time); if (settings_.concurrent_halt != nullptr && *settings_.concurrent_halt == 1) { RAFT_CUDA_TRY(cudaStreamSynchronize(stream)); @@ -735,9 +733,9 @@ class sparse_cholesky_cudss_t : public sparse_cholesky_base_t { return 0; } - i_t factorize(const csc_matrix_t& A_in) override + i_t factorize(const simplex::csc_matrix_t& A_in) override { - csr_matrix_t Arow(A_in.n, A_in.m, A_in.col_start[A_in.n]); + simplex::csr_matrix_t Arow(A_in.n, A_in.m, A_in.col_start[A_in.n]); A_in.to_compressed_row(Arow); if (A_in.n != n) { settings_.log.printf("Error A in n %d != size %d\n", A_in.n, n); } @@ -759,14 +757,14 @@ class sparse_cholesky_cudss_t : public sparse_cholesky_base_t { CUDSS_CALL_AND_CHECK( cudssMatrixSetValues(A, csr_values_d), status, "cudssMatrixSetValues for A"); - f_t start_numeric = tic(); + f_t start_numeric = simplex::tic(); CUDSS_CALL_AND_CHECK( cudssExecute( handle, CUDSS_PHASE_FACTORIZATION, solverConfig, solverData, A, cudss_x, cudss_b), status, "cudssExecute for factorization"); - f_t numeric_time = toc(start_numeric); + f_t numeric_time = simplex::toc(start_numeric); if (settings_.concurrent_halt != nullptr && *settings_.concurrent_halt == 1) { return CONCURRENT_HALT_RETURN; } @@ -853,9 +851,9 @@ class sparse_cholesky_cudss_t : public sparse_cholesky_base_t { raft::copy(x_host.data(), x.data(), n, stream); cudaStreamSynchronize(stream); settings_.log.printf("RHS norm %.16e, hash: %zu, Solution norm %.16e, hash: %zu\n", - vector_norm2(b_host), + simplex::vector_norm2(b_host), compute_hash(b_host), - vector_norm2(x_host), + simplex::vector_norm2(x_host), compute_hash(x_host)); #endif @@ -890,10 +888,10 @@ class sparse_cholesky_cudss_t : public sparse_cholesky_base_t { f_t* x_values_d; f_t* b_values_d; - const simplex_solver_settings_t& settings_; + const simplex::simplex_solver_settings_t& settings_; CUgreenCtx barrier_green_ctx; CUstream stream; void* cuGetErrorString_func; }; -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::barrier diff --git a/cpp/src/barrier/sparse_matrix_kernels.cuh b/cpp/src/barrier/sparse_matrix_kernels.cuh index 4727c12ec8..3a220111f6 100644 --- a/cpp/src/barrier/sparse_matrix_kernels.cuh +++ b/cpp/src/barrier/sparse_matrix_kernels.cuh @@ -10,7 +10,7 @@ #include #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::barrier { template void initialize_cusparse_data(raft::handle_t const* handle, @@ -163,4 +163,4 @@ void multiply_kernels(raft::handle_t const* handle, handle->sync_stream(); } -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::barrier diff --git a/cpp/src/barrier/translate_soc.hpp b/cpp/src/barrier/translate_soc.hpp index 3209dee3c6..aac7da2025 100644 --- a/cpp/src/barrier/translate_soc.hpp +++ b/cpp/src/barrier/translate_soc.hpp @@ -8,7 +8,7 @@ #pragma once #include -#include +#include #include #include @@ -26,7 +26,7 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::barrier { /** Convert MPS >= ('G') quadratic row to <= ('L') form on a working copy for SOC conversion. */ template @@ -56,8 +56,8 @@ void convert_quadratic_constraints_to_second_order_cones( i_t n, const std::vector::quadratic_constraint_t>& qcs, - dual_simplex::csr_matrix_t& csr_A, - dual_simplex::user_problem_t& user_problem) + simplex::csr_matrix_t& csr_A, + simplex::user_problem_t& user_problem) { cuopt_expects(!qcs.empty(), error_type_t::ValidationError, @@ -624,7 +624,7 @@ void convert_quadratic_constraints_to_second_order_cones( } } - dual_simplex::csc_matrix_t H_csc(n_local, n_local, h_nnz); + simplex::csc_matrix_t H_csc(n_local, n_local, h_nnz); { i_t p = 0; for (i_t j = 0; j < n_local; j++) { @@ -642,14 +642,14 @@ void convert_quadratic_constraints_to_second_order_cones( } // Step 2: Factorize H = P * L * D * L^T * P^T - dual_simplex::simplex_solver_settings_t ldlt_settings; + simplex::simplex_solver_settings_t ldlt_settings; std::vector ldlt_perm; - dual_simplex::csc_matrix_t L_factor(n, n, 1); + simplex::csc_matrix_t L_factor(n, n, 1); std::vector D_factor; f_t ldlt_work = 0; - f_t ldlt_start = dual_simplex::tic(); + f_t ldlt_start = simplex::tic(); - i_t rank = dual_simplex::right_looking_ldlt( + i_t rank = simplex::right_looking_ldlt( H_csc, ldlt_settings, f_t(1e-12), ldlt_start, ldlt_perm, L_factor, D_factor, ldlt_work); // ldlt_settings uses default time_limit=inf and concurrent_halt=nullptr, @@ -684,8 +684,7 @@ void convert_quadratic_constraints_to_second_order_cones( user_problem.objective.resize(var_base + n_new_vars, 0); user_problem.lower.resize(var_base + n_new_vars, neg_inf); user_problem.upper.resize(var_base + n_new_vars, pos_inf); - user_problem.var_types.resize(var_base + n_new_vars, - dual_simplex::variable_type_t::CONTINUOUS); + user_problem.var_types.resize(var_base + n_new_vars, simplex::variable_type_t::CONTINUOUS); if (!user_problem.col_names.empty()) { user_problem.col_names.resize(var_base + n_new_vars); for (i_t k = 0; k < r; k++) { @@ -707,7 +706,7 @@ void convert_quadratic_constraints_to_second_order_cones( user_problem.row_sense.resize(m_before + n_new_rows); if (!user_problem.row_names.empty()) { user_problem.row_names.resize(m_before + n_new_rows); } - dual_simplex::sparse_vector_t eq_row; + simplex::sparse_vector_t eq_row; eq_row.n = csr_A.n; // y-linking rows: y_k - sqrt(D[k]) * [row k of L^T P] * x = 0 @@ -820,7 +819,7 @@ void convert_quadratic_constraints_to_second_order_cones( user_problem.lower.resize(n_aug, -inf); user_problem.upper.resize(n_aug, inf); user_problem.var_types.resize( - n_aug, cuopt::linear_programming::dual_simplex::variable_type_t::CONTINUOUS); + n_aug, cuopt::mathematical_optimization::simplex::variable_type_t::CONTINUOUS); if (!user_problem.col_names.empty()) { user_problem.col_names.resize(n_aug); } for (size_t qc_i = 0; qc_i < qcs.size(); ++qc_i) { @@ -838,7 +837,7 @@ void convert_quadratic_constraints_to_second_order_cones( if (!user_problem.row_names.empty()) { user_problem.row_names.resize(m_aug); } csr_A.n = std::max(csr_A.n, n_aug); - dual_simplex::sparse_vector_t eq_row; + simplex::sparse_vector_t eq_row; eq_row.n = csr_A.n; for (size_t qc_i = 0; qc_i < qcs.size(); ++qc_i) { @@ -891,18 +890,18 @@ void convert_quadratic_constraints_to_second_order_cones( for (const rotated_soc_t& rc : rotated_cones) { cuopt_expects(user_problem.var_types[rc.head0] == - cuopt::linear_programming::dual_simplex::variable_type_t::CONTINUOUS, + cuopt::mathematical_optimization::simplex::variable_type_t::CONTINUOUS, error_type_t::ValidationError, "Rotated SOC head variables must be continuous"); if (!rc.head1_is_constant_half) { cuopt_expects(user_problem.var_types[rc.head1] == - cuopt::linear_programming::dual_simplex::variable_type_t::CONTINUOUS, + cuopt::mathematical_optimization::simplex::variable_type_t::CONTINUOUS, error_type_t::ValidationError, "Rotated SOC head variables must be continuous"); } for (const i_t t : rc.tails) { cuopt_expects(user_problem.var_types[t] == - cuopt::linear_programming::dual_simplex::variable_type_t::CONTINUOUS, + cuopt::mathematical_optimization::simplex::variable_type_t::CONTINUOUS, error_type_t::ValidationError, "Rotated SOC tail variables must be continuous"); } @@ -924,7 +923,7 @@ void convert_quadratic_constraints_to_second_order_cones( user_problem.lower.resize(n_prob, -inf); user_problem.upper.resize(n_prob, inf); user_problem.var_types.resize( - n_prob, cuopt::linear_programming::dual_simplex::variable_type_t::CONTINUOUS); + n_prob, cuopt::mathematical_optimization::simplex::variable_type_t::CONTINUOUS); if (!user_problem.col_names.empty()) { user_problem.col_names.resize(n_prob); for (i_t j = n_old; j < n_prob; ++j) { @@ -946,7 +945,7 @@ void convert_quadratic_constraints_to_second_order_cones( csr_A.n = n_prob; - dual_simplex::sparse_vector_t eq_row; + simplex::sparse_vector_t eq_row; size_t ri = 0; i_t slack_base = n_old; i_t row_idx = m_old; @@ -1065,7 +1064,7 @@ void convert_quadratic_constraints_to_second_order_cones( user_problem.lower.resize(n_new, -std::numeric_limits::infinity()); user_problem.upper.resize(n_new, std::numeric_limits::infinity()); user_problem.var_types.resize( - n_new, cuopt::linear_programming::dual_simplex::variable_type_t::CONTINUOUS); + n_new, cuopt::mathematical_optimization::simplex::variable_type_t::CONTINUOUS); if (!user_problem.col_names.empty()) { user_problem.col_names.resize(n_new); } for (const auto& [alias, original] : cone_alias_pairs) { @@ -1085,7 +1084,7 @@ void convert_quadratic_constraints_to_second_order_cones( if (!user_problem.row_names.empty()) { user_problem.row_names.resize(m_new); } csr_A.n = n_new; - dual_simplex::sparse_vector_t eq_row; + simplex::sparse_vector_t eq_row; eq_row.n = n_new; i_t row_idx = m_old; for (const auto& [alias, original] : cone_alias_pairs) { @@ -1152,7 +1151,7 @@ void convert_quadratic_constraints_to_second_order_cones( user_problem.lower.resize(n_new, neg_inf); user_problem.upper.resize(n_new, pos_inf); user_problem.var_types.resize( - n_new, cuopt::linear_programming::dual_simplex::variable_type_t::CONTINUOUS); + n_new, cuopt::mathematical_optimization::simplex::variable_type_t::CONTINUOUS); if (!user_problem.col_names.empty()) { user_problem.col_names.resize(n_new); } for (const auto& [alias, original] : bound_split_pairs) { @@ -1168,7 +1167,7 @@ void convert_quadratic_constraints_to_second_order_cones( if (!user_problem.row_names.empty()) { user_problem.row_names.resize(m_new); } csr_A.n = n_new; - dual_simplex::sparse_vector_t eq_row; + simplex::sparse_vector_t eq_row; eq_row.n = n_new; i_t row_idx = m_old; for (const auto& [alias, original] : bound_split_pairs) { @@ -1332,8 +1331,7 @@ void convert_quadratic_constraints_to_second_order_cones( */ template void project_barrier_solution_to_model_variables( - const dual_simplex::user_problem_t& user_problem, - dual_simplex::lp_solution_t& solution) + const simplex::user_problem_t& user_problem, simplex::lp_solution_t& solution) { const i_t n_original = user_problem.original_num_cols; if (n_original <= 0) { return; } @@ -1352,4 +1350,4 @@ void project_barrier_solution_to_model_variables( solution.z = std::move(model_z); } -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::barrier diff --git a/cpp/src/branch_and_bound/bb_event.hpp b/cpp/src/branch_and_bound/bb_event.hpp index b5ef80a167..d07d52e4a0 100644 --- a/cpp/src/branch_and_bound/bb_event.hpp +++ b/cpp/src/branch_and_bound/bb_event.hpp @@ -12,7 +12,7 @@ #include #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::mip { // Event types generated by B&B workers during deterministic execution enum class bb_event_type_t : int8_t { @@ -147,4 +147,4 @@ struct bb_event_batch_t { bool empty() const { return events.empty(); } }; -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/branch_and_bound/branch_and_bound.cpp b/cpp/src/branch_and_bound/branch_and_bound.cpp index 33641a5fb3..806f2850ce 100644 --- a/cpp/src/branch_and_bound/branch_and_bound.cpp +++ b/cpp/src/branch_and_bound/branch_and_bound.cpp @@ -11,7 +11,7 @@ #include #include -#include // benchmark_info_t +#include // benchmark_info_t #include #include @@ -44,7 +44,35 @@ #include #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::mip { + +using simplex::basis_update_mpf_t; +using simplex::bounds_strengthening_t; +using simplex::compute_objective; +using simplex::compute_user_objective; +using simplex::crossover_status_t; +using simplex::crush_primal_solution; +using simplex::csr_matrix_t; +using simplex::decompress_vstatus; +using simplex::dual_phase2_with_advanced_basis; +using simplex::dual_status_t; +using simplex::inf; +using simplex::logger_t; +using simplex::lp_problem_t; +using simplex::lp_solution_t; +using simplex::lp_status_t; +using simplex::matrix_vector_multiply; +using simplex::mip_solution_t; +using simplex::simplex_solver_settings_t; +using simplex::solve_linear_program_with_advanced_basis; +using simplex::tic; +using simplex::toc; +using simplex::uncrush_primal_solution; +using simplex::user_problem_t; +using simplex::variable_status_t; +using simplex::variable_type_t; +using simplex::vector_norm_inf; + namespace { template @@ -144,28 +172,28 @@ void set_uninitialized_steepest_edge_norms(const lp_problem_t& lp, } } -dual::status_t convert_lp_status_to_dual_status(lp_status_t status) +dual_status_t convert_lp_status_to_dual_status(lp_status_t status) { if (status == lp_status_t::OPTIMAL) { - return dual::status_t::OPTIMAL; + return dual_status_t::OPTIMAL; } else if (status == lp_status_t::INFEASIBLE) { - return dual::status_t::DUAL_UNBOUNDED; + return dual_status_t::DUAL_UNBOUNDED; } else if (status == lp_status_t::ITERATION_LIMIT) { - return dual::status_t::ITERATION_LIMIT; + return dual_status_t::ITERATION_LIMIT; } else if (status == lp_status_t::TIME_LIMIT) { - return dual::status_t::TIME_LIMIT; + return dual_status_t::TIME_LIMIT; } else if (status == lp_status_t::WORK_LIMIT) { - return dual::status_t::WORK_LIMIT; + return dual_status_t::WORK_LIMIT; } else if (status == lp_status_t::NUMERICAL_ISSUES) { - return dual::status_t::NUMERICAL; + return dual_status_t::NUMERICAL; } else if (status == lp_status_t::CUTOFF) { - return dual::status_t::CUTOFF; + return dual_status_t::CUTOFF; } else if (status == lp_status_t::CONCURRENT_LIMIT) { - return dual::status_t::CONCURRENT_LIMIT; + return dual_status_t::CONCURRENT_LIMIT; } else if (status == lp_status_t::UNSET) { - return dual::status_t::UNSET; + return dual_status_t::UNSET; } else { - return dual::status_t::NUMERICAL; + return dual_status_t::NUMERICAL; } } @@ -223,7 +251,7 @@ branch_and_bound_t::branch_and_bound_t( const simplex_solver_settings_t& solver_settings, f_t start_time, const probing_implied_bound_t& probing_implied_bound, - std::shared_ptr> clique_table, + std::shared_ptr> clique_table, mip_symmetry_t* symmetry) : original_problem_(user_problem), settings_(solver_settings), @@ -244,8 +272,9 @@ branch_and_bound_t::branch_and_bound_t( original_problem_.A.print_matrix(); #endif - dualize_info_t dualize_info; - convert_user_problem(original_problem_, settings_, original_lp_, new_slacks_, dualize_info); + simplex::dualize_info_t dualize_info; + simplex::convert_user_problem( + original_problem_, settings_, original_lp_, new_slacks_, dualize_info); full_variable_types(original_problem_, original_lp_, var_types_); // Check slack @@ -579,11 +608,11 @@ bool branch_and_bound_t::repair_solution(const std::vector& edge_ lp_settings.inside_mip = 2; std::vector leaf_edge_norms = edge_norms; // should probably set the cut off here lp_settings.cut_off - dual::status_t lp_status = dual_phase2( + dual_status_t lp_status = simplex::dual_phase2( 2, 0, lp_start_time, repair_lp, lp_settings, vstatus, lp_solution, iter, leaf_edge_norms); repaired_solution = lp_solution.x; - if (lp_status == dual::status_t::OPTIMAL) { + if (lp_status == dual_status_t::OPTIMAL) { f_t primal_error; f_t bound_error; i_t num_fractional; @@ -1201,7 +1230,7 @@ std::pair branch_and_bound_t::updat mip_node_t* node_ptr, search_tree_t& search_tree, WorkerT* worker, - dual::status_t lp_status, + dual_status_t lp_status, Policy& policy) { const f_t abs_fathom_tol = settings_.absolute_mip_gap_tol / 10; @@ -1214,20 +1243,20 @@ std::pair branch_and_bound_t::updat worker->recompute_basis = true; worker->recompute_bounds = true; - if (lp_status == dual::status_t::DUAL_UNBOUNDED) { + if (lp_status == dual_status_t::DUAL_UNBOUNDED) { node_ptr->lower_bound = inf; policy.graphviz(search_tree, node_ptr, "infeasible", 0.0); search_tree.update(node_ptr, node_status_t::INFEASIBLE); status = node_status_t::INFEASIBLE; - } else if (lp_status == dual::status_t::CUTOFF) { + } else if (lp_status == dual_status_t::CUTOFF) { f_t leaf_obj = compute_objective(leaf_problem, leaf_solution.x); node_ptr->lower_bound = upper_bound; policy.graphviz(search_tree, node_ptr, "cut off", leaf_obj); search_tree.update(node_ptr, node_status_t::FATHOMED); status = node_status_t::FATHOMED; - } else if (lp_status == dual::status_t::OPTIMAL) { + } else if (lp_status == dual_status_t::OPTIMAL) { std::vector leaf_fractional; i_t num_frac = fractional_variables(settings_, leaf_solution.x, var_types_, leaf_fractional); @@ -1305,10 +1334,10 @@ std::pair branch_and_bound_t::updat search_tree.update(node_ptr, node_status_t::FATHOMED); status = node_status_t::FATHOMED; } - } else if (lp_status == dual::status_t::TIME_LIMIT) { + } else if (lp_status == dual_status_t::TIME_LIMIT) { policy.graphviz(search_tree, node_ptr, "timeout", 0.0); status = node_status_t::PENDING; - } else if (lp_status == dual::status_t::WORK_LIMIT) { + } else if (lp_status == dual_status_t::WORK_LIMIT) { policy.graphviz(search_tree, node_ptr, "work limit", 0.0); status = node_status_t::PENDING; } else { @@ -1327,7 +1356,7 @@ std::pair branch_and_bound_t::updat mip_node_t* node_ptr, search_tree_t& search_tree, branch_and_bound_worker_t* worker, - dual::status_t lp_status, + dual_status_t lp_status, logger_t& log) { nondeterministic_policy_t policy{*this, worker, log}; @@ -1377,7 +1406,7 @@ bool branch_and_bound_t::apply_symmetry_reductions( } template -dual::status_t branch_and_bound_t::solve_node_lp( +dual_status_t branch_and_bound_t::solve_node_lp( mip_node_t* node_ptr, branch_and_bound_worker_t* worker, branch_and_bound_stats_t& stats, @@ -1449,7 +1478,7 @@ dual::status_t branch_and_bound_t::solve_node_lp( f_t factor = settings_.diving_settings.iteration_limit_factor; int64_t max_iter = factor * bnb_lp_iters; lp_settings.iteration_limit = max_iter - stats.total_lp_iters; - if (lp_settings.iteration_limit <= 0) { return dual::status_t::ITERATION_LIMIT; } + if (lp_settings.iteration_limit <= 0) { return dual_status_t::ITERATION_LIMIT; } } #ifdef LOG_NODE_SIMPLEX @@ -1474,9 +1503,9 @@ dual::status_t branch_and_bound_t::solve_node_lp( node_ptr->vstatus[node_ptr->branch_var]); #endif - bool feasible = worker->set_lp_variable_bounds(node_ptr, settings_); - dual::status_t lp_status = dual::status_t::DUAL_UNBOUNDED; - worker->leaf_edge_norms = edge_norms_; + bool feasible = worker->set_lp_variable_bounds(node_ptr, settings_); + dual_status_t lp_status = dual_status_t::DUAL_UNBOUNDED; + worker->leaf_edge_norms = edge_norms_; if (worker->recompute_bounds && worker->orbital_fixing && worker->search_strategy == BEST_FIRST) { worker->orbital_fixing->reset(symmetry_, node_ptr); } @@ -1502,7 +1531,7 @@ dual::status_t branch_and_bound_t::solve_node_lp( node_iter, worker->leaf_edge_norms); - if (lp_status == dual::status_t::NUMERICAL) { + if (lp_status == dual_status_t::NUMERICAL) { log.debug("Numerical issue node %d. Resolving from scratch.\n", node_ptr->node_id); lp_status_t second_status = solve_linear_program_with_advanced_basis(worker->leaf_problem, @@ -1618,24 +1647,24 @@ void branch_and_bound_t::plunge_with(bfs_worker_t* worker, break; } - dual::status_t lp_status = solve_node_lp(node_ptr, worker, exploration_stats_, settings_.log); + dual_status_t lp_status = solve_node_lp(node_ptr, worker, exploration_stats_, settings_.log); ++exploration_stats_.nodes_since_last_log; ++exploration_stats_.nodes_explored; --exploration_stats_.nodes_unexplored; --exploration_stats_.nodes_being_solved; - if (lp_status == dual::status_t::TIME_LIMIT) { + if (lp_status == dual_status_t::TIME_LIMIT) { solver_status_ = mip_status_t::TIME_LIMIT; stack.push_front(node_ptr); break; } - if (lp_status == dual::status_t::CONCURRENT_LIMIT) { + if (lp_status == dual_status_t::CONCURRENT_LIMIT) { stack.push_front(node_ptr); break; } - if (lp_status == dual::status_t::ITERATION_LIMIT) { + if (lp_status == dual_status_t::ITERATION_LIMIT) { stack.push_front(node_ptr); break; } @@ -1887,15 +1916,15 @@ void branch_and_bound_t::dive_with(diving_worker_t* worker) } if (dive_stats.nodes_explored >= diving_node_limit) { break; } - dual::status_t lp_status = solve_node_lp(node_ptr, worker, dive_stats, log); + dual_status_t lp_status = solve_node_lp(node_ptr, worker, dive_stats, log); ++dive_stats.nodes_explored; - if (lp_status == dual::status_t::TIME_LIMIT) { + if (lp_status == dual_status_t::TIME_LIMIT) { solver_status_ = mip_status_t::TIME_LIMIT; break; } - if (lp_status == dual::status_t::CONCURRENT_LIMIT) { break; } - if (lp_status == dual::status_t::ITERATION_LIMIT) { break; } + if (lp_status == dual_status_t::CONCURRENT_LIMIT) { break; } + if (lp_status == dual_status_t::ITERATION_LIMIT) { break; } auto [node_status, round_dir] = update_tree(node_ptr, dive_tree, worker, lp_status, log); @@ -2037,13 +2066,13 @@ lp_status_t branch_and_bound_t::solve_root_relaxation( std::vector crushed_root_y; std::vector crushed_root_z; - f_t dual_res_inf = crush_dual_solution(original_problem_, - original_lp_, - new_slacks_, - root_crossover_soln_.y, - root_crossover_soln_.z, - crushed_root_y, - crushed_root_z); + f_t dual_res_inf = simplex::crush_dual_solution(original_problem_, + original_lp_, + new_slacks_, + root_crossover_soln_.y, + root_crossover_soln_.z, + crushed_root_y, + crushed_root_z); root_crossover_soln_.x = crushed_root_x; root_crossover_soln_.y = crushed_root_y; @@ -2141,7 +2170,7 @@ lp_status_t branch_and_bound_t::solve_root_relaxation( settings_.log.printf("Root relaxation objective %+.8e\n", user_objective); } else { settings_.log.printf("Root relaxation returned: %s\n", - lp_status_to_string(root_status).c_str()); + simplex::lp_status_to_string(root_status).c_str()); } settings_.log.printf("\n"); @@ -2318,31 +2347,31 @@ auto branch_and_bound_t::do_cut_pass( bool initialize_basis = false; lp_settings.concurrent_halt = NULL; f_t dual_phase2_start_time = tic(); - dual::status_t cut_status = dual_phase2_with_advanced_basis(2, - 0, - initialize_basis, - exploration_stats_.start_time, - original_lp_, - lp_settings, - root_vstatus_, - basis_update, - basic_list, - nonbasic_list, - root_relax_soln_, - iter, - edge_norms_); + dual_status_t cut_status = dual_phase2_with_advanced_basis(2, + 0, + initialize_basis, + exploration_stats_.start_time, + original_lp_, + lp_settings, + root_vstatus_, + basis_update, + basic_list, + nonbasic_list, + root_relax_soln_, + iter, + edge_norms_); exploration_stats_.total_lp_iters += iter; f_t dual_phase2_time = toc(dual_phase2_start_time); if (dual_phase2_time > 1.0) { settings_.log.debug("Dual phase2 time %.2f seconds\n", dual_phase2_time); } - if (cut_status == dual::status_t::TIME_LIMIT) { + if (cut_status == dual_status_t::TIME_LIMIT) { solver_status_ = mip_status_t::TIME_LIMIT; set_final_solution(solution, root_objective_); return {cut_pass_action_t::RETURN, solver_status_}; } - if (cut_status != dual::status_t::OPTIMAL) { + if (cut_status != dual_status_t::OPTIMAL) { settings_.log.printf("Numerical issue at root node. Resolving from scratch\n"); lp_status_t scratch_status = solve_linear_program_with_advanced_basis(original_lp_, @@ -2360,7 +2389,7 @@ auto branch_and_bound_t::do_cut_pass( exploration_stats_.total_lp_iters += root_relax_soln_.iterations; root_objective_ = compute_objective(original_lp_, root_relax_soln_.x); } else { - settings_.log.printf("Cut status %s\n", dual::status_to_string(cut_status).c_str()); + settings_.log.printf("Cut status %s\n", simplex::dual_status_to_string(cut_status).c_str()); #ifdef WRITE_CUT_INFEASIBLE_MPS original_lp_.write_mps("cut_infeasible.mps"); #endif @@ -2491,7 +2520,7 @@ mip_status_t branch_and_bound_t::solve(mip_solution_t& solut { user_problem_t problem_copy = original_problem_; timer_t timer(std::numeric_limits::infinity()); - detail::find_initial_cliques( + mip::find_initial_cliques( problem_copy, tolerances_for_clique, &clique_table_, timer, clique_signal); } } @@ -2585,12 +2614,12 @@ mip_status_t branch_and_bound_t::solve(mip_solution_t& solut uncrush_primal_solution(original_problem_, original_lp_, root_relax_soln_.x, original_x); std::vector original_dual; std::vector original_z; - uncrush_dual_solution(original_problem_, - original_lp_, - root_relax_soln_.y, - root_relax_soln_.z, - original_dual, - original_z); + simplex::uncrush_dual_solution(original_problem_, + original_lp_, + root_relax_soln_.y, + root_relax_soln_.z, + original_dual, + original_z); settings_.set_simplex_solution_callback( original_x, original_dual, compute_user_objective(original_lp_, root_objective_)); } @@ -2652,7 +2681,7 @@ mip_status_t branch_and_bound_t::solve(mip_solution_t& solut } constexpr bool enable_root_cut_cpufj = true; - std::unique_ptr> root_cut_cpufj_task; + std::unique_ptr> root_cut_cpufj_task; auto root_cut_cpufj_improvement_callback = [this](f_t obj, const std::vector& assignment, double work_units) { std::vector user_assignment; @@ -2670,7 +2699,7 @@ mip_status_t branch_and_bound_t::solve(mip_solution_t& solut }; auto stop_root_cut_cpufj = [&]() { if (!root_cut_cpufj_task) { return; } - detail::stop_fj_cpu_task(*root_cut_cpufj_task); + mip::stop_fj_cpu_task(*root_cut_cpufj_task); root_cut_cpufj_task.reset(); }; cuopt::scope_guard root_cut_cpufj_guard([&]() { stop_root_cut_cpufj(); }); @@ -2699,9 +2728,9 @@ mip_status_t branch_and_bound_t::solve(mip_solution_t& solut if (root_cut_cpufj_task) { #pragma omp task shared(root_cut_cpufj_task) priority(CUOPT_DEFAULT_TASK_PRIORITY) default(none) \ depend(out : *root_cut_cpufj_task) - detail::run_fj_cpu_task(*root_cut_cpufj_task, - std::numeric_limits::infinity(), - std::numeric_limits::infinity()); + mip::run_fj_cpu_task(*root_cut_cpufj_task, + std::numeric_limits::infinity(), + std::numeric_limits::infinity()); } cut_pass_result = do_cut_pass(cut_pass, @@ -2724,7 +2753,7 @@ mip_status_t branch_and_bound_t::solve(mip_solution_t& solut saved_solution); if (root_cut_cpufj_task) { - detail::stop_fj_cpu_task(*root_cut_cpufj_task); + mip::stop_fj_cpu_task(*root_cut_cpufj_task); #pragma omp taskwait depend(in : *root_cut_cpufj_task) } @@ -2742,12 +2771,12 @@ mip_status_t branch_and_bound_t::solve(mip_solution_t& solut cut_pass + 1 < settings_.max_cut_passes) { f_t root_cut_cpufj_build_start_time = tic(); root_cut_cpufj_task = - detail::make_fj_cpu_task_from_host_lp(original_lp_, - var_types_, - root_relax_soln_.x, - settings_, - root_cut_cpufj_improvement_callback, - "[RootCut CPUFJ] "); + mip::make_fj_cpu_task_from_host_lp(original_lp_, + var_types_, + root_relax_soln_.x, + settings_, + root_cut_cpufj_improvement_callback, + "[RootCut CPUFJ] "); settings_.log.debug("Root cut CPUFJ problem build time after pass %d: %.6f seconds\n", cut_pass, toc(root_cut_cpufj_build_start_time)); @@ -2784,13 +2813,13 @@ mip_status_t branch_and_bound_t::solve(mip_solution_t& solut int64_t root_cut_cpufj_seed = settings_.deterministic ? static_cast(settings_.random_seed) : -1; root_cut_cpufj_task = - detail::make_fj_cpu_task_from_host_lp(original_lp_, - var_types_, - root_relax_soln_.x, - settings_, - root_cut_cpufj_improvement_callback, - "[RootCut CPUFJ] ", - root_cut_cpufj_seed); + mip::make_fj_cpu_task_from_host_lp(original_lp_, + var_types_, + root_relax_soln_.x, + settings_, + root_cut_cpufj_improvement_callback, + "[RootCut CPUFJ] ", + root_cut_cpufj_seed); settings_.log.debug("Root cut CPUFJ final problem build time: %.6f seconds\n", toc(root_cut_cpufj_build_start_time)); f_t remaining_time = f_t(settings_.time_limit - toc(exploration_stats_.start_time)); @@ -2798,7 +2827,7 @@ mip_status_t branch_and_bound_t::solve(mip_solution_t& solut // at 1s so generous budgets don't grant CPUFJ more than the historical ceiling. f_t fj_time_limit = settings_.deterministic ? remaining_time : std::min(remaining_time * f_t{0.5}, f_t{1}); - detail::run_fj_cpu_task(*root_cut_cpufj_task, fj_time_limit, 0.5); + mip::run_fj_cpu_task(*root_cut_cpufj_task, fj_time_limit, 0.5); root_cut_cpufj_task.reset(); } @@ -3378,7 +3407,7 @@ void branch_and_bound_t::deterministic_sync_callback() } } - state_hash = detail::compute_hash(state_data); + state_hash = cuopt::compute_hash(state_data); state_hash ^= pc_.compute_state_hash(); } @@ -3523,22 +3552,22 @@ node_status_t branch_and_bound_t::solve_node_deterministic( f_t lp_start_time = tic(); std::vector leaf_edge_norms = edge_norms_; - dual::status_t lp_status = dual_phase2_with_advanced_basis(2, - 0, - worker.recompute_bounds_and_basis, - lp_start_time, - worker.leaf_problem, - lp_settings, - worker.leaf_vstatus, - worker.basis_factors, - worker.basic_list, - worker.nonbasic_list, - worker.leaf_solution, - node_iter, - leaf_edge_norms, - &worker.work_context); - - if (lp_status == dual::status_t::NUMERICAL) { + dual_status_t lp_status = dual_phase2_with_advanced_basis(2, + 0, + worker.recompute_bounds_and_basis, + lp_start_time, + worker.leaf_problem, + lp_settings, + worker.leaf_vstatus, + worker.basis_factors, + worker.basic_list, + worker.nonbasic_list, + worker.leaf_solution, + node_iter, + leaf_edge_norms, + &worker.work_context); + + if (lp_status == dual_status_t::NUMERICAL) { settings_.log.printf("Numerical issue node %d. Resolving from scratch.\n", node_ptr->node_id); lp_status_t second_status = solve_linear_program_with_advanced_basis(worker.leaf_problem, lp_start_time, @@ -4137,22 +4166,22 @@ void branch_and_bound_t::deterministic_dive( std::vector leaf_edge_norms = edge_norms_; decompress_vstatus(node_ptr->packed_vstatus, worker.leaf_problem.num_cols, worker.leaf_vstatus); - dual::status_t lp_status = dual_phase2_with_advanced_basis(2, - 0, - worker.recompute_bounds_and_basis, - lp_start_time, - worker.leaf_problem, - lp_settings, - worker.leaf_vstatus, - worker.basis_factors, - worker.basic_list, - worker.nonbasic_list, - worker.leaf_solution, - node_iter, - leaf_edge_norms, - &worker.work_context); - - if (lp_status == dual::status_t::NUMERICAL) { + dual_status_t lp_status = dual_phase2_with_advanced_basis(2, + 0, + worker.recompute_bounds_and_basis, + lp_start_time, + worker.leaf_problem, + lp_settings, + worker.leaf_vstatus, + worker.basis_factors, + worker.basic_list, + worker.nonbasic_list, + worker.leaf_solution, + node_iter, + leaf_edge_norms, + &worker.work_context); + + if (lp_status == dual_status_t::NUMERICAL) { lp_status_t second_status = solve_linear_program_with_advanced_basis(worker.leaf_problem, lp_start_time, lp_settings, @@ -4172,8 +4201,8 @@ void branch_and_bound_t::deterministic_dive( worker.clock = worker.work_context.global_work_units_elapsed; - if (lp_status == dual::status_t::TIME_LIMIT || lp_status == dual::status_t::WORK_LIMIT || - lp_status == dual::status_t::ITERATION_LIMIT) { + if (lp_status == dual_status_t::TIME_LIMIT || lp_status == dual_status_t::WORK_LIMIT || + lp_status == dual_status_t::ITERATION_LIMIT) { break; } @@ -4188,4 +4217,4 @@ template class branch_and_bound_t; #endif -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/branch_and_bound/branch_and_bound.hpp b/cpp/src/branch_and_bound/branch_and_bound.hpp index 0b32b2ece5..2d503fa4ad 100644 --- a/cpp/src/branch_and_bound/branch_and_bound.hpp +++ b/cpp/src/branch_and_bound/branch_and_bound.hpp @@ -30,7 +30,7 @@ #include #include -#include +#include #include @@ -40,12 +40,12 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template struct clique_table_t; } -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::mip { template struct mip_symmetry_t; @@ -61,9 +61,6 @@ enum class mip_status_t { WORK_LIMIT = 7, // The solver reached a deterministic work limit }; -template -class bounds_strengthening_t; - template void upper_bound_callback(f_t upper_bound); @@ -79,12 +76,12 @@ struct deterministic_diving_policy_t; template class branch_and_bound_t { public: - branch_and_bound_t(const user_problem_t& user_problem, - const simplex_solver_settings_t& solver_settings, + branch_and_bound_t(const simplex::user_problem_t& user_problem, + const simplex::simplex_solver_settings_t& solver_settings, f_t start_time, const probing_implied_bound_t& probing_implied_bound, - std::shared_ptr> clique_table = nullptr, - mip_symmetry_t* symmetry = nullptr); + std::shared_ptr> clique_table = nullptr, + mip_symmetry_t* symmetry = nullptr); // Set an initial guess based on the user_problem. This should be called before solve. void set_initial_guess(const std::vector& user_guess) { guess_ = user_guess; } @@ -141,20 +138,21 @@ class branch_and_bound_t { bool enable_concurrent_lp_root_solve() const { return enable_concurrent_lp_root_solve_; } std::atomic* get_root_concurrent_halt() { return &root_concurrent_halt_; } void set_root_concurrent_halt(int value) { root_concurrent_halt_ = value; } - lp_status_t solve_root_relaxation(simplex_solver_settings_t const& lp_settings, - lp_solution_t& root_relax_soln, - std::vector& root_vstatus, - basis_update_mpf_t& basis_update, - std::vector& basic_list, - std::vector& nonbasic_list, - std::vector& edge_norms); + simplex::lp_status_t solve_root_relaxation( + simplex::simplex_solver_settings_t const& lp_settings, + simplex::lp_solution_t& root_relax_soln, + std::vector& root_vstatus, + simplex::basis_update_mpf_t& basis_update, + std::vector& basic_list, + std::vector& nonbasic_list, + std::vector& edge_norms); i_t find_reduced_cost_fixings(f_t upper_bound, std::vector& lower_bounds, std::vector& upper_bounds); // The main entry routine. Returns the solver status and populates solution with the incumbent. - mip_status_t solve(mip_solution_t& solution); + mip_status_t solve(simplex::mip_solution_t& solution); work_limit_context_t& get_work_unit_context() { return work_unit_context_; } @@ -162,10 +160,10 @@ class branch_and_bound_t { producer_sync_t& get_producer_sync() { return producer_sync_; } private: - const user_problem_t& original_problem_; - const simplex_solver_settings_t settings_; + const simplex::user_problem_t& original_problem_; + const simplex::simplex_solver_settings_t settings_; const probing_implied_bound_t& probing_implied_bound_; - std::shared_ptr> clique_table_; + std::shared_ptr> clique_table_; omp_atomic_t signal_extend_cliques_{false}; mip_symmetry_t* symmetry_; @@ -175,10 +173,10 @@ class branch_and_bound_t { std::vector guess_; // LP relaxation - csr_matrix_t Arow_; - lp_problem_t original_lp_; + simplex::csr_matrix_t Arow_; + simplex::lp_problem_t original_lp_; std::vector new_slacks_; - std::vector var_types_; + std::vector var_types_; // Variable locks (see definition 3.3 from T. Achterberg, “Constraint Integer Programming,” // PhD, Technischen Universität Berlin, Berlin, 2007. doi: 10.14279/depositonce-1634). @@ -202,7 +200,7 @@ class branch_and_bound_t { omp_atomic_t upper_bound_; // Solver-space incumbent tracked directly by B&B. - mip_solution_t incumbent_; + simplex::mip_solution_t incumbent_; // Whether obj should replace the stored incumbent. Must be called under mutex_upper_. // Compares against the stored incumbent's objective, NOT against upper_bound_, because @@ -221,11 +219,11 @@ class branch_and_bound_t { std::vector> repair_queue_; // Variables for the root node in the search tree. - std::vector root_vstatus_; - std::vector crossover_vstatus_; + std::vector root_vstatus_; + std::vector crossover_vstatus_; f_t root_objective_; - lp_solution_t root_relax_soln_; - lp_solution_t root_crossover_soln_; + simplex::lp_solution_t root_relax_soln_; + simplex::lp_solution_t root_crossover_soln_; method_t root_relax_solved_by{Unset}; std::vector edge_norms_; std::atomic root_crossover_solution_set_{false}; @@ -278,17 +276,17 @@ class branch_and_bound_t { }; cut_pass_result_t do_cut_pass(i_t cut_pass, - mip_solution_t& solution, + simplex::mip_solution_t& solution, i_t& num_fractional, std::vector& fractional, cut_generation_t& cut_generation, - basis_update_mpf_t& basis_update, + simplex::basis_update_mpf_t& basis_update, std::vector& basic_list, std::vector& nonbasic_list, variable_bounds_t& variable_bounds, cut_pool_t& cut_pool, cut_info_t& cut_info, - simplex_solver_settings_t& lp_settings, + simplex::simplex_solver_settings_t& lp_settings, i_t original_rows, f_t& last_upper_bound, f_t& last_objective, @@ -297,12 +295,12 @@ class branch_and_bound_t { const std::vector& saved_solution); // Set the solution when found at the root node - void set_solution_at_root(mip_solution_t& solution, + void set_solution_at_root(simplex::mip_solution_t& solution, const cut_info_t& cut_info); void update_user_bound(f_t lower_bound); // Set the final solution. - void set_final_solution(mip_solution_t& solution, f_t lower_bound); + void set_final_solution(simplex::mip_solution_t& solution, f_t lower_bound); // Update the incumbent solution with the new feasible solution // found during branch and bound. @@ -336,10 +334,10 @@ class branch_and_bound_t { void dive_with(diving_worker_t* worker); // Solve the LP relaxation of a leaf node - dual::status_t solve_node_lp(mip_node_t* node_ptr, - branch_and_bound_worker_t* worker, - branch_and_bound_stats_t& stats, - logger_t& log); + simplex::dual_status_t solve_node_lp(mip_node_t* node_ptr, + branch_and_bound_worker_t* worker, + branch_and_bound_stats_t& stats, + simplex::logger_t& log); // Apply symmetry-based bound reductions (orbital fixing and, when // settings_.symmetry == 2, lexical reduction) to the current node. @@ -360,7 +358,7 @@ class branch_and_bound_t { mip_node_t* node_ptr, search_tree_t& search_tree, WorkerT* worker, - dual::status_t lp_status, + simplex::dual_status_t lp_status, Policy& policy); // Opportunistic tree update wrapper. @@ -368,15 +366,15 @@ class branch_and_bound_t { mip_node_t* node_ptr, search_tree_t& search_tree, branch_and_bound_worker_t* worker, - dual::status_t lp_status, - logger_t& log); + simplex::dual_status_t lp_status, + simplex::logger_t& log); // ============================================================================ // Deterministic BSP (Bulk Synchronous Parallel) methods for deterministic parallel B&B // ============================================================================ // Main deterministic coordinator loop - void run_deterministic_coordinator(const csr_matrix_t& Arow); + void run_deterministic_coordinator(const simplex::csr_matrix_t& Arow); // Gather all events generated, sort by WU timestamp, apply void deterministic_sort_replay_events(const bb_event_batch_t& events); @@ -477,4 +475,4 @@ class branch_and_bound_t { heap_t diving_heap_; }; -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/branch_and_bound/constants.hpp b/cpp/src/branch_and_bound/constants.hpp index d507999ed6..0194e23da4 100644 --- a/cpp/src/branch_and_bound/constants.hpp +++ b/cpp/src/branch_and_bound/constants.hpp @@ -7,7 +7,7 @@ #pragma once -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::mip { constexpr int num_search_strategies = 7; @@ -41,4 +41,4 @@ enum class branch_direction_t { NONE = -1, DOWN = 0, UP = 1 }; enum class branch_and_bound_mode_t { PARALLEL = 0, DETERMINISTIC = 1 }; -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/branch_and_bound/deterministic_workers.hpp b/cpp/src/branch_and_bound/deterministic_workers.hpp index fb1c0f450f..f7c960cbdd 100644 --- a/cpp/src/branch_and_bound/deterministic_workers.hpp +++ b/cpp/src/branch_and_bound/deterministic_workers.hpp @@ -22,7 +22,7 @@ #include #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::mip { template struct backlog_node_compare_t { @@ -85,10 +85,10 @@ class deterministic_worker_base_t : public branch_and_bound_worker_t { double total_nowork_time{0.0}; deterministic_worker_base_t(int id, - const lp_problem_t& original_lp, - const csr_matrix_t& Arow, - const std::vector& var_types, - const simplex_solver_settings_t& settings, + const simplex::lp_problem_t& original_lp, + const simplex::csr_matrix_t& Arow, + const std::vector& var_types, + const simplex::simplex_solver_settings_t& settings, const std::string& context_name) : base_t(id, original_lp, Arow, var_types, settings), work_context(context_name), @@ -137,10 +137,10 @@ class deterministic_bfs_worker_t i_t total_nodes_assigned{0}; explicit deterministic_bfs_worker_t(int id, - const lp_problem_t& original_lp, - const csr_matrix_t& Arow, - const std::vector& var_types, - const simplex_solver_settings_t& settings) + const simplex::lp_problem_t& original_lp, + const simplex::csr_matrix_t& Arow, + const std::vector& var_types, + const simplex::simplex_solver_settings_t& settings) : base_t(id, original_lp, Arow, var_types, settings, "BB_Worker_" + std::to_string(id)) { } @@ -293,13 +293,14 @@ class deterministic_diving_worker_t i_t total_dives{0}; i_t lp_iters_this_dive{0}; - explicit deterministic_diving_worker_t(int id, - search_strategy_t type, - const lp_problem_t& original_lp, - const csr_matrix_t& Arow, - const std::vector& var_types, - const simplex_solver_settings_t& settings, - const std::vector* root_sol) + explicit deterministic_diving_worker_t( + int id, + search_strategy_t type, + const simplex::lp_problem_t& original_lp, + const simplex::csr_matrix_t& Arow, + const std::vector& var_types, + const simplex::simplex_solver_settings_t& settings, + const std::vector* root_sol) : base_t(id, original_lp, Arow, var_types, settings, "Diving_Worker_" + std::to_string(id)), diving_type(type), root_solution(root_sol) @@ -315,7 +316,8 @@ class deterministic_diving_worker_t bool has_work_impl() const { return !dive_queue.empty(); } - void enqueue_dive_node(mip_node_t* node, const lp_problem_t& original_lp) + void enqueue_dive_node(mip_node_t* node, + const simplex::lp_problem_t& original_lp) { dive_queue_entry_t entry; entry.resolved_lower = original_lp.lower; @@ -402,10 +404,10 @@ class deterministic_bfs_worker_pool_t public: deterministic_bfs_worker_pool_t(int num_workers, - const lp_problem_t& original_lp, - const csr_matrix_t& Arow, - const std::vector& var_types, - const simplex_solver_settings_t& settings) + const simplex::lp_problem_t& original_lp, + const simplex::csr_matrix_t& Arow, + const std::vector& var_types, + const simplex::simplex_solver_settings_t& settings) { this->workers_.reserve(num_workers); for (int i = 0; i < num_workers; ++i) { @@ -437,10 +439,10 @@ class deterministic_diving_worker_pool_t public: deterministic_diving_worker_pool_t(int num_workers, const std::vector& diving_types, - const lp_problem_t& original_lp, - const csr_matrix_t& Arow, - const std::vector& var_types, - const simplex_solver_settings_t& settings, + const simplex::lp_problem_t& original_lp, + const simplex::csr_matrix_t& Arow, + const std::vector& var_types, + const simplex::simplex_solver_settings_t& settings, const std::vector* root_solution) { this->workers_.reserve(num_workers); @@ -455,4 +457,4 @@ class deterministic_diving_worker_pool_t } }; -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/branch_and_bound/diving_heuristics.cpp b/cpp/src/branch_and_bound/diving_heuristics.cpp index 933f67f506..aebb7998cc 100644 --- a/cpp/src/branch_and_bound/diving_heuristics.cpp +++ b/cpp/src/branch_and_bound/diving_heuristics.cpp @@ -7,7 +7,10 @@ #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::mip { + +using simplex::logger_t; +using simplex::lp_problem_t; template branch_variable_t line_search_diving(const std::vector& fractional, @@ -21,7 +24,7 @@ branch_variable_t line_search_diving(const std::vector& fractional, branch_direction_t round_dir = branch_direction_t::NONE; for (i_t j : fractional) { - f_t score = inf; + f_t score = simplex::inf; branch_direction_t dir = branch_direction_t::NONE; if (solution[j] < root_solution[j] - eps) { @@ -407,4 +410,4 @@ template branch_variable_t vector_length_diving(const lp_problem_t +#include #include @@ -16,7 +16,7 @@ #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::mip { // When `log_diving_type` is true, each diving strategy gets its own letter; // otherwise every dive collapses to 'D'. @@ -56,48 +56,48 @@ template branch_variable_t line_search_diving(const std::vector& fractional, const std::vector& solution, const std::vector& root_solution, - logger_t& log); + simplex::logger_t& log); template branch_variable_t pseudocost_diving(pseudo_costs_t& pc, const std::vector& fractional, const std::vector& solution, const std::vector& root_solution, - logger_t& log); + simplex::logger_t& log); template branch_variable_t guided_diving(pseudo_costs_t& pc, const std::vector& fractional, const std::vector& solution, const std::vector& incumbent, - logger_t& log); + simplex::logger_t& log); // Calculate the variable locks assuming that the constraints // has the following format: `Ax = b`. template -void calculate_variable_locks(const lp_problem_t& lp_problem, +void calculate_variable_locks(const simplex::lp_problem_t& lp_problem, std::vector& up_locks, std::vector& down_locks); template -branch_variable_t coefficient_diving(const lp_problem_t& lp_problem, +branch_variable_t coefficient_diving(const simplex::lp_problem_t& lp_problem, const std::vector& fractional, const std::vector& solution, const std::vector& up_locks, const std::vector& down_locks, - logger_t& log); + simplex::logger_t& log); template -branch_variable_t farkas_diving(const lp_problem_t& lp, +branch_variable_t farkas_diving(const simplex::lp_problem_t& lp, const std::vector& fractional, const std::vector& solution, f_t zero_tol, - logger_t& log); + simplex::logger_t& log); template -branch_variable_t vector_length_diving(const lp_problem_t& lp, +branch_variable_t vector_length_diving(const simplex::lp_problem_t& lp, const std::vector& fractional, const std::vector& solution, - logger_t& log); + simplex::logger_t& log); -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/branch_and_bound/mip_node.hpp b/cpp/src/branch_and_bound/mip_node.hpp index 2c0968ffce..fc7b3a90e9 100644 --- a/cpp/src/branch_and_bound/mip_node.hpp +++ b/cpp/src/branch_and_bound/mip_node.hpp @@ -21,7 +21,7 @@ #include #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::mip { enum class node_status_t : int { PENDING = 0, // Node is still in the tree, waiting to be solved @@ -97,7 +97,7 @@ class mip_node_t { children[1] = nullptr; } - mip_node_t(f_t root_lower_bound, const std::vector& basis) + mip_node_t(f_t root_lower_bound, const std::vector& basis) : status(node_status_t::PENDING), lower_bound(root_lower_bound), depth(0), @@ -113,14 +113,14 @@ class mip_node_t { children[1] = nullptr; } - mip_node_t(const lp_problem_t& problem, + mip_node_t(const simplex::lp_problem_t& problem, mip_node_t* parent_node, i_t node_num, i_t branch_variable, branch_direction_t branch_direction, f_t branch_var_value, i_t integer_inf, - const std::vector& basis) + const std::vector& basis) : status(node_status_t::PENDING), lower_bound(parent_node->lower_bound), depth(parent_node->depth + 1), @@ -350,7 +350,7 @@ class mip_node_t { path_steps.push_back(step); node = node->parent; } - return detail::compute_hash(path_steps); + return cuopt::compute_hash(path_steps); } }; @@ -383,9 +383,9 @@ class search_tree_t { const i_t branch_var, const f_t fractional_val, const i_t integer_infeasible, - const std::vector& parent_vstatus, - const lp_problem_t& original_lp, - logger_t& log) + const std::vector& parent_vstatus, + const simplex::lp_problem_t& original_lp, + simplex::logger_t& log) { i_t id = num_nodes.fetch_add(2); @@ -425,7 +425,7 @@ class search_tree_t { std::move(up_child)); // child pointers moved into the tree } - void graphviz_node(logger_t& log, + void graphviz_node(simplex::logger_t& log, const mip_node_t* node_ptr, const std::string label, const f_t val) @@ -435,7 +435,7 @@ class search_tree_t { } } - void graphviz_edge(logger_t& log, + void graphviz_edge(simplex::logger_t& log, const mip_node_t* origin_ptr, const mip_node_t* dest_ptr, const i_t branch_var, @@ -459,4 +459,4 @@ class search_tree_t { static constexpr bool write_graphviz = false; }; -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/branch_and_bound/node_queue.hpp b/cpp/src/branch_and_bound/node_queue.hpp index b07b371b81..0d248db45a 100644 --- a/cpp/src/branch_and_bound/node_queue.hpp +++ b/cpp/src/branch_and_bound/node_queue.hpp @@ -13,7 +13,7 @@ #include #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::mip { // This is a generic heap implementation based // on the STL functions. The main benefit here is @@ -108,7 +108,7 @@ class node_queue_t { return node; } - bool diving_init(const lp_problem_t& lp, + bool diving_init(const simplex::lp_problem_t& lp, mip_node_t& start_node, std::vector& start_lower, std::vector& start_upper, @@ -209,4 +209,4 @@ class node_queue_t { omp_atomic_t lower_bound_{std::numeric_limits::infinity()}; }; -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/branch_and_bound/pseudo_costs.cpp b/cpp/src/branch_and_bound/pseudo_costs.cpp index fc3ee3bb3f..baea370fa4 100644 --- a/cpp/src/branch_and_bound/pseudo_costs.cpp +++ b/cpp/src/branch_and_bound/pseudo_costs.cpp @@ -17,7 +17,7 @@ #include -#include +#include #include @@ -25,13 +25,31 @@ #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::mip { + +using simplex::basis_update_mpf_t; +using simplex::compute_initial_nonbasic_end; +using simplex::compute_objective; +using simplex::csc_matrix_t; +using simplex::csr_matrix_t; +using simplex::dual_status_t; +using simplex::logger_t; +using simplex::lp_problem_t; +using simplex::lp_solution_t; +using simplex::simplex_solver_settings_t; +using simplex::sparse_vector_t; +using simplex::tic; +using simplex::toc; +using simplex::variable_status_t; +using simplex::variable_type_t; +using simplex::vector_norm_inf; + namespace { -static bool is_dual_simplex_done(dual::status_t status) +static bool is_dual_simplex_done(dual_status_t status) { - return status == dual::status_t::DUAL_UNBOUNDED || status == dual::status_t::OPTIMAL || - status == dual::status_t::ITERATION_LIMIT || status == dual::status_t::CUTOFF; + return status == dual_status_t::DUAL_UNBOUNDED || status == dual_status_t::OPTIMAL || + status == dual_status_t::ITERATION_LIMIT || status == dual_status_t::CUTOFF; } template @@ -47,7 +65,7 @@ f_t compute_step_length(const simplex_solver_settings_t& settings, const std::vector& delta_z, const std::vector& delta_z_indices) { - f_t step_length = inf; + f_t step_length = simplex::inf; f_t pivot_tol = settings.pivot_tol; const i_t nz = delta_z_indices.size(); for (i_t h = 0; h < nz; h++) { @@ -104,28 +122,28 @@ objective_change_estimate_t single_pivot_objective_change_estimate( std::vector delta_z_indices; // delta_z starts out all zero if (use_transpose) { - compute_delta_z(Arow, - delta_y, - variable_j, - direction, - nonbasic_end, - workspace, - delta_z_indices, - delta_z, - work_estimate); + simplex::compute_delta_z(Arow, + delta_y, + variable_j, + direction, + nonbasic_end, + workspace, + delta_z_indices, + delta_z, + work_estimate); } else { std::vector delta_y_dense(lp.num_rows, 0); delta_y.to_dense(delta_y_dense); - compute_reduced_cost_update(lp, - basic_list, - nonbasic_list, - delta_y_dense, - variable_j, - direction, - workspace, - delta_z_indices, - delta_z, - work_estimate); + simplex::compute_reduced_cost_update(lp, + basic_list, + nonbasic_list, + delta_y_dense, + variable_j, + direction, + workspace, + delta_z_indices, + delta_z, + work_estimate); } // Verify dual feasibility @@ -135,7 +153,7 @@ objective_change_estimate_t single_pivot_objective_change_estimate( for (i_t j = 0; j < lp.num_cols; j++) { dual_residual[j] -= lp.objective[j]; } - matrix_transpose_vector_multiply(lp.A, 1.0, lp_solution.y, 1.0, dual_residual); + simplex::matrix_transpose_vector_multiply(lp.A, 1.0, lp_solution.y, 1.0, dual_residual); f_t dual_residual_norm = vector_norm_inf(dual_residual); settings.log.printf("Dual residual norm: %e\n", dual_residual_norm); } @@ -305,8 +323,8 @@ void strong_branch_helper(i_t start, std::vector& strong_branch_up, std::vector& dual_simplex_obj_down, std::vector& dual_simplex_obj_up, - std::vector& dual_simplex_status_down, - std::vector& dual_simplex_status_up, + std::vector& dual_simplex_status_down, + std::vector& dual_simplex_status_up, shared_strong_branching_context_view_t& sb_view, omp_atomic_t& num_strong_branches_completed) { @@ -358,22 +376,22 @@ void strong_branch_helper(i_t start, i_t iter = 0; std::vector vstatus = root_vstatus; std::vector child_edge_norms = edge_norms; - dual::status_t status = dual_phase2(2, - 0, - lp_start_time, - child_problem, - child_settings, - vstatus, - solution, - iter, - child_edge_norms); + dual_status_t status = simplex::dual_phase2(2, + 0, + lp_start_time, + child_problem, + child_settings, + vstatus, + solution, + iter, + child_edge_norms); f_t obj = std::numeric_limits::quiet_NaN(); - if (status == dual::status_t::DUAL_UNBOUNDED) { + if (status == dual_status_t::DUAL_UNBOUNDED) { // LP was infeasible obj = std::numeric_limits::infinity(); - } else if (status == dual::status_t::OPTIMAL || status == dual::status_t::ITERATION_LIMIT || - status == dual::status_t::CUTOFF) { + } else if (status == dual_status_t::OPTIMAL || status == dual_status_t::ITERATION_LIMIT || + status == dual_status_t::CUTOFF) { obj = compute_objective(child_problem, solution.x); } else { settings.log.debug("Thread id %2d remaining %d variable %d branch %d status %d\n", @@ -454,21 +472,21 @@ void strong_branch_helper(i_t start, } template -std::pair trial_branching(const lp_problem_t& original_lp, - const simplex_solver_settings_t& settings, - const std::vector& var_types, - const std::vector& vstatus, - const std::vector& edge_norms, - const basis_update_mpf_t& basis_factors, - const std::vector& basic_list, - const std::vector& nonbasic_list, - i_t branch_var, - f_t branch_var_lower, - f_t branch_var_upper, - f_t upper_bound, - f_t start_time, - i_t iter_limit, - i_t& iter) +std::pair trial_branching(const lp_problem_t& original_lp, + const simplex_solver_settings_t& settings, + const std::vector& var_types, + const std::vector& vstatus, + const std::vector& edge_norms, + const basis_update_mpf_t& basis_factors, + const std::vector& basic_list, + const std::vector& nonbasic_list, + i_t branch_var, + f_t branch_var_lower, + f_t branch_var_upper, + f_t upper_bound, + f_t start_time, + i_t iter_limit, + i_t& iter) { lp_problem_t child_problem = original_lp; child_problem.lower[branch_var] = branch_var_lower; @@ -494,47 +512,47 @@ std::pair trial_branching(const lp_problem_t& ori // Only refactor the basis if we encounter numerical issues. child_basis_factors.set_refactor_frequency(iter_limit); - dual::status_t status = dual_phase2_with_advanced_basis(2, - 0, - initialize_basis, - start_time, - child_problem, - child_settings, - child_vstatus, - child_basis_factors, - child_basic_list, - child_nonbasic_list, - solution, - iter, - child_edge_norms); + dual_status_t status = simplex::dual_phase2_with_advanced_basis(2, + 0, + initialize_basis, + start_time, + child_problem, + child_settings, + child_vstatus, + child_basis_factors, + child_basic_list, + child_nonbasic_list, + solution, + iter, + child_edge_norms); settings.log.debug("Trial branching on variable %d. Lo: %e Up: %e. Iter %d. Status %s. Obj %e\n", branch_var, child_problem.lower[branch_var], child_problem.upper[branch_var], iter, - dual::status_to_string(status).c_str(), + simplex::dual_status_to_string(status).c_str(), compute_objective(child_problem, solution.x)); - if (status == dual::status_t::DUAL_UNBOUNDED) { + if (status == dual_status_t::DUAL_UNBOUNDED) { // LP was infeasible - return {std::numeric_limits::infinity(), dual::status_t::DUAL_UNBOUNDED}; - } else if (status == dual::status_t::OPTIMAL || status == dual::status_t::ITERATION_LIMIT || - status == dual::status_t::CUTOFF) { + return {std::numeric_limits::infinity(), dual_status_t::DUAL_UNBOUNDED}; + } else if (status == dual_status_t::OPTIMAL || status == dual_status_t::ITERATION_LIMIT || + status == dual_status_t::CUTOFF) { return {compute_objective(child_problem, solution.x), status}; } else { - return {std::numeric_limits::quiet_NaN(), dual::status_t::NUMERICAL}; + return {std::numeric_limits::quiet_NaN(), dual_status_t::NUMERICAL}; } } } // namespace template -static cuopt::linear_programming::io::mps_data_model_t simplex_problem_to_mps_data_model( - const dual_simplex::lp_problem_t& lp, - const std::vector& new_slacks, - const std::vector& root_soln, - std::vector& original_root_soln_x) +static cuopt::mathematical_optimization::io::mps_data_model_t +simplex_problem_to_mps_data_model(const lp_problem_t& lp, + const std::vector& new_slacks, + const std::vector& root_soln, + std::vector& original_root_soln_x) { // Branch and bound has a problem of the form: // minimize c^T x @@ -549,13 +567,13 @@ static cuopt::linear_programming::io::mps_data_model_t simplex_problem // subject to lb <= A*x <= ub // l <= x <= u - cuopt::linear_programming::io::mps_data_model_t mps_model; + cuopt::mathematical_optimization::io::mps_data_model_t mps_model; int m = lp.num_rows; int n = lp.num_cols - new_slacks.size(); original_root_soln_x.resize(n); // Remove slacks from A - dual_simplex::csc_matrix_t A_no_slacks = lp.A; + csc_matrix_t A_no_slacks = lp.A; std::vector cols_to_remove(lp.A.n, 0); for (i_t j : new_slacks) { cols_to_remove[j] = 1; @@ -567,7 +585,7 @@ static cuopt::linear_programming::io::mps_data_model_t simplex_problem } // Convert CSC to CSR using built-in method - dual_simplex::csr_matrix_t csr_A(m, n, 0); + csr_matrix_t csr_A(m, n, 0); A_no_slacks.to_compressed_row(csr_A); int nz = csr_A.row_start[m]; @@ -657,34 +675,34 @@ enum class sb_source_t { DUAL_SIMPLEX, PDLP, NONE }; // 5. Else if none converged -> NaN (original objective) template static std::pair merge_sb_result(f_t dual_simplex_val, - dual::status_t dual_simplex_status, + dual_status_t dual_simplex_status, f_t pdlp_dual_obj, bool pdlp_optimal) { // Dual simplex always maintains dual feasibility, so OPTIMAL and ITERATION_LIMIT both qualify // Rule 1: Both optimal -> keep DS - if (dual_simplex_status == dual::status_t::OPTIMAL && pdlp_optimal) { + if (dual_simplex_status == dual_status_t::OPTIMAL && pdlp_optimal) { return {dual_simplex_val, sb_source_t::DUAL_SIMPLEX}; } // Rule 2: Dual Simplex found infeasible -> declare infeasible - if (dual_simplex_status == dual::status_t::DUAL_UNBOUNDED) { + if (dual_simplex_status == dual_status_t::DUAL_UNBOUNDED) { return {std::numeric_limits::infinity(), sb_source_t::DUAL_SIMPLEX}; } // Rule 3: Only one converged -> keep that - if (dual_simplex_status == dual::status_t::OPTIMAL && !pdlp_optimal) { + if (dual_simplex_status == dual_status_t::OPTIMAL && !pdlp_optimal) { return {dual_simplex_val, sb_source_t::DUAL_SIMPLEX}; } - if (pdlp_optimal && dual_simplex_status != dual::status_t::OPTIMAL) { + if (pdlp_optimal && dual_simplex_status != dual_status_t::OPTIMAL) { return {pdlp_dual_obj, sb_source_t::PDLP}; } // Rule 4: Dual Simplex hit iteration limit or work limit or cutoff -> keep DS - if (dual_simplex_status == dual::status_t::ITERATION_LIMIT || - dual_simplex_status == dual::status_t::WORK_LIMIT || - dual_simplex_status == dual::status_t::CUTOFF) { + if (dual_simplex_status == dual_status_t::ITERATION_LIMIT || + dual_simplex_status == dual_status_t::WORK_LIMIT || + dual_simplex_status == dual_status_t::CUTOFF) { return {dual_simplex_val, sb_source_t::DUAL_SIMPLEX}; } @@ -726,7 +744,7 @@ static void batch_pdlp_strong_branching_task( std::vector original_root_soln_y, original_root_soln_z; // TODO put back later once Chris has this part - /*uncrush_dual_solution( + /*simplex::uncrush_dual_solution( original_problem, original_lp, root_soln_y, root_soln_z, original_root_soln_y, original_root_soln_z);*/ @@ -1059,8 +1077,8 @@ void strong_branching_reduced(const lp_problem_t& original_lp, std::vector pdlp_obj_down(fractional.size(), std::numeric_limits::quiet_NaN()); std::vector pdlp_obj_up(fractional.size(), std::numeric_limits::quiet_NaN()); - std::vector dual_simplex_status_down(fractional.size(), dual::status_t::UNSET); - std::vector dual_simplex_status_up(fractional.size(), dual::status_t::UNSET); + std::vector dual_simplex_status_down(fractional.size(), dual_status_t::UNSET); + std::vector dual_simplex_status_up(fractional.size(), dual_status_t::UNSET); std::vector dual_simplex_obj_down(fractional.size(), std::numeric_limits::quiet_NaN()); std::vector dual_simplex_obj_up(fractional.size(), std::numeric_limits::quiet_NaN()); f_t strong_branching_start_time = tic(); @@ -1157,15 +1175,15 @@ void strong_branching_reduced(const lp_problem_t& original_lp, for (i_t k = 0; k < fractional.size(); k++) { for (auto st : {dual_simplex_status_down[k], dual_simplex_status_up[k]}) { switch (st) { - case dual::status_t::OPTIMAL: dual_simplex_optimal++; break; - case dual::status_t::DUAL_UNBOUNDED: dual_simplex_infeasible++; break; - case dual::status_t::ITERATION_LIMIT: dual_simplex_iter_limit++; break; - case dual::status_t::NUMERICAL: dual_simplex_numerical++; break; - case dual::status_t::CUTOFF: dual_simplex_cutoff++; break; - case dual::status_t::TIME_LIMIT: dual_simplex_time_limit++; break; - case dual::status_t::CONCURRENT_LIMIT: dual_simplex_concurrent++; break; - case dual::status_t::WORK_LIMIT: dual_simplex_work_limit++; break; - case dual::status_t::UNSET: dual_simplex_unset++; break; + case dual_status_t::OPTIMAL: dual_simplex_optimal++; break; + case dual_status_t::DUAL_UNBOUNDED: dual_simplex_infeasible++; break; + case dual_status_t::ITERATION_LIMIT: dual_simplex_iter_limit++; break; + case dual_status_t::NUMERICAL: dual_simplex_numerical++; break; + case dual_status_t::CUTOFF: dual_simplex_cutoff++; break; + case dual_status_t::TIME_LIMIT: dual_simplex_time_limit++; break; + case dual_status_t::CONCURRENT_LIMIT: dual_simplex_concurrent++; break; + case dual_status_t::WORK_LIMIT: dual_simplex_work_limit++; break; + case dual_status_t::UNSET: dual_simplex_unset++; break; } } } @@ -1204,14 +1222,13 @@ void strong_branching_reduced(const lp_problem_t& original_lp, i_t solved_by_both = 0; for (i_t k = 0; k < fractional.size(); k++) { for (i_t branch = 0; branch < 2; branch++) { - const bool is_down = (branch == 0); - f_t& sb_dest = is_down ? strong_branch_down[k] : strong_branch_up[k]; - f_t ds_obj = is_down ? dual_simplex_obj_down[k] : dual_simplex_obj_up[k]; - dual::status_t ds_status = - is_down ? dual_simplex_status_down[k] : dual_simplex_status_up[k]; - f_t pdlp_obj = is_down ? pdlp_obj_down[k] : pdlp_obj_up[k]; - bool pdlp_has = !std::isnan(pdlp_obj); - bool ds_has = ds_status != dual::status_t::UNSET; + const bool is_down = (branch == 0); + f_t& sb_dest = is_down ? strong_branch_down[k] : strong_branch_up[k]; + f_t ds_obj = is_down ? dual_simplex_obj_down[k] : dual_simplex_obj_up[k]; + dual_status_t ds_status = is_down ? dual_simplex_status_down[k] : dual_simplex_status_up[k]; + f_t pdlp_obj = is_down ? pdlp_obj_down[k] : pdlp_obj_up[k]; + bool pdlp_has = !std::isnan(pdlp_obj); + bool ds_has = ds_status != dual_status_t::UNSET; const auto [value, source] = merge_sb_result(ds_obj, ds_status, pdlp_obj, pdlp_has); @@ -1739,8 +1756,8 @@ i_t pseudo_costs_t::reliable_variable_selection( std::vector dual_simplex_obj_down(num_candidates, std::numeric_limits::quiet_NaN()); std::vector dual_simplex_obj_up(num_candidates, std::numeric_limits::quiet_NaN()); - std::vector dual_simplex_status_down(num_candidates, dual::status_t::UNSET); - std::vector dual_simplex_status_up(num_candidates, dual::status_t::UNSET); + std::vector dual_simplex_status_down(num_candidates, dual_status_t::UNSET); + std::vector dual_simplex_status_up(num_candidates, dual_status_t::UNSET); f_t dual_simplex_start_time = tic(); @@ -1994,4 +2011,4 @@ template void strong_branching(const lp_problem_t& ori #endif -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/branch_and_bound/pseudo_costs.hpp b/cpp/src/branch_and_bound/pseudo_costs.hpp index 6fd7dc5bb6..75821b79b7 100644 --- a/cpp/src/branch_and_bound/pseudo_costs.hpp +++ b/cpp/src/branch_and_bound/pseudo_costs.hpp @@ -24,7 +24,7 @@ #include #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::mip { template struct mip_symmetry_t; @@ -107,7 +107,8 @@ struct pseudo_cost_update_t { template class pseudo_costs_t { public: - explicit pseudo_costs_t(i_t num_variables, const simplex_solver_settings_t& settings) + explicit pseudo_costs_t(i_t num_variables, + const simplex::simplex_solver_settings_t& settings) : settings(settings), pseudo_cost_sum_down(num_variables), pseudo_cost_sum_up(num_variables), @@ -189,12 +190,12 @@ class pseudo_costs_t { i_t reliable_variable_selection(const mip_node_t* node_ptr, const std::vector& fractional, branch_and_bound_worker_t* worker, - const std::vector& var_types, + const std::vector& var_types, const branch_and_bound_stats_t& bnb_stats, f_t upper_bound, int max_num_tasks, const std::vector& new_slacks, - const lp_problem_t& original_lp); + const simplex::lp_problem_t& original_lp); void update_pseudo_costs_from_strong_branching(const std::vector& fractional, const std::vector& strong_branch_down, @@ -203,8 +204,8 @@ class pseudo_costs_t { uint32_t compute_state_hash() const { - return detail::compute_hash(pseudo_cost_sum_down) ^ detail::compute_hash(pseudo_cost_sum_up) ^ - detail::compute_hash(pseudo_cost_num_down) ^ detail::compute_hash(pseudo_cost_num_up); + return cuopt::compute_hash(pseudo_cost_sum_down) ^ cuopt::compute_hash(pseudo_cost_sum_up) ^ + cuopt::compute_hash(pseudo_cost_num_down) ^ cuopt::compute_hash(pseudo_cost_num_up); } f_t calculate_pseudocost_score(i_t j, @@ -212,12 +213,12 @@ class pseudo_costs_t { f_t avg_down, f_t avg_up) const; - std::shared_ptr> AT; // Transpose of the constraint matrix A + std::shared_ptr> AT; // Transpose of the constraint matrix A std::shared_ptr> pdlp_warm_cache; reliability_branching_settings_t reliability_branching_settings; - simplex_solver_settings_t settings; - csr_matrix_t Arow; + simplex::simplex_solver_settings_t settings; + simplex::csr_matrix_t Arow; protected: std::vector> pseudo_cost_sum_up; @@ -273,21 +274,21 @@ class pseudo_cost_snapshot_t : public pseudo_costs_t { }; template -void strong_branching(const lp_problem_t& original_lp, - const simplex_solver_settings_t& settings, +void strong_branching(const simplex::lp_problem_t& original_lp, + const simplex::simplex_solver_settings_t& settings, f_t start_time, const std::vector& new_slacks, - const std::vector& var_types, - const lp_solution_t& root_solution, + const std::vector& var_types, + const simplex::lp_solution_t& root_solution, const std::vector& fractional, f_t root_obj, f_t upper_bound, - const std::vector& root_vstatus, + const std::vector& root_vstatus, const std::vector& edge_norms, const std::vector& basic_list, const std::vector& nonbasic_list, - basis_update_mpf_t& basis_factors, + simplex::basis_update_mpf_t& basis_factors, mip_symmetry_t* symmetry, pseudo_costs_t& pc); -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/branch_and_bound/shared_strong_branching_context.hpp b/cpp/src/branch_and_bound/shared_strong_branching_context.hpp index a9e697ae58..0b5b5c8edb 100644 --- a/cpp/src/branch_and_bound/shared_strong_branching_context.hpp +++ b/cpp/src/branch_and_bound/shared_strong_branching_context.hpp @@ -12,7 +12,7 @@ #include #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::mip { template struct shared_strong_branching_context_t { @@ -57,4 +57,4 @@ struct shared_strong_branching_context_view_t { } }; -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/branch_and_bound/symmetry.hpp b/cpp/src/branch_and_bound/symmetry.hpp index bcce5ece2a..45426a9fa8 100644 --- a/cpp/src/branch_and_bound/symmetry.hpp +++ b/cpp/src/branch_and_bound/symmetry.hpp @@ -20,7 +20,7 @@ #include #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::mip { // permutation_t stores a dense permutation plus its support (non-identity entries). template @@ -338,9 +338,9 @@ class orbital_fixing_t { // Returns the number of free variables in conflicting orbits (orbits with // both zero and one sources). i_t orbital_fixing(mip_symmetry_t* symmetry, - const simplex_solver_settings_t& settings, + const simplex::simplex_solver_settings_t& settings, mip_node_t* node_ptr, - lp_problem_t& problem, + simplex::lp_problem_t& problem, const std::vector& start_lower, const std::vector& start_upper) { @@ -605,7 +605,7 @@ class lexical_reduction_t { // Return -1 to prune the node, otherwise return the number of fixings applied. i_t lexical_reduce(mip_symmetry_t* symmetry, mip_node_t* node_ptr, - lp_problem_t& problem) + simplex::lp_problem_t& problem) { reverse_branched_variables_.clear(); mip_node_t* node = node_ptr; @@ -680,22 +680,22 @@ class lexical_reduction_t { template std::unique_ptr> detect_symmetry( - const user_problem_t& user_problem, - const simplex_solver_settings_t& settings, + const simplex::user_problem_t& user_problem, + const simplex::simplex_solver_settings_t& settings, bool& has_symmetry) { has_symmetry = false; - f_t start_time = tic(); - lp_problem_t problem(user_problem.handle_ptr, 1, 1, 1); + f_t start_time = simplex::tic(); + simplex::lp_problem_t problem(user_problem.handle_ptr, 1, 1, 1); std::vector new_slacks; - dualize_info_t dualize_info; + simplex::dualize_info_t dualize_info; convert_user_problem(user_problem, settings, problem, new_slacks, dualize_info); - std::vector var_types = user_problem.var_types; + std::vector var_types = user_problem.var_types; if (problem.num_cols > user_problem.num_cols) { var_types.resize(problem.num_cols); for (i_t k = user_problem.num_cols; k < problem.num_cols; k++) { - var_types[k] = variable_type_t::CONTINUOUS; + var_types[k] = simplex::variable_type_t::CONTINUOUS; } } @@ -729,12 +729,12 @@ std::unique_ptr> detect_symmetry( return var_types[a] < var_types[b]; }); std::vector var_colors(problem.num_cols, -1); - i_t var_color = 0; - f_t last_obj = problem.objective[obj_perm[0]]; - f_t last_lower = problem.lower[obj_perm[0]]; - f_t last_upper = problem.upper[obj_perm[0]]; - variable_type_t last_type = var_types[obj_perm[0]]; - var_colors[obj_perm[0]] = var_color; + i_t var_color = 0; + f_t last_obj = problem.objective[obj_perm[0]]; + f_t last_lower = problem.lower[obj_perm[0]]; + f_t last_upper = problem.upper[obj_perm[0]]; + simplex::variable_type_t last_type = var_types[obj_perm[0]]; + var_colors[obj_perm[0]] = var_color; for (i_t k = 1; k < problem.num_cols; k++) { const i_t j = obj_perm[k]; const f_t obj = problem.objective[j]; @@ -835,7 +835,7 @@ std::unique_ptr> detect_symmetry( // Let r_i be the vertex associated with the row i // Let V_i,c be the set of variables in row i with the same color c // We create a new vertex w_i,c and edges (v_j, w_i,c) and (w_i,c, r_i) for all v_j in V_i,c - csr_matrix_t A_row(problem.num_rows, problem.num_cols, 0); + simplex::csr_matrix_t A_row(problem.num_rows, problem.num_cols, 0); problem.A.to_compressed_row(A_row); std::vector nonzeros = A_row.x; @@ -937,8 +937,8 @@ std::unique_ptr> detect_symmetry( #endif - settings.log.printf("Graph construction time %f\n", toc(start_time)); - f_t dejavu_start_time = tic(); + settings.log.printf("Graph construction time %f\n", simplex::toc(start_time)); + f_t dejavu_start_time = simplex::tic(); // The graph should now be described by: // vertices, edge_in, edge_out, vertex_colors @@ -970,7 +970,7 @@ std::unique_ptr> detect_symmetry( result->num_original_vars = num_original_vars; result->is_binary.resize(num_original_vars, 0); for (i_t j = 0; j < num_original_vars; j++) { - if (var_types[j] != variable_type_t::CONTINUOUS) { + if (var_types[j] != simplex::variable_type_t::CONTINUOUS) { if (user_problem.lower[j] == 0.0 && user_problem.upper[j] == 1.0) { result->is_binary[j] = 1; result->binary_variables.push_back(j); @@ -1060,7 +1060,7 @@ std::unique_ptr> detect_symmetry( grp_size_str.str().c_str(), num_dejavu_generators, projected_count); - settings.log.printf("Dejavu time %f\n", toc(dejavu_start_time)); + settings.log.printf("Dejavu time %f\n", simplex::toc(dejavu_start_time)); result->num_generators = result->generators.num_generators(); if (projected_count > static_cast(result->num_generators)) { @@ -1114,7 +1114,7 @@ std::unique_ptr> detect_symmetry( (total_vars_in_orbits >= 10); } - settings.log.printf("Total symmetry detection time %f\n", toc(start_time)); + settings.log.printf("Total symmetry detection time %f\n", simplex::toc(start_time)); if (!has_symmetry) { settings.log.printf( @@ -1138,4 +1138,4 @@ std::unique_ptr> detect_symmetry( return result; } -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/branch_and_bound/worker.hpp b/cpp/src/branch_and_bound/worker.hpp index 62bd0cde6b..758bbe16d8 100644 --- a/cpp/src/branch_and_bound/worker.hpp +++ b/cpp/src/branch_and_bound/worker.hpp @@ -20,7 +20,7 @@ #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::mip { template struct branch_and_bound_stats_t { @@ -54,16 +54,16 @@ class branch_and_bound_worker_t { omp_atomic_t is_active; omp_atomic_t lower_bound; - lp_problem_t leaf_problem; - lp_solution_t leaf_solution; - std::vector leaf_vstatus; + simplex::lp_problem_t leaf_problem; + simplex::lp_solution_t leaf_solution; + std::vector leaf_vstatus; std::vector leaf_edge_norms; - basis_update_mpf_t basis_factors; + simplex::basis_update_mpf_t basis_factors; std::vector basic_list; std::vector nonbasic_list; - bounds_strengthening_t node_presolver; + simplex::bounds_strengthening_t node_presolver; std::vector bounds_changed; std::vector start_lower; @@ -90,10 +90,10 @@ class branch_and_bound_worker_t { bool recompute_bounds = true; branch_and_bound_worker_t(i_t worker_id, - const lp_problem_t& original_lp, - const csr_matrix_t& Arow, - const std::vector& var_type, - const simplex_solver_settings_t& settings, + const simplex::lp_problem_t& original_lp, + const simplex::csr_matrix_t& Arow, + const std::vector& var_type, + const simplex::simplex_solver_settings_t& settings, uint64_t rng_offset = 0) : worker_id(worker_id), search_strategy(BEST_FIRST), @@ -114,7 +114,7 @@ class branch_and_bound_worker_t { // Set the variables bounds for the LP relaxation in the current node. bool set_lp_variable_bounds(mip_node_t* node_ptr, - const simplex_solver_settings_t& settings) + const simplex::simplex_solver_settings_t& settings) { // Reset the bound_changed markers std::fill(bounds_changed.begin(), bounds_changed.end(), false); @@ -142,10 +142,10 @@ class bfs_worker_t : public branch_and_bound_worker_t { public: using Base = branch_and_bound_worker_t; bfs_worker_t(i_t worker_id, - const lp_problem_t& original_lp, - const csr_matrix_t& Arow, - const std::vector& var_type, - const simplex_solver_settings_t& settings, + const simplex::lp_problem_t& original_lp, + const simplex::csr_matrix_t& Arow, + const std::vector& var_type, + const simplex::simplex_solver_settings_t& settings, uint64_t rng_offset = 0) : Base(worker_id, original_lp, Arow, var_type, settings, rng_offset) { @@ -228,7 +228,7 @@ class diving_worker_t : public branch_and_bound_worker_t { using Base::Base; // Apply bound strengthening to the starting variable bounds - bool presolve_start_bounds(const simplex_solver_settings_t& settings) + bool presolve_start_bounds(const simplex::simplex_solver_settings_t& settings) { return this->node_presolver.bounds_strengthening( settings, this->bounds_changed, this->start_lower, this->start_upper); @@ -256,4 +256,4 @@ class diving_worker_t : public branch_and_bound_worker_t { bfs_worker_t* bfs_worker{nullptr}; }; -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/branch_and_bound/worker_pool.hpp b/cpp/src/branch_and_bound/worker_pool.hpp index d75794bbf0..2189fc5b2a 100644 --- a/cpp/src/branch_and_bound/worker_pool.hpp +++ b/cpp/src/branch_and_bound/worker_pool.hpp @@ -10,7 +10,7 @@ #include #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::mip { template class worker_pool_t { @@ -19,11 +19,11 @@ class worker_pool_t { using f_t = typename WorkerType::float_type; void init(i_t num_workers, - const lp_problem_t& original_lp, - const csr_matrix_t& Arow, - const std::vector& var_type, + const simplex::lp_problem_t& original_lp, + const simplex::csr_matrix_t& Arow, + const std::vector& var_type, mip_symmetry_t* symmetry, - const simplex_solver_settings_t& settings, + const simplex::simplex_solver_settings_t& settings, const uint64_t rng_offset = 0) { assert(!is_initialized_); @@ -106,4 +106,4 @@ using bfs_worker_pool_t = worker_pool_t>; template using diving_worker_pool_t = worker_pool_t>; -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/cuts/cuts.cpp b/cpp/src/cuts/cuts.cpp index a94478adc9..2cc041d81a 100644 --- a/cpp/src/cuts/cuts.cpp +++ b/cpp/src/cuts/cuts.cpp @@ -27,7 +27,25 @@ #include #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::mip { + +using simplex::basis_update_mpf_t; +using simplex::csc_matrix_t; +using simplex::csr_matrix_t; +using simplex::form_b; +using simplex::inf; +using simplex::lp_problem_t; +using simplex::lp_solution_t; +using simplex::matrix_vector_multiply; +using simplex::simplex_solver_settings_t; +using simplex::sparse_dot; +using simplex::sparse_vector_t; +using simplex::tic; +using simplex::toc; +using simplex::variable_status_t; +using simplex::variable_type_t; +using simplex::vector_norm2; +using simplex::vector_norm_inf; namespace { @@ -354,7 +372,7 @@ void bron_kerbosch(bk_bitset_context_t& ctx, template void extend_clique_vertices(std::vector& clique_vertices, - detail::clique_table_t& graph, + mip::clique_table_t& graph, const std::vector& xstar, const std::vector& reduced_costs, i_t num_vars, @@ -2331,8 +2349,8 @@ f_t knapsack_generation_t::solve_knapsack_problem(const std::vector dp(n + 1, sum_value + 1, INT_INF); - dense_matrix_t take(n + 1, sum_value + 1, 0); + barrier::dense_matrix_t dp(n + 1, sum_value + 1, INT_INF); + barrier::dense_matrix_t take(n + 1, sum_value + 1, 0); dp(0, 0) = 0; // 4. Dynamic programming @@ -2402,8 +2420,8 @@ f_t knapsack_generation_t::exact_knapsack_problem_integer_values_fract solution.assign(n, 0.0); // dp(j, v) = minimum weight using first j items to get value v - dense_matrix_t dp(n + 1, sum_value + 1, inf); - dense_matrix_t take(n + 1, sum_value + 1, 0); + barrier::dense_matrix_t dp(n + 1, sum_value + 1, inf); + barrier::dense_matrix_t take(n + 1, sum_value + 1, 0); dp(0, 0) = 0; // 4. Dynamic programming @@ -3395,7 +3413,7 @@ i_t tableau_equality_t::generate_base_equality( u_bar.to_dense(u_bar_dense); std::vector BTu_bar(lp.num_rows); - b_transpose_multiply(lp, basic_list, u_bar_dense, BTu_bar); + simplex::b_transpose_multiply(lp, basic_list, u_bar_dense, BTu_bar); for (i_t k = 0; k < lp.num_rows; k++) { if (k == i) { settings.log.printf("BTu_bar %d error %e\n", k, std::abs(BTu_bar[k] - 1.0)); @@ -5599,4 +5617,4 @@ template void verify_cuts_against_saved_solution( const std::vector& saved_solution); #endif -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/cuts/cuts.hpp b/cpp/src/cuts/cuts.hpp index 1a7af97611..e8dfba4ccd 100644 --- a/cpp/src/cuts/cuts.hpp +++ b/cpp/src/cuts/cuts.hpp @@ -27,12 +27,12 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template struct clique_table_t; } -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::mip { enum cut_type_t : int8_t { MIXED_INTEGER_GOMORY = 0, @@ -111,10 +111,11 @@ template struct inequality_t { inequality_t() : vector(), rhs(0.0) {} inequality_t(i_t num_cols) : vector(num_cols, 0), rhs(0.0) {} - inequality_t(csr_matrix_t& A, i_t row, f_t rhs_value) : vector(A, row), rhs(rhs_value) + inequality_t(simplex::csr_matrix_t& A, i_t row, f_t rhs_value) + : vector(A, row), rhs(rhs_value) { } - sparse_vector_t vector; + simplex::sparse_vector_t vector; f_t rhs; void push_back(i_t j, f_t x) @@ -187,7 +188,7 @@ struct cut_info_t { }; template -void print_cut_info(const simplex_solver_settings_t& settings, +void print_cut_info(const simplex::simplex_solver_settings_t& settings, const cut_info_t& cut_info) { if (cut_info.has_cuts()) { @@ -200,7 +201,7 @@ void print_cut_info(const simplex_solver_settings_t& settings, template void print_cut_types(const std::string& prefix, const std::vector& cut_types, - const simplex_solver_settings_t& settings) + const simplex::simplex_solver_settings_t& settings) { cut_info_t cut_info; cut_info.record_cut_types(cut_types); @@ -251,16 +252,17 @@ void best_score_last_permutation(std::vector& scores, std::vector& per // Routines for verifying cuts against a saved solution template -void read_saved_solution_for_cut_verification(const lp_problem_t& lp, - const simplex_solver_settings_t& settings, - std::vector& saved_solution); +void read_saved_solution_for_cut_verification( + const simplex::lp_problem_t& lp, + const simplex::simplex_solver_settings_t& settings, + std::vector& saved_solution); template -void write_solution_for_cut_verification(const lp_problem_t& lp, +void write_solution_for_cut_verification(const simplex::lp_problem_t& lp, const std::vector& solution); template -void verify_cuts_against_saved_solution(const csr_matrix_t& cuts, +void verify_cuts_against_saved_solution(const simplex::csr_matrix_t& cuts, const std::vector& cut_rhs, const std::vector& saved_solution); @@ -276,7 +278,7 @@ std::vector> find_maximal_cliques_for_test( template class cut_pool_t { public: - cut_pool_t(i_t original_vars, const simplex_solver_settings_t& settings) + cut_pool_t(i_t original_vars, const simplex::simplex_solver_settings_t& settings) : original_vars_(original_vars), settings_(settings), cut_storage_(0, original_vars, 0), @@ -294,7 +296,7 @@ class cut_pool_t { void score_cuts(std::vector& x_relax); // We return the cuts in the form best_cuts*x <= best_rhs - i_t get_best_cuts(csr_matrix_t& best_cuts, + i_t get_best_cuts(simplex::csr_matrix_t& best_cuts, std::vector& best_rhs, std::vector& best_cut_types); @@ -314,9 +316,9 @@ class cut_pool_t { f_t cut_orthogonality(i_t i, i_t j); i_t original_vars_; - const simplex_solver_settings_t& settings_; + const simplex::simplex_solver_settings_t& settings_; - csr_matrix_t cut_storage_; + simplex::csr_matrix_t cut_storage_; std::vector rhs_storage_; std::vector cut_age_; std::vector cut_type_; @@ -377,11 +379,11 @@ struct flow_cover_arc_spec_t { template struct flow_cover_context_t { - const lp_problem_t& lp; - const simplex_solver_settings_t& settings; - csr_matrix_t& Arow; + const simplex::lp_problem_t& lp; + const simplex::simplex_solver_settings_t& settings; + simplex::csr_matrix_t& Arow; const variable_bounds_t& variable_bounds; - const std::vector& var_types; + const std::vector& var_types; const std::vector& xstar; }; @@ -394,16 +396,16 @@ struct flow_cover_evaluation_t { template class flow_cover_generation_t { public: - flow_cover_generation_t(const lp_problem_t& lp, - const simplex_solver_settings_t& settings, - csr_matrix_t& Arow, + flow_cover_generation_t(const simplex::lp_problem_t& lp, + const simplex::simplex_solver_settings_t& settings, + simplex::csr_matrix_t& Arow, const std::vector& new_slacks); - i_t generate_cut(const lp_problem_t& lp, - const simplex_solver_settings_t& settings, - csr_matrix_t& Arow, + i_t generate_cut(const simplex::lp_problem_t& lp, + const simplex::simplex_solver_settings_t& settings, + simplex::csr_matrix_t& Arow, const variable_bounds_t& variable_bounds, - const std::vector& var_types, + const std::vector& var_types, const std::vector& xstar, const flow_cover_row_t& flow_cover_row, inequality_t& cut); @@ -517,17 +519,17 @@ class flow_cover_generation_t { template class knapsack_generation_t { public: - knapsack_generation_t(const lp_problem_t& lp, - const simplex_solver_settings_t& settings, - csr_matrix_t& Arow, + knapsack_generation_t(const simplex::lp_problem_t& lp, + const simplex::simplex_solver_settings_t& settings, + simplex::csr_matrix_t& Arow, const std::vector& new_slacks, - const std::vector& var_types); + const std::vector& var_types); - i_t generate_knapsack_cut(const lp_problem_t& lp, - const simplex_solver_settings_t& settings, - csr_matrix_t& Arow, + i_t generate_knapsack_cut(const simplex::lp_problem_t& lp, + const simplex::simplex_solver_settings_t& settings, + simplex::csr_matrix_t& Arow, const std::vector& new_slacks, - const std::vector& var_types, + const std::vector& var_types, const std::vector& xstar, i_t knapsack_row, inequality_t& cut); @@ -574,7 +576,7 @@ class knapsack_generation_t { std::vector is_marked_; std::vector workspace_; std::vector complemented_xstar_; - const simplex_solver_settings_t& settings_; + const simplex::simplex_solver_settings_t& settings_; }; // Forward declarations @@ -585,15 +587,15 @@ template class cut_generation_t { public: cut_generation_t(cut_pool_t& cut_pool, - const lp_problem_t& lp, - const simplex_solver_settings_t& settings, - csr_matrix_t& Arow, + const simplex::lp_problem_t& lp, + const simplex::simplex_solver_settings_t& settings, + simplex::csr_matrix_t& Arow, const std::vector& new_slacks, - const std::vector& var_types, - const user_problem_t& user_problem, + const std::vector& var_types, + const simplex::user_problem_t& user_problem, const probing_implied_bound_t& probing_implied_bound, - std::shared_ptr> clique_table = nullptr, - omp_atomic_t* signal_extend = nullptr) + std::shared_ptr> clique_table = nullptr, + omp_atomic_t* signal_extend = nullptr) : cut_pool_(cut_pool), knapsack_generation_(lp, settings, Arow, new_slacks, var_types), flow_cover_generation_(lp, settings, Arow, new_slacks), @@ -604,12 +606,12 @@ class cut_generation_t { { } - bool generate_cuts(const lp_problem_t& lp, - const simplex_solver_settings_t& settings, - csr_matrix_t& Arow, + bool generate_cuts(const simplex::lp_problem_t& lp, + const simplex::simplex_solver_settings_t& settings, + simplex::csr_matrix_t& Arow, const std::vector& new_slacks, - const std::vector& var_types, - basis_update_mpf_t& basis_update, + const std::vector& var_types, + simplex::basis_update_mpf_t& basis_update, const std::vector& xstar, const std::vector& ystar, const std::vector& zstar, @@ -620,65 +622,65 @@ class cut_generation_t { private: // Generate all mixed integer gomory cuts - void generate_gomory_cuts(const lp_problem_t& lp, - const simplex_solver_settings_t& settings, - csr_matrix_t& Arow, + void generate_gomory_cuts(const simplex::lp_problem_t& lp, + const simplex::simplex_solver_settings_t& settings, + simplex::csr_matrix_t& Arow, const std::vector& new_slacks, - const std::vector& var_types, - basis_update_mpf_t& basis_update, + const std::vector& var_types, + simplex::basis_update_mpf_t& basis_update, const std::vector& xstar, const std::vector& basic_list, const std::vector& nonbasic_list); // Generate all mixed integer rounding cuts - void generate_mir_cuts(const lp_problem_t& lp, - const simplex_solver_settings_t& settings, - csr_matrix_t& Arow, + void generate_mir_cuts(const simplex::lp_problem_t& lp, + const simplex::simplex_solver_settings_t& settings, + simplex::csr_matrix_t& Arow, const std::vector& new_slacks, - const std::vector& var_types, + const std::vector& var_types, const std::vector& xstar, const std::vector& ystar, variable_bounds_t& variable_bounds); // Generate all knapsack cuts - void generate_knapsack_cuts(const lp_problem_t& lp, - const simplex_solver_settings_t& settings, - csr_matrix_t& Arow, + void generate_knapsack_cuts(const simplex::lp_problem_t& lp, + const simplex::simplex_solver_settings_t& settings, + simplex::csr_matrix_t& Arow, const std::vector& new_slacks, - const std::vector& var_types, + const std::vector& var_types, const std::vector& xstar, f_t start_time); // Generate all flow cover cuts - void generate_flow_cover_cuts(const lp_problem_t& lp, - const simplex_solver_settings_t& settings, - csr_matrix_t& Arow, - const std::vector& var_types, + void generate_flow_cover_cuts(const simplex::lp_problem_t& lp, + const simplex::simplex_solver_settings_t& settings, + simplex::csr_matrix_t& Arow, + const std::vector& var_types, const std::vector& xstar, variable_bounds_t& variable_bounds, f_t start_time); // Generate clique cuts from conflict graph cliques - bool generate_clique_cuts(const lp_problem_t& lp, - const simplex_solver_settings_t& settings, - const std::vector& var_types, + bool generate_clique_cuts(const simplex::lp_problem_t& lp, + const simplex::simplex_solver_settings_t& settings, + const std::vector& var_types, const std::vector& xstar, const std::vector& reduced_costs, f_t start_time); // Generate implied bounds cuts from probing implications - void generate_implied_bound_cuts(const lp_problem_t& lp, - const simplex_solver_settings_t& settings, - const std::vector& var_types, + void generate_implied_bound_cuts(const simplex::lp_problem_t& lp, + const simplex::simplex_solver_settings_t& settings, + const std::vector& var_types, const std::vector& xstar, f_t start_time); cut_pool_t& cut_pool_; knapsack_generation_t knapsack_generation_; flow_cover_generation_t flow_cover_generation_; - const user_problem_t& user_problem_; + const simplex::user_problem_t& user_problem_; const probing_implied_bound_t& probing_implied_bound_; - std::shared_ptr> clique_table_; + std::shared_ptr> clique_table_; omp_atomic_t* signal_extend_{nullptr}; }; @@ -743,8 +745,8 @@ class mixed_integer_gomory_cut_t { template class tableau_equality_t { public: - tableau_equality_t(const lp_problem_t& lp, - basis_update_mpf_t& basis_update, + tableau_equality_t(const simplex::lp_problem_t& lp, + simplex::basis_update_mpf_t& basis_update, const std::vector& nonbasic_list) : b_bar_(lp.num_rows, 0.0), nonbasic_mark_(lp.num_cols, 0), @@ -759,11 +761,11 @@ class tableau_equality_t { } // Generates the base inequalities: C*x == d that will be turned into cuts - i_t generate_base_equality(const lp_problem_t& lp, - const simplex_solver_settings_t& settings, - csr_matrix_t& Arow, - const std::vector& var_types, - basis_update_mpf_t& basis_update, + i_t generate_base_equality(const simplex::lp_problem_t& lp, + const simplex::simplex_solver_settings_t& settings, + simplex::csr_matrix_t& Arow, + const std::vector& var_types, + simplex::basis_update_mpf_t& basis_update, const std::vector& xstar, const std::vector& basic_list, const std::vector& nonbasic_list, @@ -781,10 +783,10 @@ class tableau_equality_t { template class variable_bounds_t { public: - variable_bounds_t(const lp_problem_t& lp, - const simplex_solver_settings_t& settings, - const std::vector& var_types, - const csr_matrix_t& Arow, + variable_bounds_t(const simplex::lp_problem_t& lp, + const simplex::simplex_solver_settings_t& settings, + const std::vector& var_types, + const simplex::csr_matrix_t& Arow, const std::vector& new_slacks); std::vector upper_offsets; @@ -831,14 +833,15 @@ class variable_bounds_t { { if (num_lower_inf == 0) { return activity - lower_activity_i - lower_activity_j; - } else if (num_lower_inf == 1 && lower_activity_j == -inf) { + } else if (num_lower_inf == 1 && lower_activity_j == -simplex::inf) { return activity - lower_activity_i; - } else if (num_lower_inf == 1 && lower_activity_i == -inf) { + } else if (num_lower_inf == 1 && lower_activity_i == -simplex::inf) { return activity - lower_activity_j; - } else if (num_lower_inf == 2 && lower_activity_i == -inf && lower_activity_j == -inf) { + } else if (num_lower_inf == 2 && lower_activity_i == -simplex::inf && + lower_activity_j == -simplex::inf) { return activity; } else { - return -inf; + return -simplex::inf; } } @@ -857,14 +860,15 @@ class variable_bounds_t { { if (num_upper_inf == 0) { return activity - upper_activity_i - upper_activity_j; - } else if (num_upper_inf == 1 && upper_activity_j == inf) { + } else if (num_upper_inf == 1 && upper_activity_j == simplex::inf) { return activity - upper_activity_i; - } else if (num_upper_inf == 1 && upper_activity_i == inf) { + } else if (num_upper_inf == 1 && upper_activity_i == simplex::inf) { return activity - upper_activity_j; - } else if (num_upper_inf == 2 && upper_activity_i == inf && upper_activity_j == inf) { + } else if (num_upper_inf == 2 && upper_activity_i == simplex::inf && + upper_activity_j == simplex::inf) { return activity; } else { - return inf; + return simplex::inf; } } @@ -879,13 +883,14 @@ class variable_bounds_t { template class complemented_mixed_integer_rounding_cut_t { public: - complemented_mixed_integer_rounding_cut_t(const lp_problem_t& lp, - const simplex_solver_settings_t& settings, - const std::vector& new_slacks); - - void compute_initial_scores_for_rows(const lp_problem_t& lp, - const simplex_solver_settings_t& settings, - const csr_matrix_t& Arow, + complemented_mixed_integer_rounding_cut_t( + const simplex::lp_problem_t& lp, + const simplex::simplex_solver_settings_t& settings, + const std::vector& new_slacks); + + void compute_initial_scores_for_rows(const simplex::lp_problem_t& lp, + const simplex::simplex_solver_settings_t& settings, + const simplex::csr_matrix_t& Arow, const std::vector& xstar, const std::vector& ystar, std::vector& score); @@ -893,9 +898,9 @@ class complemented_mixed_integer_rounding_cut_t { // Perform bound substitution for the continuous variables using simple bounds // and variable bounds. And bound substitution for the integer variables // using simple bounds. - void bound_substitution(const lp_problem_t& lp, + void bound_substitution(const simplex::lp_problem_t& lp, const variable_bounds_t& variable_bounds, - const std::vector& var_types, + const std::vector& var_types, const std::vector& xstar, std::vector& transformed_xstar); @@ -906,7 +911,7 @@ class complemented_mixed_integer_rounding_cut_t { // where v_j = x_j - l_j for j in L // and w_j = u_j - x_j for j in U void transform_inequality(const variable_bounds_t& variable_bounds, - const std::vector& var_type, + const std::vector& var_type, inequality_t& inequality); // Converts an inequality of the form: @@ -917,16 +922,16 @@ class complemented_mixed_integer_rounding_cut_t { // back to the form: sum_j a_j x_j >= beta // with l_j <= x_j <= u_j void untransform_inequality(const variable_bounds_t& variable_bounds, - const std::vector& var_type, + const std::vector& var_type, inequality_t& inequality); bool cut_generation_heuristic(const inequality_t& transformed_inequality, - const std::vector& var_types, + const std::vector& var_types, const std::vector& transformed_xstar, inequality_t& transformed_cut, f_t& work_estimate); - bool scale_uncomplement_and_generate_cut(const std::vector& var_types, + bool scale_uncomplement_and_generate_cut(const std::vector& var_types, const std::vector& transformed_xstar, const std::vector& complemented_indices, const inequality_t& complemented_inequality, @@ -935,9 +940,10 @@ class complemented_mixed_integer_rounding_cut_t { f_t& work_estimate); // This routine takes an inequality and generates the MIR cut - bool generate_cut_nonnegative_maintain_indicies(const inequality_t& inequality, - const std::vector& var_types, - inequality_t& cut); + bool generate_cut_nonnegative_maintain_indicies( + const inequality_t& inequality, + const std::vector& var_types, + inequality_t& cut); f_t compute_violation(const inequality_t& cut, const std::vector& xstar); @@ -950,15 +956,15 @@ class complemented_mixed_integer_rounding_cut_t { const std::vector& upper_bounds, inequality_t& cut); - void substitute_slacks(const lp_problem_t& lp, - csr_matrix_t& Arow, + void substitute_slacks(const simplex::lp_problem_t& lp, + simplex::csr_matrix_t& Arow, inequality_t& cut); // Combine the pivot row with the inequality to eliminate the variable j // The new inequality is returned in inequality and inequality_rhs // The multiplier for the pivot row is returned - f_t combine_rows(const lp_problem_t& lp, - csr_matrix_t& Arow, + f_t combine_rows(const simplex::lp_problem_t& lp, + simplex::csr_matrix_t& Arow, i_t j, const inequality_t& pivot_row, inequality_t& inequality); @@ -969,7 +975,7 @@ class complemented_mixed_integer_rounding_cut_t { const i_t slack_rows(i_t j) const { return slack_rows_[j]; } const i_t slack_cols(i_t i) const { return slack_cols_[i]; } - bool scale_and_generate_mir_cut(const std::vector& var_types, + bool scale_and_generate_mir_cut(const std::vector& var_types, const std::vector& transformed_xstar, const inequality_t& inequality, f_t divisor, @@ -1005,68 +1011,70 @@ class complemented_mixed_integer_rounding_cut_t { template class strong_cg_cut_t { public: - strong_cg_cut_t(const lp_problem_t& lp, - const std::vector& var_types, + strong_cg_cut_t(const simplex::lp_problem_t& lp, + const std::vector& var_types, const std::vector& xstar); - i_t generate_strong_cg_cut(const lp_problem_t& lp, - const simplex_solver_settings_t& settings, - const std::vector& var_types, + i_t generate_strong_cg_cut(const simplex::lp_problem_t& lp, + const simplex::simplex_solver_settings_t& settings, + const std::vector& var_types, const inequality_t& inequality, const std::vector& xstar, inequality_t& cut); i_t remove_continuous_variables_integers_nonnegative( - const lp_problem_t& lp, - const simplex_solver_settings_t& settings, - const std::vector& var_types, + const simplex::lp_problem_t& lp, + const simplex::simplex_solver_settings_t& settings, + const std::vector& var_types, inequality_t& inequality); - void to_original_integer_variables(const lp_problem_t& lp, inequality_t& cut); + void to_original_integer_variables(const simplex::lp_problem_t& lp, + inequality_t& cut); - i_t generate_strong_cg_cut_integer_only(const simplex_solver_settings_t& settings, - const std::vector& var_types, - const inequality_t& inequality, - inequality_t& cut); + i_t generate_strong_cg_cut_integer_only( + const simplex::simplex_solver_settings_t& settings, + const std::vector& var_types, + const inequality_t& inequality, + inequality_t& cut); private: i_t generate_strong_cg_cut_helper(const std::vector& indicies, const std::vector& coefficients, f_t rhs, - const std::vector& var_types, + const std::vector& var_types, inequality_t& cut); std::vector transformed_variables_; }; template -i_t add_cuts(const simplex_solver_settings_t& settings, - const csr_matrix_t& cuts, +i_t add_cuts(const simplex::simplex_solver_settings_t& settings, + const simplex::csr_matrix_t& cuts, const std::vector& cut_rhs, - lp_problem_t& lp, + simplex::lp_problem_t& lp, std::vector& new_slacks, - lp_solution_t& solution, - basis_update_mpf_t& basis_update, + simplex::lp_solution_t& solution, + simplex::basis_update_mpf_t& basis_update, std::vector& basic_list, std::vector& nonbasic_list, - std::vector& vstatus, + std::vector& vstatus, std::vector& edge_norms); template -i_t remove_cuts(lp_problem_t& lp, - const simplex_solver_settings_t& settings, +i_t remove_cuts(simplex::lp_problem_t& lp, + const simplex::simplex_solver_settings_t& settings, f_t start_time, - csr_matrix_t& Arow, + simplex::csr_matrix_t& Arow, std::vector& new_slacks, i_t original_rows, - std::vector& var_types, - std::vector& vstatus, + std::vector& var_types, + std::vector& vstatus, std::vector& edge_norms, std::vector& x, std::vector& y, std::vector& z, std::vector& basic_list, std::vector& nonbasic_list, - basis_update_mpf_t& basis_update); + simplex::basis_update_mpf_t& basis_update); -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/cuts/objective_step.cpp b/cpp/src/cuts/objective_step.cpp index a166839343..a3978de228 100644 --- a/cpp/src/cuts/objective_step.cpp +++ b/cpp/src/cuts/objective_step.cpp @@ -14,7 +14,9 @@ #include #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::mip { + +using simplex::objective_step_t; namespace { @@ -408,4 +410,4 @@ template objective_step_t compute_objective_step_info(const s const std::vector&, const std::vector&); -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/cuts/objective_step.hpp b/cpp/src/cuts/objective_step.hpp index 8588cf1384..180be642a4 100644 --- a/cpp/src/cuts/objective_step.hpp +++ b/cpp/src/cuts/objective_step.hpp @@ -12,7 +12,7 @@ #include #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::mip { // Pure-host computation of the objective step for the case where lattice propagation is // required (i.e. at least one variable with nonzero objective coefficient is continuous @@ -23,7 +23,7 @@ namespace cuopt::linear_programming::dual_simplex { // objective coefficient is already lattice-known, step = gcd(|c_j|) can be computed // without ever touching the constraint matrix. template -objective_step_t compute_objective_step_info( +simplex::objective_step_t compute_objective_step_info( const std::vector& obj_coefs, const std::vector& is_lattice_known_initially, const std::vector& offsets, @@ -52,4 +52,4 @@ bool propagate_lattice(i_t n_vars, const std::vector& obj_coefs, std::vector& lattice_step); -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/cuts/rational.hpp b/cpp/src/cuts/rational.hpp index eee05f984e..014546ff3e 100644 --- a/cpp/src/cuts/rational.hpp +++ b/cpp/src/cuts/rational.hpp @@ -13,7 +13,7 @@ #include #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::mip { // Best rational approximation p/q to x with q <= max_denominator, via continued fractions. // On success, returns true with numerator/denominator set to a rational within 1e-14 of x. @@ -185,4 +185,4 @@ f_t gcd_of_integer_values(const std::vector& values) return static_cast(g); } -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/dual_simplex/basis_solves.cpp b/cpp/src/dual_simplex/basis_solves.cpp index c5fee4e108..a961e085aa 100644 --- a/cpp/src/dual_simplex/basis_solves.cpp +++ b/cpp/src/dual_simplex/basis_solves.cpp @@ -15,7 +15,7 @@ #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::simplex { // Work = 3 * m template @@ -998,4 +998,4 @@ template int b_solve(const csc_matrix_t& L, std::vector& solution); #endif -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/basis_solves.hpp b/cpp/src/dual_simplex/basis_solves.hpp index 76a9c396bc..74b213f362 100644 --- a/cpp/src/dual_simplex/basis_solves.hpp +++ b/cpp/src/dual_simplex/basis_solves.hpp @@ -12,7 +12,7 @@ #include #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::simplex { template i_t reorder_basic_list(const std::vector& q, std::vector& basic_list); @@ -91,4 +91,4 @@ i_t b_solve(const csc_matrix_t& L, const std::vector& rhs, std::vector& solution); -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/basis_updates.cpp b/cpp/src/dual_simplex/basis_updates.cpp index fdf8acf07d..f81962d054 100644 --- a/cpp/src/dual_simplex/basis_updates.cpp +++ b/cpp/src/dual_simplex/basis_updates.cpp @@ -14,7 +14,7 @@ #include #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::simplex { template i_t basis_update_t::b_solve(const std::vector& rhs, std::vector& solution) const @@ -238,7 +238,7 @@ i_t basis_update_t::l_solve(std::vector& rhs) const // First solve // L0*x0 = b f_t work_estimate = 0; - dual_simplex::lower_triangular_solve(L0_, rhs, work_estimate); + simplex::lower_triangular_solve(L0_, rhs, work_estimate); #ifdef CHECK_LOWER_SOLVE { matrix_vector_multiply(L0_, 1.0, rhs, -1.0, residual); @@ -373,7 +373,7 @@ i_t basis_update_t::l_transpose_solve(std::vector& rhs) const // L0'*y = c // TODO: handle a sparse rhs f_t work_estimate = 0; - dual_simplex::lower_triangular_transpose_solve(L0_, rhs, work_estimate); + simplex::lower_triangular_transpose_solve(L0_, rhs, work_estimate); return 0; } @@ -563,7 +563,7 @@ i_t basis_update_t::u_solve(std::vector& x) const #endif f_t work_estimate = 0; - dual_simplex::upper_triangular_solve(U_, bprime, work_estimate); + simplex::upper_triangular_solve(U_, bprime, work_estimate); #ifdef CHECK_UPPER_SOLVE matrix_vector_multiply(U_, 1.0, bprime, -1.0, residual); @@ -611,7 +611,7 @@ i_t basis_update_t::u_transpose_solve(std::vector& x) const std::vector bprime(m); inverse_permute_vector(col_permutation_, x, bprime); f_t work_estimate = 0; - dual_simplex::upper_triangular_transpose_solve(U_, bprime, work_estimate); + simplex::upper_triangular_transpose_solve(U_, bprime, work_estimate); permute_vector(col_permutation_, bprime, x); return 0; } @@ -881,7 +881,7 @@ i_t basis_update_t::update(std::vector& utilde, i_t leaving_index std::vector w(m); w[t] = delta; f_t work_estimate = 0; - dual_simplex::upper_triangular_transpose_solve(U_, w, work_estimate); + simplex::upper_triangular_transpose_solve(U_, w, work_estimate); #ifdef PARANOID { // Compute the residual of the solve @@ -1683,7 +1683,7 @@ template i_t basis_update_mpf_t::u_transpose_solve(std::vector& rhs) const { total_dense_U_transpose_++; - dual_simplex::upper_triangular_transpose_solve(U0_, rhs, work_estimate_); + simplex::upper_triangular_transpose_solve(U0_, rhs, work_estimate_); return 0; } @@ -1693,7 +1693,7 @@ i_t basis_update_mpf_t::u_transpose_solve(sparse_vector_t& r total_sparse_U_transpose_++; // U0'*x = y // Solve U0'*x0 = y - i_t top = dual_simplex::sparse_triangle_solve( + i_t top = simplex::sparse_triangle_solve( rhs, std::nullopt, xi_workspace_, U0_transpose_, x_workspace_.data(), work_estimate_); solve_to_sparse_vector(top, rhs); return 0; @@ -1727,7 +1727,7 @@ i_t basis_update_mpf_t::l_transpose_solve(std::vector& rhs) const work_estimate_ += 2 * num_updates_; // Solve for x such that L0^T * x = b' - dual_simplex::lower_triangular_transpose_solve(L0_, rhs, work_estimate_); + simplex::lower_triangular_transpose_solve(L0_, rhs, work_estimate_); return 0; } @@ -1800,7 +1800,7 @@ i_t basis_update_mpf_t::l_transpose_solve(sparse_vector_t& r sparse_vector_t b(m, nz); work_estimate_ += nz; gather_into_sparse_vector(nz, b); - i_t top = dual_simplex::sparse_triangle_solve( + i_t top = simplex::sparse_triangle_solve( b, std::nullopt, xi_workspace_, L0_transpose_, x_workspace_.data(), work_estimate_); solve_to_sparse_vector(top, rhs); @@ -1991,7 +1991,7 @@ i_t basis_update_mpf_t::u_solve(std::vector& rhs) const total_dense_U_++; const i_t m = L0_.m; // U*x = y - dual_simplex::upper_triangular_solve(U0_, rhs, work_estimate_); + simplex::upper_triangular_solve(U0_, rhs, work_estimate_); return 0; } @@ -2003,7 +2003,7 @@ i_t basis_update_mpf_t::u_solve(sparse_vector_t& rhs) const // U*x = y // Solve U0*x = y - i_t top = dual_simplex::sparse_triangle_solve( + i_t top = simplex::sparse_triangle_solve( rhs, std::nullopt, xi_workspace_, U0_, x_workspace_.data(), work_estimate_); solve_to_sparse_vector(top, rhs); @@ -2025,7 +2025,7 @@ i_t basis_update_mpf_t::l_solve(std::vector& rhs) const #ifdef CHECK_L_SOLVE std::vector rhs_check = rhs; #endif - dual_simplex::lower_triangular_solve(L0_, rhs, work_estimate_); + simplex::lower_triangular_solve(L0_, rhs, work_estimate_); #ifdef CHECK_L0_SOLVE matrix_vector_multiply(L0_, 1.0, rhs, -1.0, residual); @@ -2074,7 +2074,7 @@ i_t basis_update_mpf_t::l_solve(sparse_vector_t& rhs) const // L0 * T0 * T1 * ... * T_{num_updates_ - 1} * x = y // First solve L0*x0 = y - i_t top = dual_simplex::sparse_triangle_solve( + i_t top = simplex::sparse_triangle_solve( rhs, std::nullopt, xi_workspace_, L0_, x_workspace_.data(), work_estimate_); solve_to_workspace(top); // Uses xi_workspace_ and x_workspace_ to fill rhs i_t nz = m - top; @@ -2455,4 +2455,4 @@ template class basis_update_t; template class basis_update_mpf_t; #endif -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/basis_updates.hpp b/cpp/src/dual_simplex/basis_updates.hpp index f313e15c1e..9d98a1fb43 100644 --- a/cpp/src/dual_simplex/basis_updates.hpp +++ b/cpp/src/dual_simplex/basis_updates.hpp @@ -15,7 +15,7 @@ #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::simplex { // Forrest-Tomlin update to the LU factorization of a basis matrix B template @@ -484,4 +484,4 @@ class basis_update_mpf_t { mutable f_t work_estimate_{0.0}; }; -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/bound_flipping_ratio_test.cpp b/cpp/src/dual_simplex/bound_flipping_ratio_test.cpp index e30b067398..2434ea1acf 100644 --- a/cpp/src/dual_simplex/bound_flipping_ratio_test.cpp +++ b/cpp/src/dual_simplex/bound_flipping_ratio_test.cpp @@ -12,7 +12,7 @@ #include #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::simplex { template i_t bound_flipping_ratio_test_t::compute_breakpoints(std::vector& indicies, @@ -349,4 +349,4 @@ template class bound_flipping_ratio_test_t; #endif -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/bound_flipping_ratio_test.hpp b/cpp/src/dual_simplex/bound_flipping_ratio_test.hpp index 244ff334df..25ca75618f 100644 --- a/cpp/src/dual_simplex/bound_flipping_ratio_test.hpp +++ b/cpp/src/dual_simplex/bound_flipping_ratio_test.hpp @@ -12,7 +12,7 @@ #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::simplex { #define RATIO_TEST_NO_ENTERING_VARIABLE -1 #define RATIO_TEST_CONCURRENT_LIMIT CONCURRENT_HALT_RETURN // -2 @@ -103,4 +103,4 @@ class bound_flipping_ratio_test_t { f_t work_estimate_; }; -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/bounds_strengthening.cpp b/cpp/src/dual_simplex/bounds_strengthening.cpp index 6506ce4873..cac5515d8e 100644 --- a/cpp/src/dual_simplex/bounds_strengthening.cpp +++ b/cpp/src/dual_simplex/bounds_strengthening.cpp @@ -10,7 +10,7 @@ #include #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::simplex { template static inline f_t update_lb(f_t curr_lb, f_t coeff, f_t delta_min_act, f_t delta_max_act) @@ -294,4 +294,4 @@ bool bounds_strengthening_t::bounds_strengthening( template class bounds_strengthening_t; #endif -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/bounds_strengthening.hpp b/cpp/src/dual_simplex/bounds_strengthening.hpp index 009f7b2433..49b38184e8 100644 --- a/cpp/src/dual_simplex/bounds_strengthening.hpp +++ b/cpp/src/dual_simplex/bounds_strengthening.hpp @@ -9,7 +9,7 @@ #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::simplex { template class bounds_strengthening_t { @@ -42,4 +42,4 @@ class bounds_strengthening_t { std::vector constraint_lb; std::vector constraint_ub; }; -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/crossover.cpp b/cpp/src/dual_simplex/crossover.cpp index eb3b88ce50..068166cc5e 100644 --- a/cpp/src/dual_simplex/crossover.cpp +++ b/cpp/src/dual_simplex/crossover.cpp @@ -19,7 +19,7 @@ #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::simplex { namespace { @@ -1423,7 +1423,7 @@ crossover_status_t crossover(const lp_problem_t& lp, } else if (dual_feasible && !primal_feasible) { i_t dual_iter = 0; std::vector edge_norms; - dual::status_t status = + dual_status_t status = dual_phase2(2, 0, start_time, lp, settings, vstatus, solution, dual_iter, edge_norms); if (toc(start_time) > settings.time_limit) { settings.log.printf("Time limit exceeded\n"); @@ -1437,7 +1437,7 @@ crossover_status_t crossover(const lp_problem_t& lp, dual_infeas = dual_infeasibility(lp, settings, vstatus, solution.z); primal_res = primal_residual(lp, solution); dual_res = dual_residual(lp, solution); - if (status != dual::status_t::OPTIMAL) { + if (status != dual_status_t::OPTIMAL) { print_crossover_info(lp, settings, vstatus, solution, "Dual phase 2 complete"); } solution.iterations += dual_iter; @@ -1469,10 +1469,10 @@ crossover_status_t crossover(const lp_problem_t& lp, i_t iter = 0; lp_solution_t phase1_solution(phase1_problem.num_rows, phase1_problem.num_cols); std::vector junk; - dual::status_t phase1_status = dual_phase2( + dual_status_t phase1_status = dual_phase2( 1, 1, start_time, phase1_problem, settings, phase1_vstatus, phase1_solution, iter, junk); - if (phase1_status == dual::status_t::NUMERICAL || - phase1_status == dual::status_t::DUAL_UNBOUNDED) { + if (phase1_status == dual_status_t::NUMERICAL || + phase1_status == dual_status_t::DUAL_UNBOUNDED) { settings.log.printf("Failed in Phase 1\n"); phase1_solution.objective = -std::numeric_limits::infinity(); } @@ -1581,8 +1581,8 @@ crossover_status_t crossover(const lp_problem_t& lp, } settings.log.debug("Num flips %d\n", num_flips); print_crossover_info(lp, settings, vstatus, solution, "Dual phase 1 complete"); - dual_infeas = dual_infeasibility(lp, settings, vstatus, solution.z); - dual::status_t status = dual::status_t::NUMERICAL; + dual_infeas = dual_infeasibility(lp, settings, vstatus, solution.z); + dual_status_t status = dual_status_t::NUMERICAL; if (dual_infeas <= settings.dual_tol) { std::vector edge_norms; status = dual_phase2( @@ -1601,7 +1601,7 @@ crossover_status_t crossover(const lp_problem_t& lp, dual_infeas = dual_infeasibility(lp, settings, vstatus, solution.z); primal_res = primal_residual(lp, solution); dual_res = dual_residual(lp, solution); - if (status != dual::status_t::OPTIMAL) { + if (status != dual_status_t::OPTIMAL) { print_crossover_info(lp, settings, vstatus, solution, "Dual phase 2 complete"); } primal_feasible = primal_infeas <= primal_tol && primal_res <= primal_tol; @@ -1636,4 +1636,4 @@ template crossover_status_t crossover( #endif -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/crossover.hpp b/cpp/src/dual_simplex/crossover.hpp index 0bb1ff6627..1b0b0ba823 100644 --- a/cpp/src/dual_simplex/crossover.hpp +++ b/cpp/src/dual_simplex/crossover.hpp @@ -1,6 +1,6 @@ /* clang-format off */ /* - * SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. * SPDX-License-Identifier: Apache-2.0 */ /* clang-format on */ @@ -13,7 +13,7 @@ #include #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::simplex { enum class crossover_status_t : int8_t { OPTIMAL = 0, @@ -32,4 +32,4 @@ crossover_status_t crossover(const lp_problem_t& problem, lp_solution_t& solution, std::vector& vstatus); -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/folding.cpp b/cpp/src/dual_simplex/folding.cpp index f851e51d79..8e6724a07f 100644 --- a/cpp/src/dual_simplex/folding.cpp +++ b/cpp/src/dual_simplex/folding.cpp @@ -15,7 +15,7 @@ #include #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::simplex { template struct color_t { @@ -1748,4 +1748,4 @@ template void folding(lp_problem_t& problem, presolve_info_t& presolve_info); #endif -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/folding.hpp b/cpp/src/dual_simplex/folding.hpp index bba84dc936..74dd2e8d61 100644 --- a/cpp/src/dual_simplex/folding.hpp +++ b/cpp/src/dual_simplex/folding.hpp @@ -1,6 +1,6 @@ /* clang-format off */ /* - * SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. * SPDX-License-Identifier: Apache-2.0 */ /* clang-format on */ @@ -11,11 +11,11 @@ #include #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::simplex { template void folding(lp_problem_t& problem, const simplex_solver_settings_t& settings, presolve_info_t& presolve_info); -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/initial_basis.cpp b/cpp/src/dual_simplex/initial_basis.cpp index e415f03672..19426853b5 100644 --- a/cpp/src/dual_simplex/initial_basis.cpp +++ b/cpp/src/dual_simplex/initial_basis.cpp @@ -16,7 +16,7 @@ #include #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::simplex { uint8_t encode(variable_status_t vstatus) { @@ -325,4 +325,4 @@ template int initial_basis_selection( #endif -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/initial_basis.hpp b/cpp/src/dual_simplex/initial_basis.hpp index f4cb19efc5..ef7230946b 100644 --- a/cpp/src/dual_simplex/initial_basis.hpp +++ b/cpp/src/dual_simplex/initial_basis.hpp @@ -12,7 +12,7 @@ #include #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::simplex { enum class variable_status_t : int8_t { BASIC = 0, @@ -36,4 +36,4 @@ i_t initial_basis_selection(const lp_problem_t& problem, std::vector& vstatus, std::vector& dependent_rows); -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/logger.hpp b/cpp/src/dual_simplex/logger.hpp index f813086708..c35712fc26 100644 --- a/cpp/src/dual_simplex/logger.hpp +++ b/cpp/src/dual_simplex/logger.hpp @@ -17,7 +17,7 @@ #include #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::simplex { class logger_t { public: @@ -128,4 +128,4 @@ class logger_t { std::FILE* log_file; }; -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/phase1.cpp b/cpp/src/dual_simplex/phase1.cpp index 253c40d056..96b941d992 100644 --- a/cpp/src/dual_simplex/phase1.cpp +++ b/cpp/src/dual_simplex/phase1.cpp @@ -1,6 +1,6 @@ /* clang-format off */ /* - * SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. * SPDX-License-Identifier: Apache-2.0 */ /* clang-format on */ @@ -15,7 +15,7 @@ #include #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::simplex { template i_t create_phase1_problem(const lp_problem_t& lp, lp_problem_t& out) @@ -93,4 +93,4 @@ template int create_phase1_problem(const lp_problem_t& #endif -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/phase1.hpp b/cpp/src/dual_simplex/phase1.hpp index fe30321eda..e180746bef 100644 --- a/cpp/src/dual_simplex/phase1.hpp +++ b/cpp/src/dual_simplex/phase1.hpp @@ -1,6 +1,6 @@ /* clang-format off */ /* - * SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. * SPDX-License-Identifier: Apache-2.0 */ /* clang-format on */ @@ -14,9 +14,9 @@ #include #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::simplex { template i_t create_phase1_problem(const lp_problem_t& lp, lp_problem_t& out); -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/phase2.cpp b/cpp/src/dual_simplex/phase2.cpp index 7bbbd9a30c..36daed4c8d 100644 --- a/cpp/src/dual_simplex/phase2.cpp +++ b/cpp/src/dual_simplex/phase2.cpp @@ -42,7 +42,7 @@ #include #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::simplex { constexpr int FEATURE_LOG_INTERVAL = 100; @@ -262,8 +262,6 @@ void update_Arow(i_t leaving, work_estimate += 2 * row_mark.size(); } -namespace phase2 { - // Computes vectors farkas_y, farkas_zl, farkas_zu that satisfy // // A'*farkas_y + farkas_zl - farkas_zu ~= 0 @@ -273,6 +271,9 @@ namespace phase2 { // This is a Farkas certificate for the infeasibility of the primal problem // // A*x = b, l <= x <= u + +namespace phase2 { + template void compute_farkas_certificate(const lp_problem_t& lp, const simplex_solver_settings_t& settings, @@ -2348,16 +2349,16 @@ void prepare_optimality(i_t info, sol.objective = compute_objective(lp, sol.x); sol.user_objective = compute_user_objective(lp, sol.objective); - f_t perturbation = phase2::amount_of_perturbation(lp, objective); + f_t perturbation = amount_of_perturbation(lp, objective); f_t orig_perturbation = perturbation; if (perturbation > 1e-6 && phase == 2) { // Try to remove perturbation std::vector unperturbed_y(m); std::vector unperturbed_z(n); - phase2::compute_dual_solution_from_basis( + compute_dual_solution_from_basis( lp, ft, basic_list, nonbasic_list, unperturbed_y, unperturbed_z, work_estimate); { - const f_t dual_infeas = phase2::dual_infeasibility( + const f_t dual_infeas = dual_infeasibility( lp, settings, vstatus, unperturbed_z, settings.tight_tol, settings.dual_tol); if (dual_infeas <= settings.dual_tol) { settings.log.printf("Removed perturbation of %.2e.\n", perturbation); @@ -2372,8 +2373,8 @@ void prepare_optimality(i_t info, sol.l2_primal_residual = l2_primal_residual(lp, sol); sol.l2_dual_residual = l2_dual_residual(lp, sol); - const f_t dual_infeas = phase2::dual_infeasibility(lp, settings, vstatus, z, 0.0, 0.0); - const f_t primal_infeas = phase2::primal_infeasibility(lp, settings, vstatus, x); + const f_t dual_infeas = dual_infeasibility(lp, settings, vstatus, z, 0.0, 0.0); + const f_t primal_infeas = primal_infeasibility(lp, settings, vstatus, x); if (phase == 1 && iter > 0) { settings.log.printf("Dual phase I complete. Iterations %d. Time %.2f\n", iter, toc(start_time)); } @@ -2395,7 +2396,7 @@ void prepare_optimality(i_t info, f_t basic_infeas = 0.0; f_t nonbasic_infeas = 0.0; f_t basic_over = 0.0; - phase2::primal_infeasibility_breakdown( + primal_infeasibility_breakdown( lp, settings, vstatus, x, basic_infeas, nonbasic_infeas, basic_over); settings.log.printf( "Primal infeasibility %e/%e (Basic %e, Nonbasic %e, Basic over %e). Perturbation %e/%e. Info " @@ -2494,16 +2495,16 @@ class phase2_timers_t { } // namespace phase2 template -dual::status_t dual_phase2(i_t phase, - i_t slack_basis, - f_t start_time, - const lp_problem_t& lp, - const simplex_solver_settings_t& settings, - std::vector& vstatus, - lp_solution_t& sol, - i_t& iter, - std::vector& delta_y_steepest_edge, - work_limit_context_t* work_unit_context) +dual_status_t dual_phase2(i_t phase, + i_t slack_basis, + f_t start_time, + const lp_problem_t& lp, + const simplex_solver_settings_t& settings, + std::vector& vstatus, + lp_solution_t& sol, + i_t& iter, + std::vector& delta_y_steepest_edge, + work_limit_context_t* work_unit_context) { PHASE2_NVTX_RANGE("DualSimplex::phase2"); const i_t m = lp.num_rows; @@ -2529,20 +2530,20 @@ dual::status_t dual_phase2(i_t phase, } template -dual::status_t dual_phase2_with_advanced_basis(i_t phase, - i_t slack_basis, - bool initialize_basis, - f_t start_time, - const lp_problem_t& lp, - const simplex_solver_settings_t& settings, - std::vector& vstatus, - basis_update_mpf_t& ft, - std::vector& basic_list, - std::vector& nonbasic_list, - lp_solution_t& sol, - i_t& iter, - std::vector& delta_y_steepest_edge, - work_limit_context_t* work_unit_context) +dual_status_t dual_phase2_with_advanced_basis(i_t phase, + i_t slack_basis, + bool initialize_basis, + f_t start_time, + const lp_problem_t& lp, + const simplex_solver_settings_t& settings, + std::vector& vstatus, + basis_update_mpf_t& ft, + std::vector& basic_list, + std::vector& nonbasic_list, + lp_solution_t& sol, + i_t& iter, + std::vector& delta_y_steepest_edge, + work_limit_context_t* work_unit_context) { PHASE2_NVTX_RANGE("DualSimplex::phase2_advanced"); const i_t m = lp.num_rows; @@ -2570,7 +2571,7 @@ dual::status_t dual_phase2_with_advanced_basis(i_t phase, phase2_work_estimate += 2 * (n + m); - dual::status_t status = dual::status_t::UNSET; + dual_status_t status = dual_status_t::UNSET; nvtx_range_guard init_scope("DualSimplex::phase2_advanced_init"); @@ -2601,11 +2602,11 @@ dual::status_t dual_phase2_with_advanced_basis(i_t phase, i_t refactor_status = ft.refactor_basis( lp.A, settings, lp.lower, lp.upper, start_time, basic_list, nonbasic_list, vstatus); refactor_work = ft.work_estimate() - refactor_start_work; - if (refactor_status == CONCURRENT_HALT_RETURN) { return dual::status_t::CONCURRENT_LIMIT; } - if (refactor_status == TIME_LIMIT_RETURN) { return dual::status_t::TIME_LIMIT; } - if (refactor_status > 0) { return dual::status_t::NUMERICAL; } + if (refactor_status == CONCURRENT_HALT_RETURN) { return dual_status_t::CONCURRENT_LIMIT; } + if (refactor_status == TIME_LIMIT_RETURN) { return dual_status_t::TIME_LIMIT; } + if (refactor_status > 0) { return dual_status_t::NUMERICAL; } - if (toc(start_time) > settings.time_limit) { return dual::status_t::TIME_LIMIT; } + if (toc(start_time) > settings.time_limit) { return dual_status_t::TIME_LIMIT; } } // Populate c_basic after basis is initialized @@ -2617,7 +2618,7 @@ dual::status_t dual_phase2_with_advanced_basis(i_t phase, // Solve B'*y = cB ft.b_transpose_solve(c_basic, y); - if (toc(start_time) > settings.time_limit) { return dual::status_t::TIME_LIMIT; } + if (toc(start_time) > settings.time_limit) { return dual_status_t::TIME_LIMIT; } constexpr bool print_norms = false; if constexpr (print_norms) { settings.log.printf( @@ -2673,7 +2674,7 @@ dual::status_t dual_phase2_with_advanced_basis(i_t phase, xB_workspace, phase2_work_estimate); - if (toc(start_time) > settings.time_limit) { return dual::status_t::TIME_LIMIT; } + if (toc(start_time) > settings.time_limit) { return dual_status_t::TIME_LIMIT; } if (print_norms) { settings.log.printf("|| x || %e\n", vector_norm2(x)); } #ifdef COMPUTE_PRIMAL_RESIDUAL @@ -2700,8 +2701,8 @@ dual::status_t dual_phase2_with_advanced_basis(i_t phase, i_t status = phase2::initialize_steepest_edge_norms( lp, settings, start_time, basic_list, ft, delta_y_steepest_edge, phase2_work_estimate); f_t steepest_edge_time = toc(steepest_edge_start); - if (status == CONCURRENT_HALT_RETURN) { return dual::status_t::CONCURRENT_LIMIT; } - if (status == -1) { return dual::status_t::TIME_LIMIT; } + if (status == CONCURRENT_HALT_RETURN) { return dual_status_t::CONCURRENT_LIMIT; } + if (status == -1) { return dual_status_t::TIME_LIMIT; } } } else { // Check that none of the basic variables have a steepest edge that is nonpositive @@ -2715,7 +2716,7 @@ dual::status_t dual_phase2_with_advanced_basis(i_t phase, } if (settings.concurrent_halt != nullptr && *settings.concurrent_halt == 1) { - return dual::status_t::CONCURRENT_LIMIT; + return dual_status_t::CONCURRENT_LIMIT; } if (phase == 2) { @@ -2769,7 +2770,7 @@ dual::status_t dual_phase2_with_advanced_basis(i_t phase, lp.A.to_compressed_row(Arow); phase2_work_estimate += 2 * lp.A.col_start[lp.A.n]; if (settings.concurrent_halt != nullptr && *settings.concurrent_halt == 1) { - return dual::status_t::CONCURRENT_LIMIT; + return dual_status_t::CONCURRENT_LIMIT; } std::vector nonbasic_end(m); @@ -2779,7 +2780,7 @@ dual::status_t dual_phase2_with_advanced_basis(i_t phase, phase2_work_estimate += lp.A.col_start[lp.A.n]; if (settings.concurrent_halt != nullptr && *settings.concurrent_halt == 1) { - return dual::status_t::CONCURRENT_LIMIT; + return dual_status_t::CONCURRENT_LIMIT; } f_t obj = compute_objective(lp, x); @@ -2934,11 +2935,9 @@ dual::status_t dual_phase2_with_advanced_basis(i_t phase, f_t refactor_start_work = ft.work_estimate(); i_t refactor_status = ft.refactor_basis( lp.A, settings, lp.lower, lp.upper, start_time, basic_list, nonbasic_list, vstatus); - if (refactor_status == CONCURRENT_HALT_RETURN) { - return dual::status_t::CONCURRENT_LIMIT; - } - if (refactor_status == TIME_LIMIT_RETURN) { return dual::status_t::TIME_LIMIT; } - if (refactor_status > 0) { return dual::status_t::NUMERICAL; } + if (refactor_status == CONCURRENT_HALT_RETURN) { return dual_status_t::CONCURRENT_LIMIT; } + if (refactor_status == TIME_LIMIT_RETURN) { return dual_status_t::TIME_LIMIT; } + if (refactor_status > 0) { return dual_status_t::NUMERICAL; } refactor_work = ft.work_estimate() - refactor_start_work; phase2::reset_basis_mark( @@ -2987,14 +2986,14 @@ dual::status_t dual_phase2_with_advanced_basis(i_t phase, y, z, sol); - status = dual::status_t::OPTIMAL; + status = dual_status_t::OPTIMAL; break; } - if (toc(start_time) > settings.time_limit) { return dual::status_t::TIME_LIMIT; } + if (toc(start_time) > settings.time_limit) { return dual_status_t::TIME_LIMIT; } if (settings.concurrent_halt != nullptr && *settings.concurrent_halt == 1) { - return dual::status_t::CONCURRENT_LIMIT; + return dual_status_t::CONCURRENT_LIMIT; } // BTran @@ -3011,7 +3010,7 @@ dual::status_t dual_phase2_with_advanced_basis(i_t phase, solve_work += (ft.work_estimate() - btran_start_work); if (settings.concurrent_halt != nullptr && *settings.concurrent_halt == 1) { - return dual::status_t::CONCURRENT_LIMIT; + return dual_status_t::CONCURRENT_LIMIT; } const f_t steepest_edge_norm_check = delta_y_sparse.norm2_squared(); @@ -3072,7 +3071,7 @@ dual::status_t dual_phase2_with_advanced_basis(i_t phase, } timers.delta_z_time += timers.stop_timer(); if (settings.concurrent_halt != nullptr && *settings.concurrent_halt == 1) { - return dual::status_t::CONCURRENT_LIMIT; + return dual_status_t::CONCURRENT_LIMIT; } #ifdef COMPUTE_DUAL_RESIDUAL @@ -3127,7 +3126,7 @@ dual::status_t dual_phase2_with_advanced_basis(i_t phase, phase2_work_estimate += bfrt.work_estimate(); if (entering_index == RATIO_TEST_NUMERICAL_ISSUES) { settings.log.printf("Numerical issues encountered in ratio test.\n"); - return dual::status_t::NUMERICAL; + return dual_status_t::NUMERICAL; } timers.bfrt_time += timers.stop_timer(); } else { @@ -3135,8 +3134,8 @@ dual::status_t dual_phase2_with_advanced_basis(i_t phase, lp, settings, vstatus, nonbasic_list, z, delta_z, step_length, nonbasic_entering_index); } } - if (entering_index == RATIO_TEST_TIME_LIMIT) { return dual::status_t::TIME_LIMIT; } - if (entering_index == CONCURRENT_HALT_RETURN) { return dual::status_t::CONCURRENT_LIMIT; } + if (entering_index == RATIO_TEST_TIME_LIMIT) { return dual_status_t::TIME_LIMIT; } + if (entering_index == CONCURRENT_HALT_RETURN) { return dual_status_t::CONCURRENT_LIMIT; } if (entering_index == RATIO_TEST_NO_ENTERING_VARIABLE) { settings.log.printf("No entering variable found. Iter %d\n", iter); settings.log.printf("Scaled infeasibility %e\n", max_val); @@ -3207,7 +3206,7 @@ dual::status_t dual_phase2_with_advanced_basis(i_t phase, y, z, sol); - status = dual::status_t::OPTIMAL; + status = dual_status_t::OPTIMAL; break; } settings.log.printf( @@ -3263,7 +3262,7 @@ dual::status_t dual_phase2_with_advanced_basis(i_t phase, y, z, sol); - status = dual::status_t::OPTIMAL; + status = dual_status_t::OPTIMAL; break; } settings.log.printf("Failed to remove perturbation of %.2e.\n", perturbation); @@ -3305,7 +3304,7 @@ dual::status_t dual_phase2_with_advanced_basis(i_t phase, phase2::dual_infeasibility(lp, settings, vstatus, z, settings.tight_tol, settings.dual_tol); phase2_work_estimate += 3 * n; settings.log.printf("Dual infeasibility %e\n", dual_infeas); - const f_t primal_inf = phase2::primal_infeasibility(lp, settings, vstatus, x); + const f_t primal_inf = simplex::phase2::primal_infeasibility(lp, settings, vstatus, x); phase2_work_estimate += 3 * n; settings.log.printf("Primal infeasibility %e\n", primal_inf); settings.log.printf("Updates %d\n", ft.num_updates()); @@ -3313,9 +3312,9 @@ dual::status_t dual_phase2_with_advanced_basis(i_t phase, if (dual_infeas > settings.dual_tol) { settings.log.printf( "Numerical issues encountered. No entering variable found with large infeasibility.\n"); - return dual::status_t::NUMERICAL; + return dual_status_t::NUMERICAL; } - return dual::status_t::DUAL_UNBOUNDED; + return dual_status_t::DUAL_UNBOUNDED; } timers.start_timer(); @@ -3332,7 +3331,7 @@ dual::status_t dual_phase2_with_advanced_basis(i_t phase, phase2_work_estimate); if (update_dual_variables_status == -1) { settings.log.printf("Numerical issues encountered in update_dual_variables.\n"); - return dual::status_t::NUMERICAL; + return dual_status_t::NUMERICAL; } timers.vector_time += timers.stop_timer(); @@ -3405,13 +3404,13 @@ dual::status_t dual_phase2_with_advanced_basis(i_t phase, delta_x, phase2_work_estimate) == -1) { settings.log.printf("Failed to compute delta_x. Iter %d\n", iter); - return dual::status_t::NUMERICAL; + return dual_status_t::NUMERICAL; } } solve_work += (ft.work_estimate() - ftran_start_work); timers.ftran_time += timers.stop_timer(); if (settings.concurrent_halt != nullptr && *settings.concurrent_halt == 1) { - return dual::status_t::CONCURRENT_LIMIT; + return dual_status_t::CONCURRENT_LIMIT; } #ifdef CHECK_PRIMAL_STEP @@ -3447,7 +3446,7 @@ dual::status_t dual_phase2_with_advanced_basis(i_t phase, solve_work += (ft.work_estimate() - se_norms_start_work); if (settings.concurrent_halt != nullptr && *settings.concurrent_halt == 1) { - return dual::status_t::CONCURRENT_LIMIT; + return dual_status_t::CONCURRENT_LIMIT; } timers.start_timer(); @@ -3593,33 +3592,33 @@ dual::status_t dual_phase2_with_advanced_basis(i_t phase, f_t refactor_start_work = ft.work_estimate(); i_t refactor_status = ft.refactor_basis( lp.A, settings, lp.lower, lp.upper, start_time, basic_list, nonbasic_list, vstatus); - if (refactor_status == CONCURRENT_HALT_RETURN) { return dual::status_t::CONCURRENT_LIMIT; } - if (refactor_status == TIME_LIMIT_RETURN) { return dual::status_t::TIME_LIMIT; } + if (refactor_status == CONCURRENT_HALT_RETURN) { return dual_status_t::CONCURRENT_LIMIT; } + if (refactor_status == TIME_LIMIT_RETURN) { return dual_status_t::TIME_LIMIT; } if (refactor_status > 0) { should_recompute_x = true; settings.log.printf("Failed to factorize basis. Iteration %d\n", iter); - if (toc(start_time) > settings.time_limit) { return dual::status_t::TIME_LIMIT; } + if (toc(start_time) > settings.time_limit) { return dual_status_t::TIME_LIMIT; } i_t count = 0; i_t deficient_size = 0; while (true) { deficient_size = ft.refactor_basis( lp.A, settings, lp.lower, lp.upper, start_time, basic_list, nonbasic_list, vstatus); if (deficient_size == CONCURRENT_HALT_RETURN) { - return dual::status_t::CONCURRENT_LIMIT; + return dual_status_t::CONCURRENT_LIMIT; } - if (deficient_size == TIME_LIMIT_RETURN) { return dual::status_t::TIME_LIMIT; } + if (deficient_size == TIME_LIMIT_RETURN) { return dual_status_t::TIME_LIMIT; } if (deficient_size <= 0) { break; } settings.log.printf("Failed to repair basis. Iteration %d. %d deficient columns.\n", iter, static_cast(deficient_size)); - if (toc(start_time) > settings.time_limit) { return dual::status_t::TIME_LIMIT; } + if (toc(start_time) > settings.time_limit) { return dual_status_t::TIME_LIMIT; } settings.threshold_partial_pivoting_tol = 1.0; count++; - if (count > 10) { return dual::status_t::NUMERICAL; } + if (count > 10) { return dual_status_t::NUMERICAL; } } - if (deficient_size < 0) { return dual::status_t::NUMERICAL; } + if (deficient_size < 0) { return dual_status_t::NUMERICAL; } settings.log.printf("Successfully repaired basis. Iteration %d\n", iter); } @@ -3711,20 +3710,20 @@ dual::status_t dual_phase2_with_advanced_basis(i_t phase, if (obj >= settings.cut_off) { settings.log.printf("Solve cutoff. Current objecive %e. Cutoff %e\n", obj, settings.cut_off); - return dual::status_t::CUTOFF; + return dual_status_t::CUTOFF; } if (work_unit_context && work_unit_context->global_work_units_elapsed >= settings.work_limit) { - return dual::status_t::WORK_LIMIT; + return dual_status_t::WORK_LIMIT; } - if (now > settings.time_limit) { return dual::status_t::TIME_LIMIT; } + if (now > settings.time_limit) { return dual_status_t::TIME_LIMIT; } if (settings.concurrent_halt != nullptr && *settings.concurrent_halt == 1) { - return dual::status_t::CONCURRENT_LIMIT; + return dual_status_t::CONCURRENT_LIMIT; } } - if (iter >= iter_limit) { status = dual::status_t::ITERATION_LIMIT; } + if (iter >= iter_limit) { status = dual_status_t::ITERATION_LIMIT; } if (phase == 2) { timers.print_timers(settings); @@ -3748,7 +3747,7 @@ dual::status_t dual_phase2_with_advanced_basis(i_t phase, #ifdef DUAL_SIMPLEX_INSTANTIATE_DOUBLE -template dual::status_t dual_phase2( +template dual_status_t dual_phase2( int phase, int slack_basis, double start_time, @@ -3760,7 +3759,7 @@ template dual::status_t dual_phase2( std::vector& steepest_edge_norms, work_limit_context_t* work_unit_context); -template dual::status_t dual_phase2_with_advanced_basis( +template dual_status_t dual_phase2_with_advanced_basis( int phase, int slack_basis, bool initialize_basis, @@ -3802,4 +3801,4 @@ template void compute_initial_nonbasic_end(const std::vector& std::vector& nonbasic_end); #endif -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/phase2.hpp b/cpp/src/dual_simplex/phase2.hpp index 266d57c19f..294c2b63bc 100644 --- a/cpp/src/dual_simplex/phase2.hpp +++ b/cpp/src/dual_simplex/phase2.hpp @@ -21,10 +21,9 @@ namespace cuopt { struct work_limit_context_t; } -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::simplex { -namespace dual { -enum class status_t { +enum class dual_status_t { OPTIMAL = 0, DUAL_UNBOUNDED = 1, NUMERICAL = 2, @@ -36,50 +35,49 @@ enum class status_t { UNSET = 8 }; -static std::string status_to_string(status_t status) +static std::string dual_status_to_string(dual_status_t status) { switch (status) { - case status_t::OPTIMAL: return "OPTIMAL"; - case status_t::DUAL_UNBOUNDED: return "DUAL_UNBOUNDED"; - case status_t::NUMERICAL: return "NUMERICAL"; - case status_t::CUTOFF: return "CUTOFF"; - case status_t::TIME_LIMIT: return "TIME_LIMIT"; - case status_t::ITERATION_LIMIT: return "ITERATION_LIMIT"; - case status_t::CONCURRENT_LIMIT: return "CONCURRENT_LIMIT"; - case status_t::WORK_LIMIT: return "WORK_LIMIT"; - case status_t::UNSET: return "UNSET"; + case dual_status_t::OPTIMAL: return "OPTIMAL"; + case dual_status_t::DUAL_UNBOUNDED: return "DUAL_UNBOUNDED"; + case dual_status_t::NUMERICAL: return "NUMERICAL"; + case dual_status_t::CUTOFF: return "CUTOFF"; + case dual_status_t::TIME_LIMIT: return "TIME_LIMIT"; + case dual_status_t::ITERATION_LIMIT: return "ITERATION_LIMIT"; + case dual_status_t::CONCURRENT_LIMIT: return "CONCURRENT_LIMIT"; + case dual_status_t::WORK_LIMIT: return "WORK_LIMIT"; + case dual_status_t::UNSET: return "UNSET"; } return "UNKNOWN"; } -} // namespace dual template -dual::status_t dual_phase2(i_t phase, - i_t slack_basis, - f_t start_time, - const lp_problem_t& lp, - const simplex_solver_settings_t& settings, - std::vector& vstatus, - lp_solution_t& sol, - i_t& iter, - std::vector& steepest_edge_norms, - work_limit_context_t* work_unit_context = nullptr); +dual_status_t dual_phase2(i_t phase, + i_t slack_basis, + f_t start_time, + const lp_problem_t& lp, + const simplex_solver_settings_t& settings, + std::vector& vstatus, + lp_solution_t& sol, + i_t& iter, + std::vector& steepest_edge_norms, + work_limit_context_t* work_unit_context = nullptr); template -dual::status_t dual_phase2_with_advanced_basis(i_t phase, - i_t slack_basis, - bool initialize_basis, - f_t start_time, - const lp_problem_t& lp, - const simplex_solver_settings_t& settings, - std::vector& vstatus, - basis_update_mpf_t& ft, - std::vector& basic_list, - std::vector& nonbasic_list, - lp_solution_t& sol, - i_t& iter, - std::vector& delta_y_steepest_edge, - work_limit_context_t* work_unit_context = nullptr); +dual_status_t dual_phase2_with_advanced_basis(i_t phase, + i_t slack_basis, + bool initialize_basis, + f_t start_time, + const lp_problem_t& lp, + const simplex_solver_settings_t& settings, + std::vector& vstatus, + basis_update_mpf_t& ft, + std::vector& basic_list, + std::vector& nonbasic_list, + lp_solution_t& sol, + i_t& iter, + std::vector& delta_y_steepest_edge, + work_limit_context_t* work_unit_context = nullptr); template void compute_reduced_cost_update(const lp_problem_t& lp, @@ -109,4 +107,4 @@ void compute_initial_nonbasic_end(const std::vector& basic_mark, csr_matrix_t& Arow, std::vector& nonbasic_end); -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/presolve.cpp b/cpp/src/dual_simplex/presolve.cpp index d438fd133b..9c55185c6d 100644 --- a/cpp/src/dual_simplex/presolve.cpp +++ b/cpp/src/dual_simplex/presolve.cpp @@ -17,7 +17,7 @@ #include #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::simplex { template /** Number of leading linear columns; SOCP cone variables occupy [linear_cols, num_cols). */ @@ -1942,4 +1942,4 @@ template void uncrush_solution(const presolve_info_t& #endif -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/presolve.hpp b/cpp/src/dual_simplex/presolve.hpp index 22e578047f..855a4e6145 100644 --- a/cpp/src/dual_simplex/presolve.hpp +++ b/cpp/src/dual_simplex/presolve.hpp @@ -20,7 +20,7 @@ #include #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::simplex { template struct lp_problem_t { @@ -273,4 +273,4 @@ void uncrush_solution(const presolve_info_t& presolve_info, std::vector& uncrushed_y, std::vector& uncrushed_z); -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/primal.cpp b/cpp/src/dual_simplex/primal.cpp index d4c6743dc6..5451a57f08 100644 --- a/cpp/src/dual_simplex/primal.cpp +++ b/cpp/src/dual_simplex/primal.cpp @@ -14,7 +14,7 @@ #include #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::simplex { namespace { @@ -246,13 +246,13 @@ f_t primal_infeasibility(const lp_problem_t& lp, // after dual simplex has found a primal feasible solution // The implementation currently cycles. So is not enabled at this time. template -primal::status_t primal_phase2(i_t phase, - f_t start_time, - const lp_problem_t& lp, - const simplex_solver_settings_t& settings, - std::vector& vstatus, - lp_solution_t& sol, - i_t& iter) +primal_status_t primal_phase2(i_t phase, + f_t start_time, + const lp_problem_t& lp, + const simplex_solver_settings_t& settings, + std::vector& vstatus, + lp_solution_t& sol, + i_t& iter) { const i_t m = lp.num_rows; const i_t n = lp.num_cols; @@ -308,12 +308,12 @@ primal::status_t primal_phase2(i_t phase, slacks_needed, work_estimate); if (rank == CONCURRENT_HALT_RETURN) { - return primal::status_t::CONCURRENT_LIMIT; + return primal_status_t::CONCURRENT_LIMIT; } else if (rank == TIME_LIMIT_RETURN) { - return primal::status_t::TIME_LIMIT; + return primal_status_t::TIME_LIMIT; } else if (rank < 0) { - return toc(start_time) > settings.time_limit ? primal::status_t::TIME_LIMIT - : primal::status_t::NUMERICAL; + return toc(start_time) > settings.time_limit ? primal_status_t::TIME_LIMIT + : primal_status_t::NUMERICAL; } else if (rank != m) { settings.log.debug("Failed to factorize basis. rank %d m %d\n", rank, m); basis_repair(lp.A, @@ -340,13 +340,13 @@ primal::status_t primal_phase2(i_t phase, slacks_needed, work_estimate); if (rank == CONCURRENT_HALT_RETURN) { - return primal::status_t::CONCURRENT_LIMIT; + return primal_status_t::CONCURRENT_LIMIT; } else if (rank == TIME_LIMIT_RETURN) { - return primal::status_t::TIME_LIMIT; + return primal_status_t::TIME_LIMIT; } else if (rank < 0) { settings.log.printf("Failed to factorize basis after repair. rank %d m %d\n", rank, m); - return toc(start_time) > settings.time_limit ? primal::status_t::TIME_LIMIT - : primal::status_t::NUMERICAL; + return toc(start_time) > settings.time_limit ? primal_status_t::TIME_LIMIT + : primal_status_t::NUMERICAL; } else { settings.log.debug("Basis repaired\n"); } @@ -443,7 +443,7 @@ primal::status_t primal_phase2(i_t phase, dual_inf, primal_inf, iter); - return primal::status_t::OPTIMAL; + return primal_status_t::OPTIMAL; } std::vector scaled_delta_xB(m); @@ -476,7 +476,7 @@ primal::status_t primal_phase2(i_t phase, i_t leaving_index = ratio_test(lp, vstatus, basic_list, x, delta_x, step_length, basic_leaving); if (leaving_index == -1) { settings.log.printf("No leaving variable. Primal unbounded?\n"); - return primal::status_t::PRIMAL_UNBOUNDED; + return primal_status_t::PRIMAL_UNBOUNDED; } assert(step_length >= 0.0); @@ -540,14 +540,14 @@ primal::status_t primal_phase2(i_t phase, iter++; } - if (iter == iter_limit) { return primal::status_t::ITERATION_LIMIT; } + if (iter == iter_limit) { return primal_status_t::ITERATION_LIMIT; } - return primal::status_t::NUMERICAL; + return primal_status_t::NUMERICAL; } #ifdef DUAL_SIMPLEX_INSTANTIATE_DOUBLE -template primal::status_t primal_phase2( +template primal_status_t primal_phase2( int phase, double start_time, const lp_problem_t& lp, @@ -558,4 +558,4 @@ template primal::status_t primal_phase2( #endif -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/primal.hpp b/cpp/src/dual_simplex/primal.hpp index bd72fee4b3..33bcfa722d 100644 --- a/cpp/src/dual_simplex/primal.hpp +++ b/cpp/src/dual_simplex/primal.hpp @@ -15,10 +15,9 @@ #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::simplex { -namespace primal { -enum class status_t { +enum class primal_status_t { OPTIMAL = 0, PRIMAL_UNBOUNDED = 1, NUMERICAL = 2, @@ -27,15 +26,14 @@ enum class status_t { ITERATION_LIMIT = 5, CONCURRENT_LIMIT = 6 }; -} template -primal::status_t primal_phase2(i_t phase, - f_t start_time, - const lp_problem_t& lp, - const simplex_solver_settings_t& settings, - std::vector& vstatus, - lp_solution_t& sol, - i_t& iter); +primal_status_t primal_phase2(i_t phase, + f_t start_time, + const lp_problem_t& lp, + const simplex_solver_settings_t& settings, + std::vector& vstatus, + lp_solution_t& sol, + i_t& iter); -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/random.hpp b/cpp/src/dual_simplex/random.hpp index 571a59857a..3d084d2acf 100644 --- a/cpp/src/dual_simplex/random.hpp +++ b/cpp/src/dual_simplex/random.hpp @@ -1,6 +1,6 @@ /* clang-format off */ /* - * SPDX-FileCopyrightText: Copyright (c) 2023-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-FileCopyrightText: Copyright (c) 2023-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. * SPDX-License-Identifier: Apache-2.0 */ /* clang-format on */ @@ -9,7 +9,7 @@ #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::simplex { template class random_t { @@ -34,4 +34,4 @@ class random_t { std::mt19937 gen; }; -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/right_looking_lu.cpp b/cpp/src/dual_simplex/right_looking_lu.cpp index 00f2fefb62..2882662f17 100644 --- a/cpp/src/dual_simplex/right_looking_lu.cpp +++ b/cpp/src/dual_simplex/right_looking_lu.cpp @@ -17,7 +17,7 @@ using cuopt::ins_vector; -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::simplex { namespace { @@ -1813,4 +1813,4 @@ template int right_looking_ldlt(const csc_matrix_t& A, double& work_estimate); #endif -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/right_looking_lu.hpp b/cpp/src/dual_simplex/right_looking_lu.hpp index 9b2814dfde..58f0b4ee7d 100644 --- a/cpp/src/dual_simplex/right_looking_lu.hpp +++ b/cpp/src/dual_simplex/right_looking_lu.hpp @@ -12,7 +12,7 @@ #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::simplex { template i_t right_looking_lu(const csc_matrix_t& A, @@ -56,4 +56,4 @@ i_t right_looking_ldlt(const csc_matrix_t& A, std::vector& D, f_t& work_estimate); -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/scaling.cpp b/cpp/src/dual_simplex/scaling.cpp index 92b4d3377d..ac96496ec6 100644 --- a/cpp/src/dual_simplex/scaling.cpp +++ b/cpp/src/dual_simplex/scaling.cpp @@ -10,7 +10,7 @@ #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::simplex { template i_t scaling(const lp_problem_t& unscaled, @@ -286,4 +286,4 @@ template void unscale_solution(const std::vector& column_sc #endif -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/scaling.hpp b/cpp/src/dual_simplex/scaling.hpp index df0bf4d845..eab60c486b 100644 --- a/cpp/src/dual_simplex/scaling.hpp +++ b/cpp/src/dual_simplex/scaling.hpp @@ -14,7 +14,7 @@ #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::simplex { template i_t scaling(const lp_problem_t& unscaled, @@ -33,4 +33,4 @@ void unscale_solution(const std::vector& column_scaling, std::vector& unscaled_y, std::vector& unscaled_z); -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/simplex_solver_settings.hpp b/cpp/src/dual_simplex/simplex_solver_settings.hpp index 286ac7364f..45168ced8a 100644 --- a/cpp/src/dual_simplex/simplex_solver_settings.hpp +++ b/cpp/src/dual_simplex/simplex_solver_settings.hpp @@ -7,7 +7,7 @@ #pragma once -#include +#include #include #include @@ -20,11 +20,11 @@ #include #include -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { struct benchmark_info_t; } -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::simplex { template struct simplex_solver_settings_t { @@ -225,7 +225,7 @@ struct simplex_solver_settings_t { std::atomic* concurrent_halt; // if nullptr ignored, if !nullptr, 0 if solver should // continue, 1 if solver should halt // Optional non-owning pointer to run-level benchmark stats. - cuopt::linear_programming::benchmark_info_t* benchmark_info_ptr = nullptr; + cuopt::mathematical_optimization::benchmark_info_t* benchmark_info_ptr = nullptr; }; -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/singletons.cpp b/cpp/src/dual_simplex/singletons.cpp index dbba46f6a5..4d686b2ac1 100644 --- a/cpp/src/dual_simplex/singletons.cpp +++ b/cpp/src/dual_simplex/singletons.cpp @@ -11,7 +11,7 @@ #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::simplex { // Destroys the queue but prints it template @@ -315,4 +315,4 @@ template int find_singletons(const csc_matrix_t& A, double& work_estimate); #endif -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/singletons.hpp b/cpp/src/dual_simplex/singletons.hpp index 9bbe9270f7..59964fc428 100644 --- a/cpp/src/dual_simplex/singletons.hpp +++ b/cpp/src/dual_simplex/singletons.hpp @@ -12,7 +12,7 @@ #include #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::simplex { template struct row_col_graph_t { @@ -52,4 +52,4 @@ i_t find_singletons(const csc_matrix_t& A, std::vector& col_perm, f_t& work_estimate); -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/solution.hpp b/cpp/src/dual_simplex/solution.hpp index 86213c86e9..435e9a9fce 100644 --- a/cpp/src/dual_simplex/solution.hpp +++ b/cpp/src/dual_simplex/solution.hpp @@ -12,7 +12,7 @@ #include #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::simplex { template class lp_solution_t { @@ -78,4 +78,4 @@ class mip_solution_t { omp_atomic_t has_incumbent; }; -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/solve.cpp b/cpp/src/dual_simplex/solve.cpp index d81265358a..7c4f13d8c5 100644 --- a/cpp/src/dual_simplex/solve.cpp +++ b/cpp/src/dual_simplex/solve.cpp @@ -33,12 +33,12 @@ #include #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::simplex { namespace { template -void write_matlab(const std::string& filename, const dual_simplex::lp_problem_t& lp) +void write_matlab(const std::string& filename, const simplex::lp_problem_t& lp) { FILE* fid = fopen(filename.c_str(), "w"); if (fid == NULL) { printf("Can't open file %s\n", filename.c_str()); } @@ -200,7 +200,7 @@ lp_status_t solve_linear_program_with_advanced_basis( i_t iter = 0; lp_solution_t phase1_solution(phase1_problem.num_rows, phase1_problem.num_cols); edge_norms.clear(); - dual::status_t phase1_status; + dual_status_t phase1_status; { raft::common::nvtx::range scope_phase1("DualSimplex::phase1"); phase1_status = dual_phase2(1, @@ -214,17 +214,17 @@ lp_status_t solve_linear_program_with_advanced_basis( edge_norms, work_unit_context); } - if (phase1_status == dual::status_t::NUMERICAL) { + if (phase1_status == dual_status_t::NUMERICAL) { settings.log.printf("Failed in Phase 1\n"); return lp_status_t::NUMERICAL_ISSUES; } - if (phase1_status == dual::status_t::DUAL_UNBOUNDED) { + if (phase1_status == dual_status_t::DUAL_UNBOUNDED) { return lp_status_t::UNBOUNDED_OR_INFEASIBLE; } - if (phase1_status == dual::status_t::TIME_LIMIT) { return lp_status_t::TIME_LIMIT; } - if (phase1_status == dual::status_t::WORK_LIMIT) { return lp_status_t::WORK_LIMIT; } - if (phase1_status == dual::status_t::ITERATION_LIMIT) { return lp_status_t::ITERATION_LIMIT; } - if (phase1_status == dual::status_t::CONCURRENT_LIMIT) { + if (phase1_status == dual_status_t::TIME_LIMIT) { return lp_status_t::TIME_LIMIT; } + if (phase1_status == dual_status_t::WORK_LIMIT) { return lp_status_t::WORK_LIMIT; } + if (phase1_status == dual_status_t::ITERATION_LIMIT) { return lp_status_t::ITERATION_LIMIT; } + if (phase1_status == dual_status_t::CONCURRENT_LIMIT) { original_solution.iterations = iter; return lp_status_t::CONCURRENT_LIMIT; } @@ -237,21 +237,21 @@ lp_status_t solve_linear_program_with_advanced_basis( vstatus = phase1_vstatus; edge_norms.clear(); bool initialize_basis_update = true; - dual::status_t status = dual_phase2_with_advanced_basis(2, - iter == 0 ? 1 : 0, - initialize_basis_update, - start_time, - lp, - settings, - vstatus, - ft, - basic_list, - nonbasic_list, - solution, - iter, - edge_norms, - work_unit_context); - if (status == dual::status_t::NUMERICAL) { + dual_status_t status = dual_phase2_with_advanced_basis(2, + iter == 0 ? 1 : 0, + initialize_basis_update, + start_time, + lp, + settings, + vstatus, + ft, + basic_list, + nonbasic_list, + solution, + iter, + edge_norms, + work_unit_context); + if (status == dual_status_t::NUMERICAL) { // Became dual infeasible. Try phase 1 again phase1_vstatus = vstatus; settings.log.printf("Running Phase 1 again\n"); @@ -289,10 +289,10 @@ lp_status_t solve_linear_program_with_advanced_basis( work_unit_context); } constexpr bool primal_cleanup = false; - if (status == dual::status_t::OPTIMAL && primal_cleanup) { + if (status == dual_status_t::OPTIMAL && primal_cleanup) { primal_phase2(2, start_time, lp, settings, vstatus, solution, iter); } - if (status == dual::status_t::OPTIMAL) { + if (status == dual_status_t::OPTIMAL) { std::vector unscaled_x(lp.num_cols); std::vector unscaled_y(lp.num_rows); std::vector unscaled_z(lp.num_cols); @@ -319,16 +319,16 @@ lp_status_t solve_linear_program_with_advanced_basis( original_solution.l2_dual_residual = solution.l2_dual_residual; lp_status = lp_status_t::OPTIMAL; } - if (status == dual::status_t::DUAL_UNBOUNDED) { lp_status = lp_status_t::INFEASIBLE; } - if (status == dual::status_t::TIME_LIMIT) { lp_status = lp_status_t::TIME_LIMIT; } - if (status == dual::status_t::WORK_LIMIT) { lp_status = lp_status_t::WORK_LIMIT; } - if (status == dual::status_t::ITERATION_LIMIT) { lp_status = lp_status_t::ITERATION_LIMIT; } - if (status == dual::status_t::CONCURRENT_LIMIT) { + if (status == dual_status_t::DUAL_UNBOUNDED) { lp_status = lp_status_t::INFEASIBLE; } + if (status == dual_status_t::TIME_LIMIT) { lp_status = lp_status_t::TIME_LIMIT; } + if (status == dual_status_t::WORK_LIMIT) { lp_status = lp_status_t::WORK_LIMIT; } + if (status == dual_status_t::ITERATION_LIMIT) { lp_status = lp_status_t::ITERATION_LIMIT; } + if (status == dual_status_t::CONCURRENT_LIMIT) { original_solution.iterations = iter; return lp_status_t::CONCURRENT_LIMIT; } - if (status == dual::status_t::NUMERICAL) { lp_status = lp_status_t::NUMERICAL_ISSUES; } - if (status == dual::status_t::CUTOFF) { lp_status = lp_status_t::CUTOFF; } + if (status == dual_status_t::NUMERICAL) { lp_status = lp_status_t::NUMERICAL_ISSUES; } + if (status == dual_status_t::CUTOFF) { lp_status = lp_status_t::CUTOFF; } original_solution.iterations = iter; } else { // Dual infeasible -> Primal unbounded or infeasible @@ -361,7 +361,7 @@ lp_status_t solve_linear_program_with_barrier(const user_problem_t& us simplex_solver_settings_t barrier_settings = settings; dualize_info_t dualize_info; convert_user_problem(user_problem, barrier_settings, original_lp, new_slacks, dualize_info); - if (!validate_barrier_cone_layout(original_lp, barrier_settings)) { + if (!barrier::validate_barrier_cone_layout(original_lp, barrier_settings)) { return lp_status_t::NUMERICAL_ISSUES; } @@ -387,7 +387,7 @@ lp_status_t solve_linear_program_with_barrier(const user_problem_t& us // Solve using barrier lp_solution_t barrier_solution(barrier_lp.num_rows, barrier_lp.num_cols); - barrier_solver_t barrier_solver(barrier_lp, presolve_info, barrier_settings); + barrier::barrier_solver_t barrier_solver(barrier_lp, presolve_info, barrier_settings); lp_status_t barrier_status = barrier_solver.solve(start_time, barrier_solution); if (barrier_status == lp_status_t::OPTIMAL) { #ifdef COMPUTE_SCALED_RESIDUALS @@ -725,11 +725,11 @@ i_t solve(const user_problem_t& problem, { i_t status; if (is_mip(problem) && !settings.relaxation) { - probing_implied_bound_t empty_probing(problem.num_cols); - branch_and_bound_t branch_and_bound(problem, settings, tic(), empty_probing); + mip::probing_implied_bound_t empty_probing(problem.num_cols); + mip::branch_and_bound_t branch_and_bound(problem, settings, tic(), empty_probing); mip_solution_t mip_solution(problem.num_cols); - mip_status_t mip_status = branch_and_bound.solve(mip_solution); - if (mip_status == mip_status_t::OPTIMAL) { + mip::mip_status_t mip_status = branch_and_bound.solve(mip_solution); + if (mip_status == mip::mip_status_t::OPTIMAL) { status = 0; } else { status = -1; @@ -765,11 +765,11 @@ i_t solve_mip_with_guess(const user_problem_t& problem, { i_t status; if (is_mip(problem)) { - probing_implied_bound_t empty_probing(problem.num_cols); - branch_and_bound_t branch_and_bound(problem, settings, tic(), empty_probing); + mip::probing_implied_bound_t empty_probing(problem.num_cols); + mip::branch_and_bound_t branch_and_bound(problem, settings, tic(), empty_probing); branch_and_bound.set_initial_guess(guess); - mip_status_t mip_status = branch_and_bound.solve(solution); - if (mip_status == mip_status_t::OPTIMAL) { + mip::mip_status_t mip_status = branch_and_bound.solve(solution); + if (mip_status == mip::mip_status_t::OPTIMAL) { status = 0; } else { status = -1; @@ -846,4 +846,4 @@ template int solve_mip_with_guess( #endif -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/solve.hpp b/cpp/src/dual_simplex/solve.hpp index 84eb6faa02..60a6ead66b 100644 --- a/cpp/src/dual_simplex/solve.hpp +++ b/cpp/src/dual_simplex/solve.hpp @@ -17,7 +17,7 @@ namespace cuopt { struct work_limit_context_t; } -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::simplex { template bool is_mip(const user_problem_t& problem); @@ -123,4 +123,4 @@ i_t solve(const user_problem_t& user_problem, const simplex_solver_settings_t& settings, std::vector& primal_solution); -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/sparse_matrix.cpp b/cpp/src/dual_simplex/sparse_matrix.cpp index 63004be72b..4509b97fb1 100644 --- a/cpp/src/dual_simplex/sparse_matrix.cpp +++ b/cpp/src/dual_simplex/sparse_matrix.cpp @@ -25,7 +25,7 @@ #include #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::simplex { template void csc_matrix_t::reallocate(i_t new_nz) @@ -1006,4 +1006,4 @@ matrix_transpose_vector_multiply, std::alloc #endif -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/sparse_matrix.hpp b/cpp/src/dual_simplex/sparse_matrix.hpp index 09b580cad1..2aad545ec8 100644 --- a/cpp/src/dual_simplex/sparse_matrix.hpp +++ b/cpp/src/dual_simplex/sparse_matrix.hpp @@ -16,7 +16,7 @@ #include #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::simplex { template class csr_matrix_t; // Forward declaration of CSR matrix needed to define CSC @@ -56,7 +56,7 @@ class csc_matrix_t { // Convert the CSC matrix to a CSR matrix i_t to_compressed_row( - cuopt::linear_programming::dual_simplex::csr_matrix_t& Arow) const; + cuopt::mathematical_optimization::simplex::csr_matrix_t& Arow) const; // Permutes rows of a sparse matrix A. Computes C = A(p, :) i_t permute_rows(const std::vector& pinv, csc_matrix_t& C) const; @@ -312,4 +312,4 @@ i_t matrix_vector_multiply( return 0; } -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/sparse_vector.cpp b/cpp/src/dual_simplex/sparse_vector.cpp index 1f3798e7dd..08821ea719 100644 --- a/cpp/src/dual_simplex/sparse_vector.cpp +++ b/cpp/src/dual_simplex/sparse_vector.cpp @@ -11,7 +11,7 @@ #include #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::simplex { template sparse_vector_t::sparse_vector_t(const csc_matrix_t& A, i_t col) @@ -285,4 +285,4 @@ void sparse_vector_t::squeeze(sparse_vector_t& y) const template class sparse_vector_t; #endif -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/sparse_vector.hpp b/cpp/src/dual_simplex/sparse_vector.hpp index d9ca540d18..03d9d9f601 100644 --- a/cpp/src/dual_simplex/sparse_vector.hpp +++ b/cpp/src/dual_simplex/sparse_vector.hpp @@ -12,7 +12,7 @@ #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::simplex { // A sparse vector stored as a list of nonzero coefficients and their indices template @@ -71,4 +71,4 @@ class sparse_vector_t { std::vector x; }; -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/tic_toc.cpp b/cpp/src/dual_simplex/tic_toc.cpp index 98eb89bcb4..5c27c4bc65 100644 --- a/cpp/src/dual_simplex/tic_toc.cpp +++ b/cpp/src/dual_simplex/tic_toc.cpp @@ -1,6 +1,6 @@ /* clang-format off */ /* - * SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. * SPDX-License-Identifier: Apache-2.0 */ /* clang-format on */ @@ -9,7 +9,7 @@ #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::simplex { double tic() { @@ -24,4 +24,4 @@ double toc(double start) return (now - start); } -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/tic_toc.hpp b/cpp/src/dual_simplex/tic_toc.hpp index edaf325aea..23463d63ae 100644 --- a/cpp/src/dual_simplex/tic_toc.hpp +++ b/cpp/src/dual_simplex/tic_toc.hpp @@ -1,6 +1,6 @@ /* clang-format off */ /* - * SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. * SPDX-License-Identifier: Apache-2.0 */ /* clang-format on */ @@ -9,8 +9,8 @@ #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::simplex { double tic(); double toc(double start); -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/triangle_solve.cpp b/cpp/src/dual_simplex/triangle_solve.cpp index ad09ae30cf..505b39ca6e 100644 --- a/cpp/src/dual_simplex/triangle_solve.cpp +++ b/cpp/src/dual_simplex/triangle_solve.cpp @@ -9,7 +9,7 @@ #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::simplex { // NOTE: lower_triangular_solve, lower_triangular_transpose_solve, // upper_triangular_solve, and upper_triangular_transpose_solve are now @@ -186,4 +186,4 @@ template int sparse_triangle_solve(const sparse_vector_t -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::simplex { #define FLIP(i) (-(i) - 2) // flips an unsigned integer about -1 #define UNFLIP(i) (((i) < 0) ? FLIP(i) : (i)) @@ -171,4 +171,4 @@ i_t sparse_triangle_solve(const sparse_vector_t& b, f_t* x, f_t& work_estimate); -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/types.hpp b/cpp/src/dual_simplex/types.hpp index b4ff4b8cb3..df45c733c6 100644 --- a/cpp/src/dual_simplex/types.hpp +++ b/cpp/src/dual_simplex/types.hpp @@ -10,7 +10,7 @@ #include #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::simplex { #define DUAL_SIMPLEX_INSTANTIATE_DOUBLE @@ -26,4 +26,4 @@ constexpr float64_t inf = std::numeric_limits::infinity(); // We return this constant to signal that a matrix is indefinite (has a negative pivot) #define INDEFINITE_MATRIX_RETURN -4 -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/user_problem.hpp b/cpp/src/dual_simplex/user_problem.hpp index 548ec9e449..fe19b4d456 100644 --- a/cpp/src/dual_simplex/user_problem.hpp +++ b/cpp/src/dual_simplex/user_problem.hpp @@ -15,7 +15,7 @@ #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::simplex { enum class variable_type_t : int8_t { CONTINUOUS = 0, @@ -71,4 +71,4 @@ struct user_problem_t { std::vector original_col_to_expanded_col; }; -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/vector_math.cpp b/cpp/src/dual_simplex/vector_math.cpp index 0db09b00b6..fceeec3d97 100644 --- a/cpp/src/dual_simplex/vector_math.cpp +++ b/cpp/src/dual_simplex/vector_math.cpp @@ -15,7 +15,7 @@ #include #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::simplex { template f_t vector_norm2_squared(const std::vector& x) @@ -177,10 +177,10 @@ template double vector_norm2_squared>( template double vector_norm2>( const std::vector>& x); -template double vector_norm2_squared>( - const std::vector>&); -template double vector_norm2>( - const std::vector>&); +template double vector_norm2_squared>( + const std::vector>&); +template double vector_norm2>( + const std::vector>&); template double vector_norm1(const std::vector& x); @@ -211,4 +211,4 @@ template int inverse_permutation(const std::vector& p, std::vector #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::simplex { struct norm_inf_max { template @@ -90,4 +90,4 @@ f_t vector_norm_inf(raft::host_span x, rmm::cuda_stream_view stream_v return device_vector_norm_inf(d_x, stream_view); } -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/vector_math.hpp b/cpp/src/dual_simplex/vector_math.hpp index 478e024e51..a7e481c4b2 100644 --- a/cpp/src/dual_simplex/vector_math.hpp +++ b/cpp/src/dual_simplex/vector_math.hpp @@ -11,7 +11,7 @@ #include #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::simplex { // Computes || x ||_inf = max_j | x |_j template @@ -69,4 +69,4 @@ i_t inverse_permute_vector(const std::vector& p, template i_t inverse_permutation(const std::vector& p, std::vector& pinv); -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/grpc/client/grpc_client.cpp b/cpp/src/grpc/client/grpc_client.cpp index 060b76f79c..c3ee7c046d 100644 --- a/cpp/src/grpc/client/grpc_client.cpp +++ b/cpp/src/grpc/client/grpc_client.cpp @@ -5,8 +5,8 @@ #include "grpc_client.hpp" -#include -#include +#include +#include #include #include "grpc_problem_mapper.hpp" #include "grpc_service_mapper.hpp" @@ -28,7 +28,7 @@ #include #include -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { // ============================================================================= // Constants @@ -1255,4 +1255,4 @@ template bool grpc_client_t::upload_chunked_arrays( std::string& job_id_out); #endif -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/grpc/client/grpc_client.hpp b/cpp/src/grpc/client/grpc_client.hpp index 4c3aa0c3d3..fcee8f0f75 100644 --- a/cpp/src/grpc/client/grpc_client.hpp +++ b/cpp/src/grpc/client/grpc_client.hpp @@ -5,10 +5,10 @@ #pragma once -#include -#include -#include -#include +#include +#include +#include +#include #include "../cuopt_default_grpc_port.h" @@ -35,7 +35,7 @@ class ResultResponse; class SubmitJobRequest; } // namespace cuopt::remote -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { // Forward declarations for test helper functions (implemented in grpc_client.cpp) void grpc_test_inject_mock_stub(class grpc_client_t& client, std::shared_ptr stub); @@ -478,4 +478,4 @@ class grpc_client_t { std::string& job_id_out); }; -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/grpc/client/solve_remote.cpp b/cpp/src/grpc/client/solve_remote.cpp index fb39a6d184..9dec406f02 100644 --- a/cpp/src/grpc/client/solve_remote.cpp +++ b/cpp/src/grpc/client/solve_remote.cpp @@ -5,10 +5,10 @@ */ /* clang-format on */ -#include -#include -#include -#include +#include +#include +#include +#include #include #include "grpc_client.hpp" @@ -22,7 +22,7 @@ #include -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { // Buffer added to the solver's time_limit to account for worker startup, // GPU init, and result pipe transfer. @@ -286,4 +286,4 @@ template std::unique_ptr> solve_lp_remote( template std::unique_ptr> solve_mip_remote( cpu_optimization_problem_t const&, mip_solver_settings_t const&); -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/grpc/codegen/field_registry.yaml b/cpp/src/grpc/codegen/field_registry.yaml index 4880b41a6b..e2c26a797a 100644 --- a/cpp/src/grpc/codegen/field_registry.yaml +++ b/cpp/src/grpc/codegen/field_registry.yaml @@ -731,7 +731,7 @@ mip_settings: # MIP heuristic hyper-parameters (nested: settings.heuristic_params.) # Tuning knobs for MIP GPU heuristics; see mip_heuristics_hyper_params_t - # in cpp/include/cuopt/linear_programming/mip/heuristics_hyper_params.hpp. + # in cpp/include/cuopt/mathematical_optimization/mip/heuristics_hyper_params.hpp. # All fields carry non-zero defaults on the C++ side, so they are declared # `optional` in the proto: a client that omits any of them gets the C++ # default rather than the proto3 wire zero (0). diff --git a/cpp/src/grpc/grpc_chunk_key.hpp b/cpp/src/grpc/grpc_chunk_key.hpp index 35b788931f..6b526ad7ca 100644 --- a/cpp/src/grpc/grpc_chunk_key.hpp +++ b/cpp/src/grpc/grpc_chunk_key.hpp @@ -7,7 +7,7 @@ #include -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { // Composite key for chunks targeting arrays inside repeated nested messages // (e.g., a single QuadraticConstraint's linear_values). Top-level arrays @@ -37,4 +37,4 @@ struct container_array_key_t { } }; -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/grpc/grpc_problem_mapper.cpp b/cpp/src/grpc/grpc_problem_mapper.cpp index 170dfd7aed..e4f0d48b56 100644 --- a/cpp/src/grpc/grpc_problem_mapper.cpp +++ b/cpp/src/grpc/grpc_problem_mapper.cpp @@ -5,12 +5,12 @@ #include "grpc_problem_mapper.hpp" -#include +#include #include #include -#include -#include -#include +#include +#include +#include #include "grpc_settings_mapper.hpp" #include @@ -21,7 +21,7 @@ #include #include -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { namespace { #include "generated_enum_converters_problem.inc" @@ -272,4 +272,4 @@ template std::vector build_array_chunk_req int64_t chunk_size_bytes); #endif -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/grpc/grpc_problem_mapper.hpp b/cpp/src/grpc/grpc_problem_mapper.hpp index 81ff2e927a..ac895d9d21 100644 --- a/cpp/src/grpc/grpc_problem_mapper.hpp +++ b/cpp/src/grpc/grpc_problem_mapper.hpp @@ -20,7 +20,7 @@ namespace cuopt::remote { class ChunkedProblemHeader; } -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { // Forward declarations template @@ -136,4 +136,4 @@ std::vector build_array_chunk_requests( const std::string& upload_id, int64_t chunk_size_bytes); -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/grpc/grpc_service_mapper.cpp b/cpp/src/grpc/grpc_service_mapper.cpp index dd969c1587..0fac71d905 100644 --- a/cpp/src/grpc/grpc_service_mapper.cpp +++ b/cpp/src/grpc/grpc_service_mapper.cpp @@ -5,15 +5,15 @@ #include "grpc_service_mapper.hpp" -#include +#include #include #include -#include -#include +#include +#include #include "grpc_problem_mapper.hpp" #include "grpc_settings_mapper.hpp" -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { template cuopt::remote::SubmitJobRequest build_lp_submit_request( @@ -88,4 +88,4 @@ template cuopt::remote::SubmitJobRequest build_mip_submit_request( bool enable_incumbents); #endif -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/grpc/grpc_service_mapper.hpp b/cpp/src/grpc/grpc_service_mapper.hpp index ed438a0551..20124db5cb 100644 --- a/cpp/src/grpc/grpc_service_mapper.hpp +++ b/cpp/src/grpc/grpc_service_mapper.hpp @@ -10,7 +10,7 @@ #include -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { // Forward declarations template @@ -105,4 +105,4 @@ inline cuopt::remote::DeleteRequest build_delete_request(const std::string& job_ return request; } -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/grpc/grpc_settings_mapper.cpp b/cpp/src/grpc/grpc_settings_mapper.cpp index ffa98e7693..58bcedf3b2 100644 --- a/cpp/src/grpc/grpc_settings_mapper.cpp +++ b/cpp/src/grpc/grpc_settings_mapper.cpp @@ -5,17 +5,17 @@ #include "grpc_settings_mapper.hpp" -#include +#include #include -#include -#include -#include +#include +#include +#include #include #include #include -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { namespace { #include "generated_enum_converters_settings.inc" @@ -113,4 +113,4 @@ template void map_proto_to_mip_settings(const cuopt::remote::MIPSolverSettings& mip_solver_settings_t& settings); #endif -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/grpc/grpc_settings_mapper.hpp b/cpp/src/grpc/grpc_settings_mapper.hpp index 6daf0d052b..926c89cbeb 100644 --- a/cpp/src/grpc/grpc_settings_mapper.hpp +++ b/cpp/src/grpc/grpc_settings_mapper.hpp @@ -9,7 +9,7 @@ #include -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { // Forward declarations template @@ -58,4 +58,4 @@ template void map_proto_to_mip_settings(const cuopt::remote::MIPSolverSettings& pb_settings, mip_solver_settings_t& settings); -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/grpc/grpc_solution_mapper.cpp b/cpp/src/grpc/grpc_solution_mapper.cpp index 5f32af212d..042ad2c4de 100644 --- a/cpp/src/grpc/grpc_solution_mapper.cpp +++ b/cpp/src/grpc/grpc_solution_mapper.cpp @@ -5,19 +5,19 @@ #include "grpc_solution_mapper.hpp" -#include +#include #include #include -#include -#include -#include +#include +#include +#include #include #include #include #include -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { namespace { #include "generated_enum_converters_solution.inc" @@ -258,4 +258,4 @@ template void build_mip_solution_proto( cuopt::remote::MIPSolution* proto); #endif -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/grpc/grpc_solution_mapper.hpp b/cpp/src/grpc/grpc_solution_mapper.hpp index f2b6621f29..6a9ffb9ae8 100644 --- a/cpp/src/grpc/grpc_solution_mapper.hpp +++ b/cpp/src/grpc/grpc_solution_mapper.hpp @@ -8,16 +8,16 @@ #include #include -#include -#include -#include +#include +#include +#include #include #include #include #include -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { /** * @brief Map cpu_lp_solution_t to protobuf LPSolution message. @@ -140,4 +140,4 @@ void build_mip_solution_proto(const cuopt::remote::ChunkedResultHeader& header, const std::map>& arrays, cuopt::remote::MIPSolution* proto); -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/grpc/server/grpc_pipe_serialization.hpp b/cpp/src/grpc/server/grpc_pipe_serialization.hpp index 8ad878d6cb..f9e7cf3e0f 100644 --- a/cpp/src/grpc/server/grpc_pipe_serialization.hpp +++ b/cpp/src/grpc/server/grpc_pipe_serialization.hpp @@ -229,12 +229,13 @@ inline PipeWriteStatus write_chunked_request_to_pipe( { // -------- Phase 1: bin chunks per field and validate (no pipe I/O) -------- std::map top_fields; - std::map container_fields; + std::map + container_fields; for (const auto& ac : chunks) { int64_t elem_size = 0; detail::FieldChunks* fi = nullptr; if (ac.has_container_field_num()) { - cuopt::linear_programming::container_array_key_t key{ + cuopt::mathematical_optimization::container_array_key_t key{ ac.container_field_num(), ac.container_index(), ac.field_id()}; fi = &container_fields[key]; elem_size = array_field_element_size(key.container_field_num, key.field_id); @@ -340,7 +341,7 @@ inline bool read_chunked_request_from_pipe( int fd, cuopt::remote::ChunkedProblemHeader& header_out, std::map>& arrays_out, - std::map>& + std::map>& container_arrays_out) { // dest.resize(total_bytes) can throw std::bad_alloc if the wire claims an @@ -386,8 +387,8 @@ inline bool read_chunked_request_from_pipe( if (!read_from_pipe(fd, &field_id, sizeof(field_id))) return false; if (!read_from_pipe(fd, &total_bytes, sizeof(total_bytes))) return false; if (total_bytes > kMaxPipeArrayBytes) return false; - auto& dest = - container_arrays_out[cuopt::linear_programming::container_array_key_t{cfn, ci, field_id}]; + auto& dest = container_arrays_out[cuopt::mathematical_optimization::container_array_key_t{ + cfn, ci, field_id}]; dest.resize(static_cast(total_bytes)); if (total_bytes > 0 && !read_from_pipe(fd, dest.data(), static_cast(total_bytes))) return false; diff --git a/cpp/src/grpc/server/grpc_server_types.hpp b/cpp/src/grpc/server/grpc_server_types.hpp index 92f37b1973..e199848a72 100644 --- a/cpp/src/grpc/server/grpc_server_types.hpp +++ b/cpp/src/grpc/server/grpc_server_types.hpp @@ -13,10 +13,10 @@ #include "cuopt_remote.pb.h" #include "cuopt_remote_service.grpc.pb.h" -#include -#include -#include -#include +#include +#include +#include +#include #include "grpc_problem_mapper.hpp" #include "grpc_server_logger.hpp" #include "grpc_settings_mapper.hpp" @@ -60,8 +60,9 @@ using grpc::ServerWriter; using grpc::Status; using grpc::StatusCode; -using namespace cuopt::linear_programming; -// Note: NOT using "using namespace cuopt::remote" to avoid JobStatus enum conflict +// Note: cuopt::mathematical_optimization names are fully qualified below to avoid leaking +// a header-scope using-namespace directive, and to avoid a JobStatus enum conflict +// with cuopt::remote. // ============================================================================= // Shared Memory Structures (must match between main process and workers) @@ -216,7 +217,7 @@ struct ChunkedUploadState { // Top-level and container fields stay in separate maps so a top-level // field_id and a container-relative field_id can coexist without // colliding on the int32_t key. - std::map container_field_meta; + std::map container_field_meta; std::vector chunks; int64_t total_chunks = 0; int64_t total_bytes = 0; diff --git a/cpp/src/grpc/server/grpc_service_impl.cpp b/cpp/src/grpc/server/grpc_service_impl.cpp index de428d3f39..83dbec3d19 100644 --- a/cpp/src/grpc/server/grpc_service_impl.cpp +++ b/cpp/src/grpc/server/grpc_service_impl.cpp @@ -164,7 +164,7 @@ class CuOptRemoteServiceImpl final : public cuopt::remote::CuOptRemoteService::S // container-relative field_id can coexist without colliding. ChunkedUploadState::FieldMeta* meta_ptr = nullptr; if (is_container) { - cuopt::linear_programming::container_array_key_t key{ + cuopt::mathematical_optimization::container_array_key_t key{ cfn_for_size, ac.container_index(), field_id}; meta_ptr = &state.container_field_meta[key]; } else { @@ -359,12 +359,12 @@ class CuOptRemoteServiceImpl final : public cuopt::remote::CuOptRemoteService::S // back from the worker pipe by the result retrieval thread. if (it->second.problem_category == cuopt::remote::MIP) { cuopt::remote::MIPSolution mip_solution; - build_mip_solution_proto( + cuopt::mathematical_optimization::build_mip_solution_proto( it->second.result_header, it->second.result_arrays, &mip_solution); response->mutable_mip_solution()->Swap(&mip_solution); } else { cuopt::remote::LPSolution lp_solution; - build_lp_solution_proto( + cuopt::mathematical_optimization::build_lp_solution_proto( it->second.result_header, it->second.result_arrays, &lp_solution); response->mutable_lp_solution()->Swap(&lp_solution); } diff --git a/cpp/src/grpc/server/grpc_worker.cpp b/cpp/src/grpc/server/grpc_worker.cpp index 5f21112056..3c5cfd3295 100644 --- a/cpp/src/grpc/server/grpc_worker.cpp +++ b/cpp/src/grpc/server/grpc_worker.cpp @@ -17,6 +17,10 @@ #include #include +using cuopt::mathematical_optimization::map_proto_to_mip_settings; +using cuopt::mathematical_optimization::map_proto_to_pdlp_settings; +using cuopt::mathematical_optimization::map_proto_to_problem; + namespace { int parse_pool_gigs_env() @@ -84,9 +88,9 @@ bool init_worker_cuda_environment(int worker_id) // --------------------------------------------------------------------------- struct DeserializedJob { - cpu_optimization_problem_t problem; - pdlp_solver_settings_t lp_settings; - mip_solver_settings_t mip_settings; + cuopt::mathematical_optimization::cpu_optimization_problem_t problem; + cuopt::mathematical_optimization::pdlp_solver_settings_t lp_settings; + cuopt::mathematical_optimization::mip_solver_settings_t mip_settings; bool enable_incumbents = true; bool success = false; }; @@ -288,7 +292,7 @@ static DeserializedJob read_problem_from_pipe(int worker_id, const JobQueueEntry // This avoids a single giant protobuf allocation for large problems. cuopt::remote::ChunkedProblemHeader chunked_header; std::map> arrays; - std::map> + std::map> container_arrays; if (!read_chunked_request_from_pipe(read_fd, chunked_header, arrays, container_arrays)) { return dj; @@ -319,7 +323,8 @@ static DeserializedJob read_problem_from_pipe(int worker_id, const JobQueueEntry map_proto_to_mip_settings(chunked_header.mip_settings(), dj.mip_settings); } dj.enable_incumbents = chunked_header.enable_incumbents(); - map_chunked_arrays_to_problem(chunked_header, arrays, container_arrays, dj.problem); + cuopt::mathematical_optimization::map_chunked_arrays_to_problem( + chunked_header, arrays, container_arrays, dj.problem); } else { // Unary path: the entire SubmitJobRequest was serialized as a single // protobuf blob. Simpler but copies more memory for large problems. @@ -386,7 +391,7 @@ static SolveResult run_mip_solve(DeserializedJob& dj, auto gpu_problem = dj.problem.to_optimization_problem(&handle); SERVER_LOG_INFO("[Worker] Calling solve_mip..."); - auto gpu_solution = solve_mip(*gpu_problem, dj.mip_settings); + auto gpu_solution = cuopt::mathematical_optimization::solve_mip(*gpu_problem, dj.mip_settings); SERVER_LOG_INFO("[Worker] solve_mip done"); // solve_mip_helper catches cuopt::logic_error internally and stashes it @@ -405,21 +410,22 @@ static SolveResult run_mip_solve(DeserializedJob& dj, auto host_solution = device_to_host(gpu_solution.get_solution()); - cpu_mip_solution_t cpu_solution(std::move(host_solution), - gpu_solution.get_termination_status(), - gpu_solution.get_objective_value(), - gpu_solution.get_mip_gap(), - gpu_solution.get_solution_bound(), - gpu_solution.get_total_solve_time(), - gpu_solution.get_presolve_time(), - gpu_solution.get_max_constraint_violation(), - gpu_solution.get_max_int_violation(), - gpu_solution.get_max_variable_bound_violation(), - gpu_solution.get_num_nodes(), - gpu_solution.get_num_simplex_iterations()); - - populate_chunked_result_header_mip(cpu_solution, &sr.header); - sr.arrays = collect_mip_solution_arrays(cpu_solution); + cuopt::mathematical_optimization::cpu_mip_solution_t cpu_solution( + std::move(host_solution), + gpu_solution.get_termination_status(), + gpu_solution.get_objective_value(), + gpu_solution.get_mip_gap(), + gpu_solution.get_solution_bound(), + gpu_solution.get_total_solve_time(), + gpu_solution.get_presolve_time(), + gpu_solution.get_max_constraint_violation(), + gpu_solution.get_max_int_violation(), + gpu_solution.get_max_variable_bound_violation(), + gpu_solution.get_num_nodes(), + gpu_solution.get_num_simplex_iterations()); + + cuopt::mathematical_optimization::populate_chunked_result_header_mip(cpu_solution, &sr.header); + sr.arrays = cuopt::mathematical_optimization::collect_mip_solution_arrays(cpu_solution); SERVER_LOG_INFO("[Worker] Result path: MIP solution -> %zu array(s)", sr.arrays.size()); sr.success = true; } catch (const cuopt::logic_error& e) { @@ -446,7 +452,7 @@ static SolveResult run_lp_solve(DeserializedJob& dj, auto gpu_problem = dj.problem.to_optimization_problem(&handle); SERVER_LOG_INFO("[Worker] Calling solve_lp..."); - auto gpu_solution = solve_lp(*gpu_problem, dj.lp_settings); + auto gpu_solution = cuopt::mathematical_optimization::solve_lp(*gpu_problem, dj.lp_settings); SERVER_LOG_INFO("[Worker] solve_lp done"); // solve_lp / solve_qcqp catch cuopt::logic_error internally and stash it @@ -473,25 +479,26 @@ static SolveResult run_lp_solve(DeserializedJob& dj, // Warm-start data lets clients resume an interrupted LP solve from // where it left off without starting over. - auto cpu_ws = - convert_to_cpu_warmstart(gpu_solution.get_pdlp_warm_start_data(), handle.get_stream()); - - cpu_lp_solution_t cpu_solution(std::move(host_primal), - std::move(host_dual), - std::move(host_reduced_cost), - gpu_solution.get_termination_status(), - gpu_solution.get_objective_value(), - gpu_solution.get_dual_objective_value(), - term_info.solve_time, - term_info.l2_primal_residual, - term_info.l2_dual_residual, - term_info.gap, - term_info.number_of_steps_taken, - term_info.solved_by, - std::move(cpu_ws)); - - populate_chunked_result_header_lp(cpu_solution, &sr.header); - sr.arrays = collect_lp_solution_arrays(cpu_solution); + auto cpu_ws = cuopt::mathematical_optimization::convert_to_cpu_warmstart( + gpu_solution.get_pdlp_warm_start_data(), handle.get_stream()); + + cuopt::mathematical_optimization::cpu_lp_solution_t cpu_solution( + std::move(host_primal), + std::move(host_dual), + std::move(host_reduced_cost), + gpu_solution.get_termination_status(), + gpu_solution.get_objective_value(), + gpu_solution.get_dual_objective_value(), + term_info.solve_time, + term_info.l2_primal_residual, + term_info.l2_dual_residual, + term_info.gap, + term_info.number_of_steps_taken, + term_info.solved_by, + std::move(cpu_ws)); + + cuopt::mathematical_optimization::populate_chunked_result_header_lp(cpu_solution, &sr.header); + sr.arrays = cuopt::mathematical_optimization::collect_lp_solution_arrays(cpu_solution); SERVER_LOG_INFO("[Worker] Result path: LP solution -> %zu array(s)", sr.arrays.size()); sr.success = true; } catch (const cuopt::logic_error& e) { diff --git a/cpp/src/io/data_model_view.cpp b/cpp/src/io/data_model_view.cpp index e23f715f2b..132d87b866 100644 --- a/cpp/src/io/data_model_view.cpp +++ b/cpp/src/io/data_model_view.cpp @@ -5,12 +5,12 @@ */ /* clang-format on */ -#include +#include #include #include -namespace cuopt::linear_programming::io { +namespace cuopt::mathematical_optimization::io { template void data_model_view_t::set_maximize(bool maximize) @@ -381,4 +381,4 @@ template class data_model_view_t; template class data_model_view_t; -} // namespace cuopt::linear_programming::io +} // namespace cuopt::mathematical_optimization::io diff --git a/cpp/src/io/file_to_string.cpp b/cpp/src/io/file_to_string.cpp index 77b92d90e9..9c935485e6 100644 --- a/cpp/src/io/file_to_string.cpp +++ b/cpp/src/io/file_to_string.cpp @@ -27,9 +27,9 @@ #endif // MPS_PARSER_WITH_BZIP2 || MPS_PARSER_WITH_ZLIB namespace { -using cuopt::linear_programming::io::error_type_t; -using cuopt::linear_programming::io::mps_parser_expects; -using cuopt::linear_programming::io::mps_parser_expects_fatal; +using cuopt::mathematical_optimization::io::error_type_t; +using cuopt::mathematical_optimization::io::mps_parser_expects; +using cuopt::mathematical_optimization::io::mps_parser_expects_fatal; struct FcloseDeleter { void operator()(FILE* fp) @@ -207,7 +207,7 @@ std::vector zlib_file_to_string(const std::string& file) } // end namespace #endif // MPS_PARSER_WITH_ZLIB -namespace cuopt::linear_programming::io::detail { +namespace cuopt::mathematical_optimization::io { std::vector file_to_string(const std::string& file) { @@ -252,4 +252,4 @@ std::vector file_to_string(const std::string& file) return buf; } -} // namespace cuopt::linear_programming::io::detail +} // namespace cuopt::mathematical_optimization::io diff --git a/cpp/src/io/file_to_string.hpp b/cpp/src/io/file_to_string.hpp index 94b2df821d..da36961d2b 100644 --- a/cpp/src/io/file_to_string.hpp +++ b/cpp/src/io/file_to_string.hpp @@ -10,7 +10,7 @@ #include #include -namespace cuopt::linear_programming::io::detail { +namespace cuopt::mathematical_optimization::io { // Reads `file` into a buffer and appends a trailing '\0'. // @@ -21,4 +21,4 @@ namespace cuopt::linear_programming::io::detail { // The returned buffer's size includes the null terminator. std::vector file_to_string(const std::string& file); -} // namespace cuopt::linear_programming::io::detail +} // namespace cuopt::mathematical_optimization::io diff --git a/cpp/src/io/lp_parser.cpp b/cpp/src/io/lp_parser.cpp index c72b1c7c82..d449b93273 100644 --- a/cpp/src/io/lp_parser.cpp +++ b/cpp/src/io/lp_parser.cpp @@ -5,7 +5,7 @@ */ /* clang-format on */ -#include +#include #include #include @@ -25,7 +25,7 @@ #include #include -namespace cuopt::linear_programming::io { +namespace cuopt::mathematical_optimization::io { namespace { @@ -314,7 +314,7 @@ void LpParseEngine::read_and_tokenize(const std::string& file) // way as .mps.gz / .mps.bz2 (dlopen-loaded libz / libbz2). The returned // buffer is null-terminated; strip it before constructing the string view // since `tokenize` walks the entire string range. - auto buf = detail::file_to_string(file); + auto buf = file_to_string(file); std::string text(buf.data(), buf.size() > 0 ? buf.size() - 1 : 0); tokenize(text); } @@ -1576,4 +1576,4 @@ template mps_data_model_t read_lp(const std::string&); template mps_data_model_t read_lp_from_string(std::string_view); template mps_data_model_t read_lp_from_string(std::string_view); -} // namespace cuopt::linear_programming::io +} // namespace cuopt::mathematical_optimization::io diff --git a/cpp/src/io/lp_parser.hpp b/cpp/src/io/lp_parser.hpp index 83f61785be..836ecd56ce 100644 --- a/cpp/src/io/lp_parser.hpp +++ b/cpp/src/io/lp_parser.hpp @@ -7,14 +7,14 @@ #pragma once -#include +#include #include #include #include #include -namespace cuopt::linear_programming::io { +namespace cuopt::mathematical_optimization::io { /** * @brief Parser for the LP format. @@ -81,4 +81,4 @@ class lp_parser_t { std::vector quadratic_constraint_blocks{}; }; -} // namespace cuopt::linear_programming::io +} // namespace cuopt::mathematical_optimization::io diff --git a/cpp/src/io/mps_data_model.cpp b/cpp/src/io/mps_data_model.cpp index 991c8d42a1..e6dbf7c140 100644 --- a/cpp/src/io/mps_data_model.cpp +++ b/cpp/src/io/mps_data_model.cpp @@ -5,14 +5,14 @@ */ /* clang-format on */ -#include +#include #include #include #include #include -namespace cuopt::linear_programming::io { +namespace cuopt::mathematical_optimization::io { template void mps_data_model_t::set_csr_constraint_matrix(std::span A_values, @@ -480,4 +480,4 @@ template class mps_data_model_t; // TODO current raft to cusparse wrappers only support int64_t // can be CUSPARSE_INDEX_16U, CUSPARSE_INDEX_32I, CUSPARSE_INDEX_64I -} // namespace cuopt::linear_programming::io +} // namespace cuopt::mathematical_optimization::io diff --git a/cpp/src/io/mps_parser.cpp b/cpp/src/io/mps_parser.cpp index 5f7cecda94..7d3a52ee48 100644 --- a/cpp/src/io/mps_parser.cpp +++ b/cpp/src/io/mps_parser.cpp @@ -23,10 +23,10 @@ #include namespace { -using cuopt::linear_programming::io::coo_entries_t; -using cuopt::linear_programming::io::error_type_t; -using cuopt::linear_programming::io::mps_parser_expects; -using cuopt::linear_programming::io::mps_parser_expects_fatal; +using cuopt::mathematical_optimization::io::coo_entries_t; +using cuopt::mathematical_optimization::io::error_type_t; +using cuopt::mathematical_optimization::io::mps_parser_expects; +using cuopt::mathematical_optimization::io::mps_parser_expects_fatal; std::vector string_to_buffer(std::string_view input) { @@ -156,7 +156,7 @@ void triples_to_csr_flat(const coo_entries_t& entries, } // namespace -namespace cuopt::linear_programming::io { +namespace cuopt::mathematical_optimization::io { template std::string_view get_next_string(std::string_view line, i_t& pos, i_t& end) @@ -758,7 +758,7 @@ mps_parser_t::mps_parser_t(mps_data_model_t& problem, { // raft::common::nvtx::range fun_scope("mps parser"); - std::vector buf = detail::file_to_string(file); + std::vector buf = file_to_string(file); parse_string(buf.data()); fill_problem(problem); } @@ -1538,4 +1538,4 @@ template class mps_parser_t; template class mps_parser_t; -} // namespace cuopt::linear_programming::io +} // namespace cuopt::mathematical_optimization::io diff --git a/cpp/src/io/mps_parser_internal.hpp b/cpp/src/io/mps_parser_internal.hpp index d510bd4f57..de9e66e07a 100644 --- a/cpp/src/io/mps_parser_internal.hpp +++ b/cpp/src/io/mps_parser_internal.hpp @@ -7,7 +7,7 @@ #pragma once -#include +#include #include #include @@ -16,7 +16,7 @@ #include #include -namespace cuopt::linear_programming::io { +namespace cuopt::mathematical_optimization::io { /** * Sparse COO (coordinate) entries for a matrix: parallel row/col/val vectors. @@ -221,4 +221,4 @@ class mps_parser_t { }; // class mps_parser_t -} // namespace cuopt::linear_programming::io +} // namespace cuopt::mathematical_optimization::io diff --git a/cpp/src/io/mps_writer.cpp b/cpp/src/io/mps_writer.cpp index 9db528ca5b..4168b2b074 100644 --- a/cpp/src/io/mps_writer.cpp +++ b/cpp/src/io/mps_writer.cpp @@ -5,10 +5,10 @@ */ /* clang-format on */ -#include +#include -#include -#include +#include +#include #include #include @@ -21,7 +21,7 @@ #include #include -namespace cuopt::linear_programming::io { +namespace cuopt::mathematical_optimization::io { namespace { @@ -523,4 +523,4 @@ void mps_writer_t::write(const std::string& mps_file_path) template class mps_writer_t; template class mps_writer_t; -} // namespace cuopt::linear_programming::io +} // namespace cuopt::mathematical_optimization::io diff --git a/cpp/src/io/parser.cpp b/cpp/src/io/parser.cpp index 93d9d9c73c..20e80185b3 100644 --- a/cpp/src/io/parser.cpp +++ b/cpp/src/io/parser.cpp @@ -5,11 +5,11 @@ */ /* clang-format on */ -#include +#include #include -namespace cuopt::linear_programming::io { +namespace cuopt::mathematical_optimization::io { template mps_data_model_t read_mps(const std::string& mps_file, bool fixed_mps_format) @@ -35,4 +35,4 @@ template mps_data_model_t read_mps_from_string(std::string_view mps_ template mps_data_model_t read_mps_from_string(std::string_view mps_contents, bool fixed_mps_format); -} // namespace cuopt::linear_programming::io +} // namespace cuopt::mathematical_optimization::io diff --git a/cpp/src/io/utilities/cython_parser.cpp b/cpp/src/io/utilities/cython_parser.cpp index 4de1de9b6f..6caff48f59 100644 --- a/cpp/src/io/utilities/cython_parser.cpp +++ b/cpp/src/io/utilities/cython_parser.cpp @@ -5,24 +5,26 @@ */ /* clang-format on */ -#include -#include +#include +#include namespace cuopt { namespace cython { -std::unique_ptr> call_read( +std::unique_ptr> call_read( const std::string& file_path, bool fixed_mps_format) { - return std::make_unique>( - std::move(cuopt::linear_programming::io::read(file_path, fixed_mps_format))); + return std::make_unique>( + std::move( + cuopt::mathematical_optimization::io::read(file_path, fixed_mps_format))); } -std::unique_ptr> call_parse_mps( +std::unique_ptr> call_parse_mps( const std::string& mps_file_path, bool fixed_mps_format) { - return std::make_unique>(std::move( - cuopt::linear_programming::io::read_mps(mps_file_path, fixed_mps_format))); + return std::make_unique>( + std::move(cuopt::mathematical_optimization::io::read_mps(mps_file_path, + fixed_mps_format))); } } // namespace cython diff --git a/cpp/src/io/utilities/error.hpp b/cpp/src/io/utilities/error.hpp index 58ac3891e1..a0d1813856 100644 --- a/cpp/src/io/utilities/error.hpp +++ b/cpp/src/io/utilities/error.hpp @@ -11,7 +11,7 @@ #include #include -namespace cuopt::linear_programming::io { +namespace cuopt::mathematical_optimization::io { /** * @brief Indicates different type of exceptions which mps parser might throw @@ -116,4 +116,4 @@ inline void mps_parser_expects_fatal(bool cond, error_type_t error_type, const c } \ } while (0) -} // namespace cuopt::linear_programming::io +} // namespace cuopt::mathematical_optimization::io diff --git a/cpp/src/io/writer.cpp b/cpp/src/io/writer.cpp index 45ffc4c263..c67a1aac4b 100644 --- a/cpp/src/io/writer.cpp +++ b/cpp/src/io/writer.cpp @@ -5,11 +5,11 @@ */ /* clang-format on */ -#include +#include -#include +#include -namespace cuopt::linear_programming::io { +namespace cuopt::mathematical_optimization::io { template void write_mps(const data_model_view_t& problem, const std::string& mps_file_path) @@ -23,4 +23,4 @@ template void write_mps(const data_model_view_t& problem template void write_mps(const data_model_view_t& problem, const std::string& mps_file_path); -} // namespace cuopt::linear_programming::io +} // namespace cuopt::mathematical_optimization::io diff --git a/cpp/src/math_optimization/solution_reader.cu b/cpp/src/math_optimization/solution_reader.cu index f4a008d00e..cbc3389ae4 100644 --- a/cpp/src/math_optimization/solution_reader.cu +++ b/cpp/src/math_optimization/solution_reader.cu @@ -1,6 +1,6 @@ /* clang-format off */ /* - * SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. * SPDX-License-Identifier: Apache-2.0 */ /* clang-format on */ @@ -16,7 +16,7 @@ #include #include -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { /** * @brief Represents information about a solution including variables, objective value, and status @@ -135,4 +135,4 @@ std::vector solution_reader_t::get_variable_values_from_sol_file( return values; } -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/math_optimization/solution_reader.hpp b/cpp/src/math_optimization/solution_reader.hpp index 54eb468f6c..dd0976028a 100644 --- a/cpp/src/math_optimization/solution_reader.hpp +++ b/cpp/src/math_optimization/solution_reader.hpp @@ -1,6 +1,6 @@ /* clang-format off */ /* - * SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. * SPDX-License-Identifier: Apache-2.0 */ /* clang-format on */ @@ -10,7 +10,7 @@ #include #include -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { /** * @brief Reads a solution file and returns the values of specified variables @@ -24,4 +24,4 @@ class solution_reader_t { static std::vector get_variable_values_from_sol_file( const std::string& sol_file_path, const std::vector& variable_names); }; -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/math_optimization/solution_writer.cu b/cpp/src/math_optimization/solution_writer.cu index 880127546d..c22fb46da3 100644 --- a/cpp/src/math_optimization/solution_writer.cu +++ b/cpp/src/math_optimization/solution_writer.cu @@ -13,7 +13,7 @@ #include -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { template void solution_writer_t::write_solution_to_sol_file(const std::string& filename, @@ -60,4 +60,4 @@ template void solution_writer_t::write_solution_to_sol_file( const std::vector& variable_values); #endif -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/math_optimization/solution_writer.hpp b/cpp/src/math_optimization/solution_writer.hpp index 0ac1b64464..ab82c1e5a3 100644 --- a/cpp/src/math_optimization/solution_writer.hpp +++ b/cpp/src/math_optimization/solution_writer.hpp @@ -10,7 +10,7 @@ #include #include -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { /** * @brief Writes a solution to a .sol file @@ -30,4 +30,4 @@ class solution_writer_t { const std::vector& variable_names, const std::vector& variable_values); }; -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/math_optimization/solver_settings.cu b/cpp/src/math_optimization/solver_settings.cu index 4a000c6e05..611881ebd0 100644 --- a/cpp/src/math_optimization/solver_settings.cu +++ b/cpp/src/math_optimization/solver_settings.cu @@ -6,7 +6,7 @@ /* clang-format on */ #include -#include +#include #include #include @@ -16,7 +16,7 @@ #include #include -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { namespace { @@ -672,4 +672,4 @@ template bool solver_settings_t::get_parameter(const std::string& n template std::string solver_settings_t::get_parameter(const std::string& name) const; #endif -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/mip_heuristics/diversity/assignment_hash_map.cu b/cpp/src/mip_heuristics/diversity/assignment_hash_map.cu index 0cddcf1d26..c9d20c97fe 100644 --- a/cpp/src/mip_heuristics/diversity/assignment_hash_map.cu +++ b/cpp/src/mip_heuristics/diversity/assignment_hash_map.cu @@ -15,8 +15,8 @@ #include namespace cuopt { -namespace linear_programming { -namespace detail { +namespace mathematical_optimization { +namespace mip { struct combine_hash { DI size_t operator()(size_t hash_1, size_t hash_2) @@ -157,6 +157,6 @@ template class assignment_hash_map_t; template class assignment_hash_map_t; #endif -} // namespace detail -} // namespace linear_programming +} // namespace mip +} // namespace mathematical_optimization } // namespace cuopt diff --git a/cpp/src/mip_heuristics/diversity/assignment_hash_map.cuh b/cpp/src/mip_heuristics/diversity/assignment_hash_map.cuh index 3b87b2a5fd..50a002b2e3 100644 --- a/cpp/src/mip_heuristics/diversity/assignment_hash_map.cuh +++ b/cpp/src/mip_heuristics/diversity/assignment_hash_map.cuh @@ -10,8 +10,8 @@ #include namespace cuopt { -namespace linear_programming { -namespace detail { +namespace mathematical_optimization { +namespace mip { template class assignment_hash_map_t { @@ -30,6 +30,6 @@ class assignment_hash_map_t { rmm::device_buffer temp_storage; }; -} // namespace detail -} // namespace linear_programming +} // namespace mip +} // namespace mathematical_optimization } // namespace cuopt diff --git a/cpp/src/mip_heuristics/diversity/diversity_config.hpp b/cpp/src/mip_heuristics/diversity/diversity_config.hpp index dacf7773de..ec6998c464 100644 --- a/cpp/src/mip_heuristics/diversity/diversity_config.hpp +++ b/cpp/src/mip_heuristics/diversity/diversity_config.hpp @@ -9,7 +9,7 @@ #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { struct diversity_config_t { double time_ratio_of_probing_cache = 0.1; @@ -28,4 +28,4 @@ struct diversity_config_t { bool halve_population = false; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/diversity/diversity_manager.cu b/cpp/src/mip_heuristics/diversity/diversity_manager.cu index b88099d8ae..e90c96d8e4 100644 --- a/cpp/src/mip_heuristics/diversity/diversity_manager.cu +++ b/cpp/src/mip_heuristics/diversity/diversity_manager.cu @@ -23,7 +23,7 @@ constexpr bool fj_only_run = false; -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { size_t fp_recombiner_config_t::max_n_of_vars_from_other = fp_recombiner_config_t::initial_n_of_vars_from_other; @@ -262,7 +262,7 @@ bool diversity_manager_t::run_presolve(f_t time_limit, timer_t global_ // !problem_ptr->empty) { // f_t time_limit_for_clique_table = std::min(3., presolve_timer.remaining_time() / 5); // timer_t clique_timer(time_limit_for_clique_table); - // dual_simplex::user_problem_t host_problem(problem_ptr->handle_ptr); + // simplex::user_problem_t host_problem(problem_ptr->handle_ptr); // problem_ptr->get_host_user_problem(host_problem); // std::shared_ptr> clique_table; // constexpr bool modify_problem_with_cliques = false; @@ -966,4 +966,4 @@ template class diversity_manager_t; template class diversity_manager_t; #endif -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/diversity/diversity_manager.cuh b/cpp/src/mip_heuristics/diversity/diversity_manager.cuh index 863933de48..51cb7e6c44 100644 --- a/cpp/src/mip_heuristics/diversity/diversity_manager.cuh +++ b/cpp/src/mip_heuristics/diversity/diversity_manager.cuh @@ -18,8 +18,8 @@ #include "recombiners/recombiner_stats.hpp" #include "recombiners/sub_mip.cuh" -#include -#include +#include +#include #include #include @@ -29,7 +29,7 @@ #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template class diversity_manager_t { @@ -73,7 +73,7 @@ class diversity_manager_t { const std::vector& dual_solution, f_t objective); mip_solver_context_t& context; - dual_simplex::branch_and_bound_t* branch_and_bound_ptr; + mip::branch_and_bound_t* branch_and_bound_ptr; problem_t* problem_ptr; diversity_config_t diversity_config; population_t population; @@ -110,4 +110,4 @@ class diversity_manager_t { bool run_only_sub_mip_recombiner{false}; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/diversity/lns/rins.cu b/cpp/src/mip_heuristics/diversity/lns/rins.cu index e1318edf4d..a670322cb0 100644 --- a/cpp/src/mip_heuristics/diversity/lns/rins.cu +++ b/cpp/src/mip_heuristics/diversity/lns/rins.cu @@ -26,7 +26,7 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template rins_t::rins_t(mip_solver_context_t& context_, diversity_manager_t& dm_, @@ -234,11 +234,11 @@ void rins_t::run_rins() f_t current_mip_gap = compute_rel_mip_gap(prev_obj, lower_bound); // run sub-mip - namespace dual_simplex = cuopt::linear_programming::dual_simplex; - dual_simplex::user_problem_t branch_and_bound_problem(&rins_handle); - dual_simplex::simplex_solver_settings_t branch_and_bound_settings; - dual_simplex::mip_solution_t branch_and_bound_solution(1); - dual_simplex::mip_status_t branch_and_bound_status = dual_simplex::mip_status_t::UNSET; + namespace simplex = cuopt::mathematical_optimization::simplex; + simplex::user_problem_t branch_and_bound_problem(&rins_handle); + simplex::simplex_solver_settings_t branch_and_bound_settings; + simplex::mip_solution_t branch_and_bound_solution(1); + mip::mip_status_t branch_and_bound_status = mip::mip_status_t::UNSET; fixed_problem.get_host_user_problem(branch_and_bound_problem); branch_and_bound_solution.resize(branch_and_bound_problem.num_cols); // Fill in the settings for branch and bound @@ -262,9 +262,9 @@ void rins_t::run_rins() f_t objective) { rins_solution_queue.push_back(solution); }; - dual_simplex::probing_implied_bound_t empty_probing(branch_and_bound_problem.num_cols); - dual_simplex::branch_and_bound_t branch_and_bound( - branch_and_bound_problem, branch_and_bound_settings, dual_simplex::tic(), empty_probing); + mip::probing_implied_bound_t empty_probing(branch_and_bound_problem.num_cols); + mip::branch_and_bound_t branch_and_bound( + branch_and_bound_problem, branch_and_bound_settings, simplex::tic(), empty_probing); branch_and_bound.set_initial_guess(cuopt::host_copy(fixed_assignment, rins_handle.get_stream())); branch_and_bound_status = branch_and_bound.solve(branch_and_bound_solution); @@ -275,18 +275,18 @@ void rins_t::run_rins() // RINS submip may have just proved the initial guess is the optimal, therefore the queue might // be empty in that case } - if (branch_and_bound_status == dual_simplex::mip_status_t::OPTIMAL) { + if (branch_and_bound_status == mip::mip_status_t::OPTIMAL) { CUOPT_LOG_DEBUG("RINS submip optimal"); // do goldilocks update fixrate = std::max(fixrate - f_t(0.05), static_cast(settings.min_fixrate)); time_limit = std::max(time_limit - f_t(2), static_cast(settings.min_time_limit)); - } else if (branch_and_bound_status == dual_simplex::mip_status_t::TIME_LIMIT) { + } else if (branch_and_bound_status == mip::mip_status_t::TIME_LIMIT) { CUOPT_LOG_DEBUG("RINS submip time limit"); // do goldilocks update fixrate = std::min(fixrate + f_t(0.05), static_cast(settings.max_fixrate)); time_limit = std::min(time_limit + f_t(2), static_cast(context.settings.heuristic_params.rins_max_time_limit)); - } else if (branch_and_bound_status == dual_simplex::mip_status_t::INFEASIBLE) { + } else if (branch_and_bound_status == mip::mip_status_t::INFEASIBLE) { CUOPT_LOG_DEBUG("RINS submip infeasible"); // do goldilocks update, decreasing fixrate fixrate = std::max(fixrate - f_t(0.05), static_cast(settings.min_fixrate)); @@ -351,4 +351,4 @@ template class rins_t; template class rins_t; #endif -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/diversity/lns/rins.cuh b/cpp/src/mip_heuristics/diversity/lns/rins.cuh index b1b62bd1ae..6257afb179 100644 --- a/cpp/src/mip_heuristics/diversity/lns/rins.cuh +++ b/cpp/src/mip_heuristics/diversity/lns/rins.cuh @@ -24,7 +24,7 @@ #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { // forward declare template @@ -84,4 +84,4 @@ class rins_t { omp_atomic_t launch_new_task{true}; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/diversity/multi_armed_bandit.cu b/cpp/src/mip_heuristics/diversity/multi_armed_bandit.cu index f5fc88cbc1..4445395f1f 100644 --- a/cpp/src/mip_heuristics/diversity/multi_armed_bandit.cu +++ b/cpp/src/mip_heuristics/diversity/multi_armed_bandit.cu @@ -12,7 +12,7 @@ #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { mab_t::mab_t(int n_arms, int seed, double alpha, std::string bandit_name) : mab_arm_stats_(n_arms), mab_rng_(seed), bandit_name(bandit_name), mab_alpha_(alpha) @@ -190,4 +190,4 @@ template void mab_t::add_mab_reward( int, double, double, double, recombiner_work_normalized_reward_t); #endif -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/diversity/multi_armed_bandit.cuh b/cpp/src/mip_heuristics/diversity/multi_armed_bandit.cuh index 4571d0d57f..c5c7142539 100644 --- a/cpp/src/mip_heuristics/diversity/multi_armed_bandit.cuh +++ b/cpp/src/mip_heuristics/diversity/multi_armed_bandit.cuh @@ -13,7 +13,7 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { constexpr double recombiner_alpha = 0.05; constexpr double ls_alpha = 0.03; @@ -90,4 +90,4 @@ struct mab_t { int last_chosen_option = -1; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/diversity/population.cu b/cpp/src/mip_heuristics/diversity/population.cu index a870f654de..b9412a5250 100644 --- a/cpp/src/mip_heuristics/diversity/population.cu +++ b/cpp/src/mip_heuristics/diversity/population.cu @@ -18,7 +18,7 @@ #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { constexpr double weight_increase_ratio = 2.; constexpr double weight_decrease_ratio = 0.9; @@ -280,11 +280,11 @@ void population_t::invoke_get_solution_callback( temp_sol.assignment.size(), temp_sol.handle_ptr->get_stream()); temp_sol.handle_ptr->sync_stream(); - if (detail::mip_solver_settings_accessor::has_semi_continuous_callback_translation( + if (mip_solver_settings_accessor::has_semi_continuous_callback_translation( context.settings)) { - detail::strip_semi_continuous_auxiliaries_from_assignment( + mip::strip_semi_continuous_auxiliaries_from_assignment( user_assignment_vec, - detail::mip_solver_settings_accessor::get_semi_continuous_original_num_variables( + mip_solver_settings_accessor::get_semi_continuous_original_num_variables( context.settings)); } callback->get_solution(user_assignment_vec.data(), @@ -323,11 +323,12 @@ void population_t::run_solution_callbacks(solution_t& sol) f_t user_bound = context.stats.get_solution_bound(); auto callback_num_variables = problem_ptr->original_problem_ptr->get_n_variables(); const bool has_semi_continuous_callback_translation = - detail::mip_solver_settings_accessor::has_semi_continuous_callback_translation( + mip_solver_settings_accessor::has_semi_continuous_callback_translation( context.settings); if (has_semi_continuous_callback_translation) { - callback_num_variables = detail::mip_solver_settings_accessor:: - get_semi_continuous_original_num_variables(context.settings); + callback_num_variables = + mip_solver_settings_accessor::get_semi_continuous_original_num_variables( + context.settings); } rmm::device_uvector incumbent_assignment(callback_num_variables, sol.handle_ptr->get_stream()); @@ -349,10 +350,10 @@ void population_t::run_solution_callbacks(solution_t& sol) if (outside_sol_objective == inf) { return; } d_outside_sol_objective.set_value_async(outside_sol_objective, sol.handle_ptr->get_stream()); if (has_semi_continuous_callback_translation) { - detail::append_semi_continuous_auxiliaries_to_assignment( + mip::append_semi_continuous_auxiliaries_to_assignment( h_incumbent_assignment, - detail::mip_solver_settings_accessor:: - get_semi_continuous_binary_to_original_indices(context.settings), + mip_solver_settings_accessor::get_semi_continuous_binary_to_original_indices( + context.settings), context.settings.get_tolerances()); } incumbent_assignment.resize(h_incumbent_assignment.size(), sol.handle_ptr->get_stream()); @@ -514,7 +515,7 @@ void population_t::normalize_weights() CUOPT_LOG_DEBUG("Normalizing weights"); rmm::device_scalar l2_norm(problem_ptr->handle_ptr->get_stream()); - my_l2_norm(weights.cstr_weights, l2_norm, problem_ptr->handle_ptr); + pdlp::my_l2_norm(weights.cstr_weights, l2_norm, problem_ptr->handle_ptr); thrust::transform( problem_ptr->handle_ptr->get_thrust_policy(), weights.cstr_weights.begin(), @@ -558,7 +559,7 @@ void population_t::compute_new_weights() auto settings = context.settings; rmm::device_scalar l2_norm(problem_ptr->handle_ptr->get_stream()); - my_l2_norm(weights.cstr_weights, l2_norm, problem_ptr->handle_ptr); + pdlp::my_l2_norm(weights.cstr_weights, l2_norm, problem_ptr->handle_ptr); if (!best_sol.get_feasible()) { CUOPT_LOG_DEBUG("Increasing weights!"); @@ -901,4 +902,4 @@ template class population_t; template class population_t; #endif -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/diversity/population.cuh b/cpp/src/mip_heuristics/diversity/population.cuh index c83a4bfb83..81521b95e9 100644 --- a/cpp/src/mip_heuristics/diversity/population.cuh +++ b/cpp/src/mip_heuristics/diversity/population.cuh @@ -19,7 +19,7 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { // forward declare template @@ -214,4 +214,4 @@ class population_t { cuopt::timer_t timer; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/diversity/recombiners/bound_prop_recombiner.cuh b/cpp/src/mip_heuristics/diversity/recombiners/bound_prop_recombiner.cuh index 9d6bb3902c..42fd838105 100644 --- a/cpp/src/mip_heuristics/diversity/recombiners/bound_prop_recombiner.cuh +++ b/cpp/src/mip_heuristics/diversity/recombiners/bound_prop_recombiner.cuh @@ -15,7 +15,7 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template class bound_prop_recombiner_t : public recombiner_t { @@ -248,4 +248,4 @@ class bound_prop_recombiner_t : public recombiner_t { thrust::default_random_engine rng; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/diversity/recombiners/fp_recombiner.cuh b/cpp/src/mip_heuristics/diversity/recombiners/fp_recombiner.cuh index 1cca1ba371..85909c9d69 100644 --- a/cpp/src/mip_heuristics/diversity/recombiners/fp_recombiner.cuh +++ b/cpp/src/mip_heuristics/diversity/recombiners/fp_recombiner.cuh @@ -17,7 +17,7 @@ #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template class fp_recombiner_t : public recombiner_t { @@ -143,4 +143,4 @@ class fp_recombiner_t : public recombiner_t { feasibility_pump_t fp; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/diversity/recombiners/line_segment_recombiner.cuh b/cpp/src/mip_heuristics/diversity/recombiners/line_segment_recombiner.cuh index d413af86cd..a1e6e29c56 100644 --- a/cpp/src/mip_heuristics/diversity/recombiners/line_segment_recombiner.cuh +++ b/cpp/src/mip_heuristics/diversity/recombiners/line_segment_recombiner.cuh @@ -14,7 +14,7 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template class line_segment_recombiner_t : public recombiner_t { @@ -125,4 +125,4 @@ class line_segment_recombiner_t : public recombiner_t { line_segment_search_t& line_segment_search; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/diversity/recombiners/recombiner.cuh b/cpp/src/mip_heuristics/diversity/recombiners/recombiner.cuh index 4782e9612b..0e9c64e796 100644 --- a/cpp/src/mip_heuristics/diversity/recombiners/recombiner.cuh +++ b/cpp/src/mip_heuristics/diversity/recombiners/recombiner.cuh @@ -24,7 +24,7 @@ #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { // checks whether the values of a variable are equal when we consider them in a diversity // measurement context @@ -224,4 +224,4 @@ class recombiner_t { static std::vector enabled_recombiners; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/diversity/recombiners/recombiner_configs.hpp b/cpp/src/mip_heuristics/diversity/recombiners/recombiner_configs.hpp index 04d3332947..5abe9f5141 100644 --- a/cpp/src/mip_heuristics/diversity/recombiners/recombiner_configs.hpp +++ b/cpp/src/mip_heuristics/diversity/recombiners/recombiner_configs.hpp @@ -1,13 +1,13 @@ /* clang-format off */ /* - * SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. * SPDX-License-Identifier: Apache-2.0 */ /* clang-format on */ #pragma once -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { struct bp_recombiner_config_t { static constexpr double bounds_prop_time_limit = 2.; @@ -125,4 +125,4 @@ struct sub_mip_recombiner_config_t { } }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/diversity/recombiners/recombiner_stats.hpp b/cpp/src/mip_heuristics/diversity/recombiners/recombiner_stats.hpp index 044e313284..d01801e0ca 100644 --- a/cpp/src/mip_heuristics/diversity/recombiners/recombiner_stats.hpp +++ b/cpp/src/mip_heuristics/diversity/recombiners/recombiner_stats.hpp @@ -9,7 +9,7 @@ #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { enum class recombiner_enum_t : int { BOUND_PROP = 0, FP, LINE_SEGMENT, SUB_MIP, SIZE }; @@ -126,4 +126,4 @@ struct all_recombine_stats { } }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/diversity/recombiners/sub_mip.cuh b/cpp/src/mip_heuristics/diversity/recombiners/sub_mip.cuh index 1d0b9245d7..0f3625d9aa 100644 --- a/cpp/src/mip_heuristics/diversity/recombiners/sub_mip.cuh +++ b/cpp/src/mip_heuristics/diversity/recombiners/sub_mip.cuh @@ -7,7 +7,7 @@ #pragma once -#include "cuopt/linear_programming/mip/solver_settings.hpp" +#include "cuopt/mathematical_optimization/mip/solver_settings.hpp" #include "recombiner.cuh" #include @@ -16,7 +16,7 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template class sub_mip_recombiner_t : public recombiner_t { @@ -73,7 +73,7 @@ class sub_mip_recombiner_t : public recombiner_t { this->compute_vars_to_fix(offspring, vars_to_fix, n_vars_from_other, n_vars_from_guiding); auto [fixed_problem, fixed_assignment, variable_map] = offspring.fix_variables(vars_to_fix); // TODO ask Akif and Alice if this is ok - pdlp_initial_scaling_strategy_t scaling( + pdlp::pdlp_initial_scaling_strategy_t scaling( fixed_problem.handle_ptr, fixed_problem, context.settings.hyper_params.default_l_inf_ruiz_iterations, @@ -91,14 +91,14 @@ class sub_mip_recombiner_t : public recombiner_t { trivial_presolve(fixed_problem); fixed_problem.check_problem_representation(true); // brute force rounding threshold is 8 - const bool run_sub_mip = fixed_problem.n_integer_vars > 8; - dual_simplex::mip_status_t branch_and_bound_status = dual_simplex::mip_status_t::UNSET; - dual_simplex::mip_solution_t branch_and_bound_solution(1); + const bool run_sub_mip = fixed_problem.n_integer_vars > 8; + mip::mip_status_t branch_and_bound_status = mip::mip_status_t::UNSET; + simplex::mip_solution_t branch_and_bound_solution(1); if (run_sub_mip) { // run sub-mip - namespace dual_simplex = cuopt::linear_programming::dual_simplex; - dual_simplex::user_problem_t branch_and_bound_problem(offspring.handle_ptr); - dual_simplex::simplex_solver_settings_t branch_and_bound_settings; + namespace simplex = cuopt::mathematical_optimization::simplex; + simplex::user_problem_t branch_and_bound_problem(offspring.handle_ptr); + simplex::simplex_solver_settings_t branch_and_bound_settings; fixed_problem.get_host_user_problem(branch_and_bound_problem); branch_and_bound_solution.resize(branch_and_bound_problem.num_cols); // Fill in the settings for branch and bound @@ -120,10 +120,9 @@ class sub_mip_recombiner_t : public recombiner_t { // disable B&B logs, so that it is not interfering with the main B&B thread branch_and_bound_settings.log.log = false; - dual_simplex::probing_implied_bound_t empty_probing( - branch_and_bound_problem.num_cols); - dual_simplex::branch_and_bound_t branch_and_bound( - branch_and_bound_problem, branch_and_bound_settings, dual_simplex::tic(), empty_probing); + mip::probing_implied_bound_t empty_probing(branch_and_bound_problem.num_cols); + mip::branch_and_bound_t branch_and_bound( + branch_and_bound_problem, branch_and_bound_settings, simplex::tic(), empty_probing); branch_and_bound_status = branch_and_bound.solve(branch_and_bound_solution); if (solution_vector.size() > 0) { cuopt_assert(fixed_assignment.size() == branch_and_bound_solution.x.size(), @@ -162,7 +161,7 @@ class sub_mip_recombiner_t : public recombiner_t { // bool same_as_parents = this->check_if_offspring_is_same_as_parents(offspring, a, b); // adjust the max_n_of_vars_from_other if (n_different_vars > (i_t)sub_mip_recombiner_config_t::max_n_of_vars_from_other) { - if (branch_and_bound_status == dual_simplex::mip_status_t::OPTIMAL) { + if (branch_and_bound_status == mip::mip_status_t::OPTIMAL) { sub_mip_recombiner_config_t::increase_max_n_of_vars_from_other(); } else { sub_mip_recombiner_config_t::decrease_max_n_of_vars_from_other(); @@ -206,4 +205,4 @@ class sub_mip_recombiner_t : public recombiner_t { population_t& population; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/diversity/weights.cuh b/cpp/src/mip_heuristics/diversity/weights.cuh index 7502ae9210..f0c5facb6a 100644 --- a/cpp/src/mip_heuristics/diversity/weights.cuh +++ b/cpp/src/mip_heuristics/diversity/weights.cuh @@ -1,6 +1,6 @@ /* clang-format off */ /* - * SPDX-FileCopyrightText: Copyright (c) 2024-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-FileCopyrightText: Copyright (c) 2024-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. * SPDX-License-Identifier: Apache-2.0 */ /* clang-format on */ @@ -12,7 +12,7 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template struct weight_t { @@ -29,4 +29,4 @@ struct weight_t { rmm::device_scalar objective_weight; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/early_heuristic.cuh b/cpp/src/mip_heuristics/early_heuristic.cuh index 090cfd4901..6654470732 100644 --- a/cpp/src/mip_heuristics/early_heuristic.cuh +++ b/cpp/src/mip_heuristics/early_heuristic.cuh @@ -10,7 +10,7 @@ #include #include -#include +#include #include @@ -21,7 +21,7 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template using early_incumbent_callback_t = std::function #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template struct fj_cpu_climber_t; @@ -37,10 +37,10 @@ struct fj_cpu_task_t { // seed_generator::get_seed() racing with concurrent callers breaks reproducibility. template std::unique_ptr> make_fj_cpu_task_from_host_lp( - const dual_simplex::lp_problem_t& problem, - const std::vector& variable_types, + const simplex::lp_problem_t& problem, + const std::vector& variable_types, const std::vector& seed_assignment, - const dual_simplex::simplex_solver_settings_t& settings, + const simplex::simplex_solver_settings_t& settings, std::function&, double)> improvement_callback, std::string log_prefix, int64_t seed = -1); @@ -53,4 +53,4 @@ void run_fj_cpu_task(fj_cpu_task_t& task, template void stop_fj_cpu_task(fj_cpu_task_t& task); -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/feasibility_jump/early_cpufj.cu b/cpp/src/mip_heuristics/feasibility_jump/early_cpufj.cu index 46ffde6089..ba14e657d5 100644 --- a/cpp/src/mip_heuristics/feasibility_jump/early_cpufj.cu +++ b/cpp/src/mip_heuristics/feasibility_jump/early_cpufj.cu @@ -9,7 +9,7 @@ #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template early_cpufj_t::early_cpufj_t( @@ -75,4 +75,4 @@ template class early_cpufj_t; template class early_cpufj_t; #endif -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/feasibility_jump/early_cpufj.cuh b/cpp/src/mip_heuristics/feasibility_jump/early_cpufj.cuh index fd85e4b9f3..e2bb2c07b2 100644 --- a/cpp/src/mip_heuristics/feasibility_jump/early_cpufj.cuh +++ b/cpp/src/mip_heuristics/feasibility_jump/early_cpufj.cuh @@ -13,7 +13,7 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template class early_cpufj_t : public early_heuristic_t> { @@ -34,4 +34,4 @@ class early_cpufj_t : public early_heuristic_t std::atomic preemption_flag_{false}; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/feasibility_jump/early_gpufj.cu b/cpp/src/mip_heuristics/feasibility_jump/early_gpufj.cu index eac901151b..697f26e6df 100644 --- a/cpp/src/mip_heuristics/feasibility_jump/early_gpufj.cu +++ b/cpp/src/mip_heuristics/feasibility_jump/early_gpufj.cu @@ -16,7 +16,7 @@ #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template early_gpufj_t::early_gpufj_t(const optimization_problem_t& op_problem, @@ -89,4 +89,4 @@ template class early_gpufj_t; template class early_gpufj_t; #endif -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/feasibility_jump/early_gpufj.cuh b/cpp/src/mip_heuristics/feasibility_jump/early_gpufj.cuh index e5ceaaeb61..99e8579d31 100644 --- a/cpp/src/mip_heuristics/feasibility_jump/early_gpufj.cuh +++ b/cpp/src/mip_heuristics/feasibility_jump/early_gpufj.cuh @@ -11,7 +11,7 @@ #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template class fj_t; @@ -38,4 +38,4 @@ class early_gpufj_t : public early_heuristic_t std::unique_ptr> fj_ptr_; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/feasibility_jump/feasibility_jump.cu b/cpp/src/mip_heuristics/feasibility_jump/feasibility_jump.cu index 21e2bf0783..a6665e57e1 100644 --- a/cpp/src/mip_heuristics/feasibility_jump/feasibility_jump.cu +++ b/cpp/src/mip_heuristics/feasibility_jump/feasibility_jump.cu @@ -33,7 +33,7 @@ #define FJ_LOG_PREFIX "FJ: " -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { #if FJ_SINGLE_STEP static constexpr int iterations_per_graph = 1; @@ -1156,4 +1156,4 @@ template class fj_t; template class fj_t; #endif -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/feasibility_jump/feasibility_jump.cuh b/cpp/src/mip_heuristics/feasibility_jump/feasibility_jump.cuh index 4cc411abf9..8d1f39ce22 100644 --- a/cpp/src/mip_heuristics/feasibility_jump/feasibility_jump.cuh +++ b/cpp/src/mip_heuristics/feasibility_jump/feasibility_jump.cuh @@ -9,7 +9,7 @@ #include "utils.cuh" -#include +#include #include #include #include @@ -25,7 +25,7 @@ #define FJ_DEBUG_LOAD_BALANCING 0 #define FJ_SINGLE_STEP 0 -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template using fj_improvement_callback_t = @@ -641,4 +641,4 @@ class fj_t { f_t last_reported_objective_{std::numeric_limits::infinity()}; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/feasibility_jump/feasibility_jump_impl_common.cuh b/cpp/src/mip_heuristics/feasibility_jump/feasibility_jump_impl_common.cuh index e57f0ec9e2..98267f117c 100644 --- a/cpp/src/mip_heuristics/feasibility_jump/feasibility_jump_impl_common.cuh +++ b/cpp/src/mip_heuristics/feasibility_jump/feasibility_jump_impl_common.cuh @@ -7,7 +7,7 @@ #include "feasibility_jump.cuh" -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template HDI f_t fj_kahan_babushka_neumaier_sum(Iterator begin, Iterator end) @@ -228,4 +228,4 @@ HDI f_t get_breakthrough_move(typename fj_t::climber_data_t::view_t fj return new_val; } -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/feasibility_jump/feasibility_jump_kernels.cu b/cpp/src/mip_heuristics/feasibility_jump/feasibility_jump_kernels.cu index acff55a097..0efc93b760 100644 --- a/cpp/src/mip_heuristics/feasibility_jump/feasibility_jump_kernels.cu +++ b/cpp/src/mip_heuristics/feasibility_jump/feasibility_jump_kernels.cu @@ -25,7 +25,7 @@ namespace cg = cooperative_groups; #define CONSTRAINT_FLAG_INSERT 0 #define CONSTRAINT_FLAG_REMOVE 1 -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template DI thrust::pair move_objective_score( @@ -1449,7 +1449,8 @@ template std::pair get_launch_dims_update_assignment_kernel(int TPB, const raft::handle_t* handle_ptr) { - return get_launch_dims_max_occupancy((void*)update_assignment_kernel, TPB, handle_ptr); + return cuopt::get_launch_dims_max_occupancy( + (void*)update_assignment_kernel, TPB, handle_ptr); } template @@ -1466,7 +1467,7 @@ template std::pair get_launch_dims_compute_mtm_moves_kernel(int TPB, const raft::handle_t* handle_ptr) { - return get_launch_dims_max_occupancy( + return cuopt::get_launch_dims_max_occupancy( (void*)compute_mtm_moves_kernel, TPB, handle_ptr); } @@ -1474,7 +1475,7 @@ template std::pair get_launch_dims_handle_local_minimum_kernel(int TPB, const raft::handle_t* handle_ptr) { - return get_launch_dims_max_occupancy( + return cuopt::get_launch_dims_max_occupancy( (void*)handle_local_minimum_kernel, TPB, handle_ptr); } @@ -1482,14 +1483,15 @@ template std::pair get_launch_dims_update_lift_moves_kernel(int TPB, const raft::handle_t* handle_ptr) { - return get_launch_dims_max_occupancy((void*)update_lift_moves_kernel, TPB, handle_ptr); + return cuopt::get_launch_dims_max_occupancy( + (void*)update_lift_moves_kernel, TPB, handle_ptr); } template std::pair get_launch_dims_load_balancing_compute_workid_mappings( int TPB, const raft::handle_t* handle_ptr) { - return get_launch_dims_max_occupancy( + return cuopt::get_launch_dims_max_occupancy( (void*)load_balancing_compute_workid_mappings, TPB, handle_ptr); } @@ -1497,7 +1499,7 @@ template std::pair get_launch_dims_load_balancing_compute_scores_binary( int TPB, const raft::handle_t* handle_ptr) { - return get_launch_dims_max_occupancy( + return cuopt::get_launch_dims_max_occupancy( (void*)load_balancing_compute_scores_binary, TPB, handle_ptr); } @@ -1505,7 +1507,7 @@ template std::pair get_launch_dims_load_balancing_mtm_compute_candidates( int TPB, const raft::handle_t* handle_ptr) { - return get_launch_dims_max_occupancy( + return cuopt::get_launch_dims_max_occupancy( (void*)load_balancing_mtm_compute_candidates, TPB, handle_ptr); } @@ -1513,7 +1515,7 @@ template std::pair get_launch_dims_load_balancing_mtm_compute_scores( int TPB, const raft::handle_t* handle_ptr) { - return get_launch_dims_max_occupancy( + return cuopt::get_launch_dims_max_occupancy( (void*)load_balancing_mtm_compute_scores, TPB, handle_ptr); } @@ -1521,7 +1523,7 @@ template std::pair get_launch_dims_load_balancing_prepare_iteration( int TPB, const raft::handle_t* handle_ptr) { - return get_launch_dims_max_occupancy( + return cuopt::get_launch_dims_max_occupancy( (void*)load_balancing_prepare_iteration, TPB, handle_ptr); } @@ -1564,7 +1566,7 @@ template std::pair get_launch_dims_update_changed_constraints_kernel( int TPB, const raft::handle_t* handle_ptr) { - return get_launch_dims_max_occupancy( + return cuopt::get_launch_dims_max_occupancy( (void*)update_changed_constraints_kernel, TPB, handle_ptr); } @@ -1803,4 +1805,4 @@ CUOPT_INSTANTIATE(double) #undef CUOPT_INSTANTIATE -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/feasibility_jump/feasibility_jump_kernels.cuh b/cpp/src/mip_heuristics/feasibility_jump/feasibility_jump_kernels.cuh index 535e3c3171..3bc4b2ebaa 100644 --- a/cpp/src/mip_heuristics/feasibility_jump/feasibility_jump_kernels.cuh +++ b/cpp/src/mip_heuristics/feasibility_jump/feasibility_jump_kernels.cuh @@ -16,7 +16,7 @@ #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { enum class weight_strategy_t { Increment, Multiply }; @@ -234,4 +234,4 @@ void launch_load_balancing_mtm_compute_scores(dim3 grid, void** kernel_args, rmm::cuda_stream_view stream); -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/feasibility_jump/fj_cpu.cu b/cpp/src/mip_heuristics/feasibility_jump/fj_cpu.cu index a537426457..04a312766c 100644 --- a/cpp/src/mip_heuristics/feasibility_jump/fj_cpu.cu +++ b/cpp/src/mip_heuristics/feasibility_jump/fj_cpu.cu @@ -46,7 +46,11 @@ #define CPUFJ_NVTX_RANGE(name) ((void)0) #endif -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { + +using simplex::lp_problem_t; +using simplex::simplex_solver_settings_t; +using simplex::variable_type_t; template void finalize_fj_cpu_host_initialization( @@ -1416,10 +1420,10 @@ void finalize_fj_cpu_host_initialization( template static std::unique_ptr> init_fj_cpu_from_host_lp( - const dual_simplex::lp_problem_t& problem, - const std::vector& variable_types, + const lp_problem_t& problem, + const std::vector& variable_types, const std::vector& seed_assignment, - const dual_simplex::simplex_solver_settings_t& settings, + const simplex_solver_settings_t& settings, std::atomic& preemption_flag, int64_t seed) { @@ -1438,7 +1442,7 @@ static std::unique_ptr> init_fj_cpu_from_host_lp( const i_t n_variables = problem.num_cols; const i_t n_constraints = problem.num_rows; - dual_simplex::csr_matrix_t csr_A(problem.num_rows, problem.num_cols, problem.A.nnz()); + simplex::csr_matrix_t csr_A(problem.num_rows, problem.num_cols, problem.A.nnz()); problem.A.to_compressed_row(csr_A); std::vector coefficients = csr_A.x; std::vector variables = csr_A.j; @@ -1454,7 +1458,7 @@ static std::unique_ptr> init_fj_cpu_from_host_lp( variable_bounds[j] = f_t2{problem.lower[j], problem.upper[j]}; const auto var_type = variable_types[j]; cpufj_variable_types[j] = - var_type == dual_simplex::variable_type_t::CONTINUOUS ? var_t::CONTINUOUS : var_t::INTEGER; + var_type == variable_type_t::CONTINUOUS ? var_t::CONTINUOUS : var_t::INTEGER; const bool is_integer = cpufj_variable_types[j] == var_t::INTEGER; const bool is_binary = is_integer && @@ -1465,7 +1469,7 @@ static std::unique_ptr> init_fj_cpu_from_host_lp( } const i_t nnz = static_cast(variables.size()); - dual_simplex::csc_matrix_t reverse_csc(n_constraints, n_variables, nnz); + simplex::csc_matrix_t reverse_csc(n_constraints, n_variables, nnz); csr_A.to_compressed_col(reverse_csc); std::vector reverse_coefficients = std::move(reverse_csc.x); std::vector reverse_constraints = std::move(reverse_csc.i); @@ -1475,7 +1479,7 @@ static std::unique_ptr> init_fj_cpu_from_host_lp( for (i_t j = 0; j < n_variables; ++j) { f_t value = j < static_cast(seed_assignment.size()) ? seed_assignment[j] : f_t{0}; value = std::clamp(value, problem.lower[j], problem.upper[j]); - if (variable_types[j] != dual_simplex::variable_type_t::CONTINUOUS) { + if (variable_types[j] != variable_type_t::CONTINUOUS) { value = std::clamp(std::round(value), problem.lower[j], problem.upper[j]); } projected_seed[j] = value; @@ -1795,10 +1799,10 @@ void fj_cpu_task_t::fj_cpu_deleter_t::operator()(fj_cpu_climber_t std::unique_ptr> make_fj_cpu_task_from_host_lp( - const dual_simplex::lp_problem_t& problem, - const std::vector& variable_types, + const lp_problem_t& problem, + const std::vector& variable_types, const std::vector& seed_assignment, - const dual_simplex::simplex_solver_settings_t& settings, + const simplex_solver_settings_t& settings, std::function&, double)> improvement_callback, std::string log_prefix, int64_t seed) @@ -1841,10 +1845,10 @@ template std::unique_ptr> init_fj_cpu_standalone( std::atomic& preemption_flag, fj_settings_t settings); template std::unique_ptr> make_fj_cpu_task_from_host_lp( - const dual_simplex::lp_problem_t& problem, - const std::vector& variable_types, + const lp_problem_t& problem, + const std::vector& variable_types, const std::vector& seed_assignment, - const dual_simplex::simplex_solver_settings_t& settings, + const simplex_solver_settings_t& settings, std::function&, double)> improvement_callback, std::string log_prefix, int64_t seed); @@ -1873,10 +1877,10 @@ template std::unique_ptr> init_fj_cpu_standalone( std::atomic& preemption_flag, fj_settings_t settings); template std::unique_ptr> make_fj_cpu_task_from_host_lp( - const dual_simplex::lp_problem_t& problem, - const std::vector& variable_types, + const lp_problem_t& problem, + const std::vector& variable_types, const std::vector& seed_assignment, - const dual_simplex::simplex_solver_settings_t& settings, + const simplex_solver_settings_t& settings, std::function&, double)> improvement_callback, std::string log_prefix, int64_t seed); @@ -1893,4 +1897,4 @@ template void finalize_fj_cpu_host_initialization( const typename mip_solver_settings_t::tolerances_t& tolerances); #endif -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/feasibility_jump/fj_cpu.cuh b/cpp/src/mip_heuristics/feasibility_jump/fj_cpu.cuh index cdf3a2f58a..dd2512a77e 100644 --- a/cpp/src/mip_heuristics/feasibility_jump/fj_cpu.cuh +++ b/cpp/src/mip_heuristics/feasibility_jump/fj_cpu.cuh @@ -18,7 +18,7 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { // NOTE: this seems an easy pick for reflection/xmacros once this is available (C++26?) // Maintaining a single source of truth for all members would be nice @@ -204,4 +204,4 @@ std::unique_ptr> init_fj_cpu_standalone( std::atomic& preemption_flag, fj_settings_t settings = fj_settings_t{}); -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/feasibility_jump/utils.cuh b/cpp/src/mip_heuristics/feasibility_jump/utils.cuh index d98686bcc6..a24e4b6a7f 100644 --- a/cpp/src/mip_heuristics/feasibility_jump/utils.cuh +++ b/cpp/src/mip_heuristics/feasibility_jump/utils.cuh @@ -1,6 +1,6 @@ /* clang-format off */ /* - * SPDX-FileCopyrightText: Copyright (c) 2024-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-FileCopyrightText: Copyright (c) 2024-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. * SPDX-License-Identifier: Apache-2.0 */ /* clang-format on */ @@ -19,7 +19,7 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { HDI uint64_t hash_64(uint64_t x) { @@ -212,4 +212,4 @@ struct contiguous_set_t { bitmap_t validity_bitmap; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/local_search/feasibility_pump/feasibility_pump.cu b/cpp/src/mip_heuristics/local_search/feasibility_pump/feasibility_pump.cu index 0a17e3ebfd..bc47027ed5 100644 --- a/cpp/src/mip_heuristics/local_search/feasibility_pump/feasibility_pump.cu +++ b/cpp/src/mip_heuristics/local_search/feasibility_pump/feasibility_pump.cu @@ -14,7 +14,7 @@ #include #include -#include +#include #include #include @@ -29,7 +29,7 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template feasibility_pump_t::feasibility_pump_t( @@ -589,4 +589,4 @@ template class feasibility_pump_t; template class feasibility_pump_t; #endif -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/local_search/feasibility_pump/feasibility_pump.cuh b/cpp/src/mip_heuristics/local_search/feasibility_pump/feasibility_pump.cuh index df3ad405e6..181f6aeb22 100644 --- a/cpp/src/mip_heuristics/local_search/feasibility_pump/feasibility_pump.cuh +++ b/cpp/src/mip_heuristics/local_search/feasibility_pump/feasibility_pump.cuh @@ -17,7 +17,7 @@ #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { constexpr double default_alpha = 0.99; constexpr double distance_to_check_for_feasible = 0.01; @@ -159,4 +159,4 @@ class feasibility_pump_t { cuopt::timer_t timer; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/local_search/lagrangian.cuh b/cpp/src/mip_heuristics/local_search/lagrangian.cuh index 3ad176a4f8..9c814d91d0 100644 --- a/cpp/src/mip_heuristics/local_search/lagrangian.cuh +++ b/cpp/src/mip_heuristics/local_search/lagrangian.cuh @@ -12,7 +12,7 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { // computes the lagrangian objectives with the given weights of the constraints // we need both left and right weights because constraints might have had excess from either lower @@ -71,4 +71,4 @@ inline rmm::device_uvector get_lagrangian_weights(solution_t& sol return get_weighted_lagrangian_weights(solution, problem, cstr_weights, cstr_weights); } -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/local_search/line_segment_search/line_segment_search.cu b/cpp/src/mip_heuristics/local_search/line_segment_search/line_segment_search.cu index ce70aec745..4e52c33104 100644 --- a/cpp/src/mip_heuristics/local_search/line_segment_search/line_segment_search.cu +++ b/cpp/src/mip_heuristics/local_search/line_segment_search/line_segment_search.cu @@ -13,7 +13,7 @@ #include #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template line_segment_search_t::line_segment_search_t( @@ -298,4 +298,4 @@ template class line_segment_search_t; template class line_segment_search_t; #endif -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/local_search/line_segment_search/line_segment_search.cuh b/cpp/src/mip_heuristics/local_search/line_segment_search/line_segment_search.cuh index 30e169e9d9..08455df6b7 100644 --- a/cpp/src/mip_heuristics/local_search/line_segment_search/line_segment_search.cuh +++ b/cpp/src/mip_heuristics/local_search/line_segment_search/line_segment_search.cuh @@ -11,7 +11,7 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { struct line_segment_settings_t { bool recombiner_mode = false; @@ -54,4 +54,4 @@ class line_segment_search_t { line_segment_settings_t settings; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/local_search/local_search.cu b/cpp/src/mip_heuristics/local_search/local_search.cu index 8a288b2da8..75c4185949 100644 --- a/cpp/src/mip_heuristics/local_search/local_search.cu +++ b/cpp/src/mip_heuristics/local_search/local_search.cu @@ -20,7 +20,7 @@ #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template local_search_t::local_search_t(mip_solver_context_t& context_, @@ -160,8 +160,7 @@ void local_search_t::stop_cpufj_scratch_threads() } template -void local_search_t::start_cpufj_deterministic( - dual_simplex::branch_and_bound_t& bb) +void local_search_t::start_cpufj_deterministic(mip::branch_and_bound_t& bb) { producer_sync_t& producer_sync = bb.get_producer_sync(); @@ -903,4 +902,4 @@ template class local_search_t; template class local_search_t; #endif -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/local_search/local_search.cuh b/cpp/src/mip_heuristics/local_search/local_search.cuh index 9befd34ab5..e22d7e2d0e 100644 --- a/cpp/src/mip_heuristics/local_search/local_search.cuh +++ b/cpp/src/mip_heuristics/local_search/local_search.cuh @@ -15,12 +15,7 @@ #include #include -namespace cuopt::linear_programming::dual_simplex { -template -class branch_and_bound_t; -} - -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { // make sure RANDOM is always the last enum class ls_method_t : int { @@ -88,7 +83,7 @@ class local_search_t { i_t ls_threads() const { return ls_cpu_fj.size() + scratch_cpu_fj.size(); } // Start CPUFJ thread for deterministic mode with B&B integration - void start_cpufj_deterministic(dual_simplex::branch_and_bound_t& bb); + void start_cpufj_deterministic(mip::branch_and_bound_t& bb); void stop_cpufj_deterministic(); void save_solution_and_add_cutting_plane(solution_t& solution, rmm::device_uvector& best_solution, @@ -131,4 +126,4 @@ class local_search_t { population_t* pop_ptr{nullptr}; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/local_search/local_search_config.hpp b/cpp/src/mip_heuristics/local_search/local_search_config.hpp index 7663cf3074..1ea4dd292b 100644 --- a/cpp/src/mip_heuristics/local_search/local_search_config.hpp +++ b/cpp/src/mip_heuristics/local_search/local_search_config.hpp @@ -1,13 +1,13 @@ /* clang-format off */ /* - * SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. * SPDX-License-Identifier: Apache-2.0 */ /* clang-format on */ #pragma once -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { struct ls_config_t { static constexpr bool use_line_segment = true; @@ -16,4 +16,4 @@ struct ls_config_t { static constexpr bool use_cutting_plane_from_best_solution = false; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/local_search/rounding/bounds_repair.cu b/cpp/src/mip_heuristics/local_search/rounding/bounds_repair.cu index 6512ad05da..ddc6db68a7 100644 --- a/cpp/src/mip_heuristics/local_search/rounding/bounds_repair.cu +++ b/cpp/src/mip_heuristics/local_search/rounding/bounds_repair.cu @@ -18,7 +18,7 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template bounds_repair_t::bounds_repair_t(const problem_t& pb, @@ -469,4 +469,4 @@ template class bounds_repair_t; template class bounds_repair_t; #endif -}; // namespace cuopt::linear_programming::detail +}; // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/local_search/rounding/bounds_repair.cuh b/cpp/src/mip_heuristics/local_search/rounding/bounds_repair.cuh index e4f1b4a866..8331749849 100644 --- a/cpp/src/mip_heuristics/local_search/rounding/bounds_repair.cuh +++ b/cpp/src/mip_heuristics/local_search/rounding/bounds_repair.cuh @@ -16,7 +16,7 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { // from the paper, probability of choosing random candidate= noise parameter constexpr double p = 0.75; @@ -152,4 +152,4 @@ class bounds_repair_t { i_t cycle_write_pos = 0; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/local_search/rounding/constraint_prop.cu b/cpp/src/mip_heuristics/local_search/rounding/constraint_prop.cu index 51c103c74f..861432b720 100644 --- a/cpp/src/mip_heuristics/local_search/rounding/constraint_prop.cu +++ b/cpp/src/mip_heuristics/local_search/rounding/constraint_prop.cu @@ -21,7 +21,7 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template repair_stats_t constraint_prop_t::repair_stats; @@ -1259,4 +1259,4 @@ template class constraint_prop_t; template class constraint_prop_t; #endif -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/local_search/rounding/constraint_prop.cuh b/cpp/src/mip_heuristics/local_search/rounding/constraint_prop.cuh index 2c609228e8..89ab15b737 100644 --- a/cpp/src/mip_heuristics/local_search/rounding/constraint_prop.cuh +++ b/cpp/src/mip_heuristics/local_search/rounding/constraint_prop.cuh @@ -17,7 +17,7 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { struct repair_stats_t { size_t repair_attempts = 0; @@ -158,4 +158,4 @@ struct constraint_prop_t { f_t max_time_for_bounds_prop = 5.; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/local_search/rounding/lb_bounds_repair.cu b/cpp/src/mip_heuristics/local_search/rounding/lb_bounds_repair.cu index 10973f1565..676a6638d8 100644 --- a/cpp/src/mip_heuristics/local_search/rounding/lb_bounds_repair.cu +++ b/cpp/src/mip_heuristics/local_search/rounding/lb_bounds_repair.cu @@ -16,7 +16,7 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template lb_bounds_repair_t::lb_bounds_repair_t(const raft::handle_t* handle_ptr) @@ -489,4 +489,4 @@ template class lb_bounds_repair_t; template class lb_bounds_repair_t; #endif -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/local_search/rounding/lb_bounds_repair.cuh b/cpp/src/mip_heuristics/local_search/rounding/lb_bounds_repair.cuh index 0b549c684d..579fc84bdd 100644 --- a/cpp/src/mip_heuristics/local_search/rounding/lb_bounds_repair.cuh +++ b/cpp/src/mip_heuristics/local_search/rounding/lb_bounds_repair.cuh @@ -15,7 +15,7 @@ #include #include "bounds_repair.cuh" -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template struct lb_bounds_t { @@ -87,4 +87,4 @@ class lb_bounds_repair_t { i_t cycle_write_pos = 0; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/local_search/rounding/lb_constraint_prop.cu b/cpp/src/mip_heuristics/local_search/rounding/lb_constraint_prop.cu index bb72834ab4..bde8b08ce8 100644 --- a/cpp/src/mip_heuristics/local_search/rounding/lb_constraint_prop.cu +++ b/cpp/src/mip_heuristics/local_search/rounding/lb_constraint_prop.cu @@ -18,7 +18,7 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template lb_constraint_prop_t::lb_constraint_prop_t(mip_solver_context_t& context_) @@ -959,4 +959,4 @@ template class lb_constraint_prop_t; template class lb_constraint_prop_t; #endif -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/local_search/rounding/lb_constraint_prop.cuh b/cpp/src/mip_heuristics/local_search/rounding/lb_constraint_prop.cuh index 20e28e7cb9..fe2b6c5a09 100644 --- a/cpp/src/mip_heuristics/local_search/rounding/lb_constraint_prop.cuh +++ b/cpp/src/mip_heuristics/local_search/rounding/lb_constraint_prop.cuh @@ -15,7 +15,7 @@ #include #include "lb_bounds_repair.cuh" -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template struct lb_constraint_prop_t { @@ -112,4 +112,4 @@ struct lb_constraint_prop_t { double total_time_spent_on_bounds_prop = 0.; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/local_search/rounding/simple_rounding.cu b/cpp/src/mip_heuristics/local_search/rounding/simple_rounding.cu index 4f3a015a6c..404185fe26 100644 --- a/cpp/src/mip_heuristics/local_search/rounding/simple_rounding.cu +++ b/cpp/src/mip_heuristics/local_search/rounding/simple_rounding.cu @@ -21,7 +21,7 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template bool check_brute_force_rounding(solution_t& solution) @@ -189,4 +189,4 @@ INSTANTIATE(double) #undef INSTANTIATE -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/local_search/rounding/simple_rounding.cuh b/cpp/src/mip_heuristics/local_search/rounding/simple_rounding.cuh index ea714d91af..31fe25a81a 100644 --- a/cpp/src/mip_heuristics/local_search/rounding/simple_rounding.cuh +++ b/cpp/src/mip_heuristics/local_search/rounding/simple_rounding.cuh @@ -9,7 +9,7 @@ #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template void invoke_round_nearest(solution_t& solution); @@ -26,4 +26,4 @@ void invoke_correct_integers(solution_t& solution, f_t tol); template bool check_brute_force_rounding(solution_t& solution); -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/local_search/rounding/simple_rounding_kernels.cuh b/cpp/src/mip_heuristics/local_search/rounding/simple_rounding_kernels.cuh index 2edca8fb08..f800ba9ff9 100644 --- a/cpp/src/mip_heuristics/local_search/rounding/simple_rounding_kernels.cuh +++ b/cpp/src/mip_heuristics/local_search/rounding/simple_rounding_kernels.cuh @@ -13,7 +13,7 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template __global__ void simple_rounding_kernel(typename solution_t::view_t solution, @@ -197,4 +197,4 @@ __global__ void random_rounding_kernel(typename solution_t::view_t sol } } -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/logger.cuh b/cpp/src/mip_heuristics/logger.cuh index 479ce128bc..d202fe5a1f 100644 --- a/cpp/src/mip_heuristics/logger.cuh +++ b/cpp/src/mip_heuristics/logger.cuh @@ -1,6 +1,6 @@ /* clang-format off */ /* - * SPDX-FileCopyrightText: Copyright (c) 2024-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-FileCopyrightText: Copyright (c) 2024-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. * SPDX-License-Identifier: Apache-2.0 */ /* clang-format on */ @@ -9,7 +9,7 @@ #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { // Default to info level if not specified. #if !defined(CUOPT_LOG_ACTIVE_LEVEL) @@ -53,4 +53,4 @@ namespace cuopt::linear_programming::detail { #define DEVICE_LOG_CRITICAL(...) void(0) #endif -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/mip_constants.hpp b/cpp/src/mip_heuristics/mip_constants.hpp index 7d28048ba9..1d1e604d12 100644 --- a/cpp/src/mip_heuristics/mip_constants.hpp +++ b/cpp/src/mip_heuristics/mip_constants.hpp @@ -7,7 +7,7 @@ #pragma once -#include +#include #define MIP_INSTANTIATE_FLOAT CUOPT_INSTANTIATE_FLOAT #define MIP_INSTANTIATE_DOUBLE CUOPT_INSTANTIATE_DOUBLE diff --git a/cpp/src/mip_heuristics/mip_scaling_strategy.cu b/cpp/src/mip_heuristics/mip_scaling_strategy.cu index f9b9037131..8ff8310f61 100644 --- a/cpp/src/mip_heuristics/mip_scaling_strategy.cu +++ b/cpp/src/mip_heuristics/mip_scaling_strategy.cu @@ -36,7 +36,7 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { constexpr int row_scaling_max_iterations = 8; constexpr double row_scaling_min_initial_log2_spread = 12.0; @@ -145,7 +145,7 @@ struct integer_coeff_for_integer_var_transform_t { template void compute_row_inf_norm( - const cuopt::linear_programming::optimization_problem_t& op_problem, + const cuopt::mathematical_optimization::optimization_problem_t& op_problem, rmm::device_uvector& temp_storage, size_t temp_storage_bytes, rmm::device_uvector& row_inf_norm, @@ -170,7 +170,7 @@ void compute_row_inf_norm( template void compute_row_integer_gcd( - const cuopt::linear_programming::optimization_problem_t& op_problem, + const cuopt::mathematical_optimization::optimization_problem_t& op_problem, rmm::device_uvector& temp_storage, size_t temp_storage_bytes, rmm::device_uvector& row_integer_gcd, @@ -208,7 +208,7 @@ void compute_row_integer_gcd( template void compute_big_m_skip_rows( - const cuopt::linear_programming::optimization_problem_t& op_problem, + const cuopt::mathematical_optimization::optimization_problem_t& op_problem, rmm::device_uvector& temp_storage, size_t temp_storage_bytes, rmm::device_uvector& row_inf_norm, @@ -286,7 +286,7 @@ void compute_big_m_skip_rows( } template -void scale_objective(cuopt::linear_programming::optimization_problem_t& op_problem) +void scale_objective(cuopt::mathematical_optimization::optimization_problem_t& op_problem) { auto& obj_coefficients = op_problem.get_objective_coefficients(); const i_t n_cols = op_problem.get_n_variables(); @@ -354,7 +354,7 @@ void scale_objective(cuopt::linear_programming::optimization_problem_t template rmm::device_uvector capture_pre_scaling_integer_gcd( - const cuopt::linear_programming::optimization_problem_t& op_problem, + const cuopt::mathematical_optimization::optimization_problem_t& op_problem, rmm::device_uvector& temp_storage, size_t temp_storage_bytes, rmm::cuda_stream_view stream_view) @@ -367,7 +367,7 @@ rmm::device_uvector capture_pre_scaling_integer_gcd( template void assert_integer_coefficient_integrality( - const cuopt::linear_programming::optimization_problem_t& op_problem, + const cuopt::mathematical_optimization::optimization_problem_t& op_problem, rmm::device_uvector& temp_storage, size_t temp_storage_bytes, const rmm::device_uvector& pre_scaling_gcd, @@ -408,13 +408,14 @@ mip_scaling_strategy_t::mip_scaling_strategy_t( } template -size_t dry_run_cub(const cuopt::linear_programming::optimization_problem_t& op_problem, - i_t n_rows, - rmm::device_uvector& row_inf_norm, - rmm::device_uvector& row_min_nonzero, - rmm::device_uvector& row_nonzero_count, - rmm::device_uvector& row_integer_gcd, - rmm::cuda_stream_view stream_view) +size_t dry_run_cub( + const cuopt::mathematical_optimization::optimization_problem_t& op_problem, + i_t n_rows, + rmm::device_uvector& row_inf_norm, + rmm::device_uvector& row_min_nonzero, + rmm::device_uvector& row_nonzero_count, + rmm::device_uvector& row_integer_gcd, + rmm::cuda_stream_view stream_view) { const auto& matrix_values = op_problem.get_constraint_matrix_values(); const auto& matrix_indices = op_problem.get_constraint_matrix_indices(); @@ -879,4 +880,4 @@ INSTANTIATE(float) INSTANTIATE(double) #endif -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/mip_scaling_strategy.cuh b/cpp/src/mip_heuristics/mip_scaling_strategy.cuh index 63d88dbec6..3355eee5ca 100644 --- a/cpp/src/mip_heuristics/mip_scaling_strategy.cuh +++ b/cpp/src/mip_heuristics/mip_scaling_strategy.cuh @@ -7,18 +7,19 @@ #pragma once -#include +#include #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template class mip_scaling_strategy_t { public: - using optimization_problem_type_t = cuopt::linear_programming::optimization_problem_t; + using optimization_problem_type_t = + cuopt::mathematical_optimization::optimization_problem_t; explicit mip_scaling_strategy_t(optimization_problem_type_t& op_problem_scaled); void scale_problem(bool scale_objective = true); @@ -29,4 +30,4 @@ class mip_scaling_strategy_t { optimization_problem_type_t& op_problem_scaled_; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/presolve/bounds_presolve.cu b/cpp/src/mip_heuristics/presolve/bounds_presolve.cu index 81717dbecf..e5a7f249f1 100644 --- a/cpp/src/mip_heuristics/presolve/bounds_presolve.cu +++ b/cpp/src/mip_heuristics/presolve/bounds_presolve.cu @@ -5,7 +5,7 @@ */ /* clang-format on */ -#include +#include #include #include @@ -23,7 +23,7 @@ #include "bounds_presolve_helpers.cuh" #include "bounds_update_helpers.cuh" -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { // Tobias Achterberg, Robert E. Bixby, Zonghao Gu, Edward Rothberg, Dieter Weninger (2019) Presolve // Reductions in Mixed Integer Programming. INFORMS Journal on Computing 32(2):473-506. @@ -366,4 +366,4 @@ template class bound_presolve_t; template class bound_presolve_t; #endif -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/presolve/bounds_presolve.cuh b/cpp/src/mip_heuristics/presolve/bounds_presolve.cuh index ed0b91466d..5580c5e470 100644 --- a/cpp/src/mip_heuristics/presolve/bounds_presolve.cuh +++ b/cpp/src/mip_heuristics/presolve/bounds_presolve.cuh @@ -23,7 +23,7 @@ #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template class probing_cache_t; @@ -84,4 +84,4 @@ class bound_presolve_t { i_t solve_iter; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/presolve/bounds_presolve_helpers.cuh b/cpp/src/mip_heuristics/presolve/bounds_presolve_helpers.cuh index 0804f68a70..ed25e1a2c1 100644 --- a/cpp/src/mip_heuristics/presolve/bounds_presolve_helpers.cuh +++ b/cpp/src/mip_heuristics/presolve/bounds_presolve_helpers.cuh @@ -1,6 +1,6 @@ /* clang-format off */ /* - * SPDX-FileCopyrightText: Copyright (c) 2022-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-FileCopyrightText: Copyright (c) 2022-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. * SPDX-License-Identifier: Apache-2.0 */ /* clang-format on */ @@ -15,7 +15,7 @@ #include "bounds_update_data.cuh" -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template struct tuple_plus_t { @@ -35,4 +35,4 @@ struct tuple_plus_t { } }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/presolve/bounds_update_data.cu b/cpp/src/mip_heuristics/presolve/bounds_update_data.cu index 7314cd5c23..afcd240374 100644 --- a/cpp/src/mip_heuristics/presolve/bounds_update_data.cu +++ b/cpp/src/mip_heuristics/presolve/bounds_update_data.cu @@ -10,7 +10,7 @@ #include #include "bounds_update_data.cuh" -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template bounds_update_data_t::bounds_update_data_t(problem_t& problem) @@ -88,4 +88,4 @@ template class bounds_update_data_t; template class bounds_update_data_t; #endif -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/presolve/bounds_update_data.cuh b/cpp/src/mip_heuristics/presolve/bounds_update_data.cuh index 8d1eac478b..3168139004 100644 --- a/cpp/src/mip_heuristics/presolve/bounds_update_data.cuh +++ b/cpp/src/mip_heuristics/presolve/bounds_update_data.cuh @@ -12,7 +12,7 @@ #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template struct bounds_update_data_t { @@ -45,4 +45,4 @@ struct bounds_update_data_t { view_t view(); }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/presolve/bounds_update_helpers.cuh b/cpp/src/mip_heuristics/presolve/bounds_update_helpers.cuh index 074cd17a60..f608ae3ede 100644 --- a/cpp/src/mip_heuristics/presolve/bounds_update_helpers.cuh +++ b/cpp/src/mip_heuristics/presolve/bounds_update_helpers.cuh @@ -10,7 +10,7 @@ #include #include "bounds_update_data.cuh" -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { // Activity calculation @@ -398,4 +398,4 @@ __global__ void update_bounds_kernel(typename problem_t::view_t pb, } } -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/presolve/conditional_bound_strengthening.cu b/cpp/src/mip_heuristics/presolve/conditional_bound_strengthening.cu index 43c58ff1d7..b1f27de8a6 100644 --- a/cpp/src/mip_heuristics/presolve/conditional_bound_strengthening.cu +++ b/cpp/src/mip_heuristics/presolve/conditional_bound_strengthening.cu @@ -26,7 +26,7 @@ #include "conditional_bound_strengthening.cuh" #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { constexpr size_t max_pair_per_row = 100; @@ -723,4 +723,4 @@ template class conditional_bound_strengthening_t; #if MIP_INSTANTIATE_DOUBLE template class conditional_bound_strengthening_t; #endif -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/presolve/conditional_bound_strengthening.cuh b/cpp/src/mip_heuristics/presolve/conditional_bound_strengthening.cuh index 50b11e8e63..ed00319c01 100644 --- a/cpp/src/mip_heuristics/presolve/conditional_bound_strengthening.cuh +++ b/cpp/src/mip_heuristics/presolve/conditional_bound_strengthening.cuh @@ -24,7 +24,7 @@ // constraint bounds which should help reduce the gap between LP relaxation and optimal integer // solutions We need to implement variable bounds improvement as well -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template class conditional_bound_strengthening_t { @@ -48,4 +48,4 @@ class conditional_bound_strengthening_t { rmm::device_uvector locks_per_constraint; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/presolve/conflict_graph/clique_table.cu b/cpp/src/mip_heuristics/presolve/conflict_graph/clique_table.cu index a5c56c0664..bcf2d1a9dd 100644 --- a/cpp/src/mip_heuristics/presolve/conflict_graph/clique_table.cu +++ b/cpp/src/mip_heuristics/presolve/conflict_graph/clique_table.cu @@ -30,7 +30,10 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { + +using simplex::csr_matrix_t; +using simplex::user_problem_t; // do constraints with only binary variables. template @@ -99,7 +102,7 @@ void sort_csr_by_constraint_coefficients( template void make_coeff_positive_knapsack_constraint( - const dual_simplex::user_problem_t& problem, + const user_problem_t& problem, std::vector>& knapsack_constraints, typename mip_solver_settings_t::tolerances_t tolerances) { @@ -132,9 +135,9 @@ void make_coeff_positive_knapsack_constraint( // convert all the knapsack constraints // if a binary variable has a negative coefficient, put its negation in the constraint template -void fill_knapsack_constraints(const dual_simplex::user_problem_t& problem, +void fill_knapsack_constraints(const user_problem_t& problem, std::vector>& knapsack_constraints, - dual_simplex::csr_matrix_t& A) + csr_matrix_t& A) { // we might add additional constraints for the equality constraints i_t added_constraints = 0; @@ -154,7 +157,7 @@ void fill_knapsack_constraints(const dual_simplex::user_problem_t& pro bool all_binary = true; // check if all variables are binary (any non-continuous with bounds [0,1]) for (i_t j = constraint_range.first; j < constraint_range.second; j++) { - if (problem.var_types[A.j[j]] == dual_simplex::variable_type_t::CONTINUOUS || + if (problem.var_types[A.j[j]] == simplex::variable_type_t::CONTINUOUS || problem.lower[A.j[j]] != 0 || problem.upper[A.j[j]] != 1) { all_binary = false; break; @@ -593,7 +596,7 @@ void clique_table_t::set_small_clique_adj_for_test( } template -void build_clique_table(const dual_simplex::user_problem_t& problem, +void build_clique_table(const user_problem_t& problem, clique_table_t& clique_table, typename mip_solver_settings_t::tolerances_t tolerances, bool remove_small_cliques_flag, @@ -605,7 +608,7 @@ void build_clique_table(const dual_simplex::user_problem_t& problem, cuopt_assert(problem.var_types.size() == static_cast(problem.num_cols), "Problem variable types size mismatch"); std::vector> knapsack_constraints; - dual_simplex::csr_matrix_t A(problem.num_rows, problem.num_cols, 0); + csr_matrix_t A(problem.num_rows, problem.num_cols, 0); problem.A.to_compressed_row(A); fill_knapsack_constraints(problem, knapsack_constraints, A); make_coeff_positive_knapsack_constraint(problem, knapsack_constraints, tolerances); @@ -662,7 +665,7 @@ void print_clique_table(const clique_table_t& clique_table) } template -void find_initial_cliques(dual_simplex::user_problem_t& problem, +void find_initial_cliques(user_problem_t& problem, typename mip_solver_settings_t::tolerances_t tolerances, std::shared_ptr>* clique_table_out, cuopt::timer_t& timer, @@ -680,7 +683,7 @@ void find_initial_cliques(dual_simplex::user_problem_t& problem, double t_remove = 0.; #endif std::vector> knapsack_constraints; - dual_simplex::csr_matrix_t A(problem.num_rows, problem.num_cols, 0); + csr_matrix_t A(problem.num_rows, problem.num_cols, 0); problem.A.to_compressed_row(A); fill_knapsack_constraints(problem, knapsack_constraints, A); #ifdef DEBUG_CLIQUE_TABLE @@ -762,13 +765,13 @@ void find_initial_cliques(dual_simplex::user_problem_t& problem, #define INSTANTIATE(F_TYPE) \ template void find_initial_cliques( \ - dual_simplex::user_problem_t & problem, \ + user_problem_t & problem, \ typename mip_solver_settings_t::tolerances_t tolerances, \ std::shared_ptr> * clique_table_out, \ cuopt::timer_t & timer, \ omp_atomic_t * signal_extend); \ template void build_clique_table( \ - const dual_simplex::user_problem_t& problem, \ + const user_problem_t& problem, \ clique_table_t& clique_table, \ typename mip_solver_settings_t::tolerances_t tolerances, \ bool remove_small_cliques_flag, \ @@ -785,4 +788,4 @@ INSTANTIATE(double) #endif #undef INSTANTIATE -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/presolve/conflict_graph/clique_table.cuh b/cpp/src/mip_heuristics/presolve/conflict_graph/clique_table.cuh index 3e1934ee5d..4abb7bfb52 100644 --- a/cpp/src/mip_heuristics/presolve/conflict_graph/clique_table.cuh +++ b/cpp/src/mip_heuristics/presolve/conflict_graph/clique_table.cuh @@ -17,7 +17,7 @@ #pragma once -#include +#include #include #include @@ -31,7 +31,7 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { struct clique_config_t { int min_clique_size = 512; @@ -205,14 +205,14 @@ struct clique_table_t { }; template -void find_initial_cliques(dual_simplex::user_problem_t& problem, +void find_initial_cliques(simplex::user_problem_t& problem, typename mip_solver_settings_t::tolerances_t tolerances, std::shared_ptr>* clique_table_out, cuopt::timer_t& timer, omp_atomic_t* signal_extend = nullptr); template -void build_clique_table(const dual_simplex::user_problem_t& problem, +void build_clique_table(const simplex::user_problem_t& problem, clique_table_t& clique_table, typename mip_solver_settings_t::tolerances_t tolerances, bool remove_small_cliques, @@ -222,7 +222,7 @@ void build_clique_table(const dual_simplex::user_problem_t& problem, template void fill_var_clique_maps(clique_table_t& clique_table); -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip // Possible application to rounding procedure, keeping it as reference diff --git a/cpp/src/mip_heuristics/presolve/gf2_presolve.cpp b/cpp/src/mip_heuristics/presolve/gf2_presolve.cpp index 8ab0176cc4..19eabaf930 100644 --- a/cpp/src/mip_heuristics/presolve/gf2_presolve.cpp +++ b/cpp/src/mip_heuristics/presolve/gf2_presolve.cpp @@ -25,7 +25,7 @@ } while (0) #endif -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template static inline i_t positive_modulo(i_t i, i_t n) @@ -257,4 +257,4 @@ INSTANTIATE(double) #undef INSTANTIATE -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/presolve/gf2_presolve.hpp b/cpp/src/mip_heuristics/presolve/gf2_presolve.hpp index 9c90fe4fa0..1ae4bd5f06 100644 --- a/cpp/src/mip_heuristics/presolve/gf2_presolve.hpp +++ b/cpp/src/mip_heuristics/presolve/gf2_presolve.hpp @@ -20,7 +20,7 @@ #pragma GCC diagnostic pop #endif -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template class GF2Presolve : public papilo::PresolveMethod { @@ -66,4 +66,4 @@ class GF2Presolve : public papilo::PresolveMethod { } }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/presolve/lb_probing_cache.cu b/cpp/src/mip_heuristics/presolve/lb_probing_cache.cu index bbb58c0164..3ac7650615 100644 --- a/cpp/src/mip_heuristics/presolve/lb_probing_cache.cu +++ b/cpp/src/mip_heuristics/presolve/lb_probing_cache.cu @@ -16,7 +16,7 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template void lb_probing_cache_t::update_bounds_with_selected( @@ -415,4 +415,4 @@ INSTANTIATE(double) #undef INSTANTIATE -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/presolve/load_balanced_bounds_presolve.cu b/cpp/src/mip_heuristics/presolve/load_balanced_bounds_presolve.cu index f48eae1de8..017bf32e91 100644 --- a/cpp/src/mip_heuristics/presolve/load_balanced_bounds_presolve.cu +++ b/cpp/src/mip_heuristics/presolve/load_balanced_bounds_presolve.cu @@ -26,7 +26,7 @@ #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { // Tobias Achterberg, Robert E. Bixby, Zonghao Gu, Edward Rothberg, Dieter Weninger (2019) Presolve // Reductions in Mixed Integer Programming. INFORMS Journal on Computing 32(2):473-506. @@ -697,4 +697,4 @@ template class load_balanced_bounds_presolve_t; template class load_balanced_bounds_presolve_t; #endif -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/presolve/load_balanced_bounds_presolve.cuh b/cpp/src/mip_heuristics/presolve/load_balanced_bounds_presolve.cuh index ff085ca962..341d9cd262 100644 --- a/cpp/src/mip_heuristics/presolve/load_balanced_bounds_presolve.cuh +++ b/cpp/src/mip_heuristics/presolve/load_balanced_bounds_presolve.cuh @@ -20,7 +20,7 @@ #include "load_balanced_partition_helpers.cuh" #include "utils.cuh" -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template class load_balanced_problem_t; @@ -262,4 +262,4 @@ class load_balanced_bounds_presolve_t { i_t solve_iter; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/presolve/load_balanced_bounds_presolve_helpers.cuh b/cpp/src/mip_heuristics/presolve/load_balanced_bounds_presolve_helpers.cuh index f276840bdf..6f8a811309 100644 --- a/cpp/src/mip_heuristics/presolve/load_balanced_bounds_presolve_helpers.cuh +++ b/cpp/src/mip_heuristics/presolve/load_balanced_bounds_presolve_helpers.cuh @@ -21,7 +21,7 @@ #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { #define CUDA_VER_13_0_UP (CUDART_VERSION >= 13000) @@ -1158,4 +1158,4 @@ void create_update_bounds_heavy_vars(cudaGraph_t upd_graph, } } -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/presolve/load_balanced_bounds_presolve_kernels.cuh b/cpp/src/mip_heuristics/presolve/load_balanced_bounds_presolve_kernels.cuh index d2301bcfb4..28626365ce 100644 --- a/cpp/src/mip_heuristics/presolve/load_balanced_bounds_presolve_kernels.cuh +++ b/cpp/src/mip_heuristics/presolve/load_balanced_bounds_presolve_kernels.cuh @@ -9,7 +9,7 @@ #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template __device__ __forceinline__ void detect_range_sub_warp(i_t* id_warp_beg, @@ -633,4 +633,4 @@ __global__ void lb_upd_bnd_sub_warp_kernel(bounds_update_view_t view, } } -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/presolve/load_balanced_partition_helpers.cuh b/cpp/src/mip_heuristics/presolve/load_balanced_partition_helpers.cuh index 0ace09afbe..1f2b387cc2 100644 --- a/cpp/src/mip_heuristics/presolve/load_balanced_partition_helpers.cuh +++ b/cpp/src/mip_heuristics/presolve/load_balanced_partition_helpers.cuh @@ -15,7 +15,7 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template constexpr int BitsPWrd = sizeof(degree_t) * 8; @@ -276,4 +276,4 @@ log_dist_t vertex_bin_t::run(rmm::device_uvector& reorganized_ver return log_dist_t(reorganized_vertices, bin_offsets_); } -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/presolve/multi_probe.cu b/cpp/src/mip_heuristics/presolve/multi_probe.cu index 9ffed054eb..f1adf28650 100644 --- a/cpp/src/mip_heuristics/presolve/multi_probe.cu +++ b/cpp/src/mip_heuristics/presolve/multi_probe.cu @@ -20,7 +20,7 @@ #include "bounds_update_helpers.cuh" #include "multi_probe.cuh" -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { // Tobias Achterberg, Robert E. Bixby, Zonghao Gu, Edward Rothberg, Dieter Weninger (2019) Presolve // Reductions in Mixed Integer Programming. INFORMS Journal on Computing 32(2):473-506. @@ -496,4 +496,4 @@ template class multi_probe_t; template class multi_probe_t; #endif -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/presolve/multi_probe.cuh b/cpp/src/mip_heuristics/presolve/multi_probe.cuh index a043770789..b4227281b6 100644 --- a/cpp/src/mip_heuristics/presolve/multi_probe.cuh +++ b/cpp/src/mip_heuristics/presolve/multi_probe.cuh @@ -17,7 +17,7 @@ #include "bounds_update_data.cuh" #include "utils.cuh" -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template class multi_probe_t { @@ -83,4 +83,4 @@ class multi_probe_t { i_t redund_constraints_count_1 = 0; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/presolve/probing_cache.cu b/cpp/src/mip_heuristics/presolve/probing_cache.cu index 3767e0f2d0..fd4790479b 100644 --- a/cpp/src/mip_heuristics/presolve/probing_cache.cu +++ b/cpp/src/mip_heuristics/presolve/probing_cache.cu @@ -24,7 +24,7 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template i_t probing_cache_t::check_number_of_conflicting_vars( @@ -967,4 +967,4 @@ INSTANTIATE(double) #undef INSTANTIATE -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/presolve/probing_cache.cuh b/cpp/src/mip_heuristics/presolve/probing_cache.cuh index 91da6a15c8..ec532febb9 100644 --- a/cpp/src/mip_heuristics/presolve/probing_cache.cuh +++ b/cpp/src/mip_heuristics/presolve/probing_cache.cuh @@ -13,7 +13,7 @@ #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template class bound_presolve_t; @@ -121,4 +121,4 @@ bool compute_probing_cache(bound_presolve_t& bound_presolve, problem_t& problem, timer_t timer); -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/presolve/semi_continuous.cu b/cpp/src/mip_heuristics/presolve/semi_continuous.cu index 812b14f5da..ebd8d24a7a 100644 --- a/cpp/src/mip_heuristics/presolve/semi_continuous.cu +++ b/cpp/src/mip_heuristics/presolve/semi_continuous.cu @@ -27,7 +27,7 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { namespace { @@ -73,28 +73,27 @@ std::vector call_host_bounds_strengthening(const optimization_problem_t(op_problem.get_handle_ptr(), op_problem); - dual_simplex::lp_problem_t lp_problem(op_problem.get_handle_ptr(), 1, 1, 1); + simplex::lp_problem_t lp_problem(op_problem.get_handle_ptr(), 1, 1, 1); std::vector new_slacks; - dual_simplex::dualize_info_t dualize_info; - dual_simplex::simplex_solver_settings_t simplex_settings; + simplex::dualize_info_t dualize_info; + simplex::simplex_solver_settings_t simplex_settings; simplex_settings.primal_tol = settings.tolerances.presolve_absolute_tolerance; simplex_settings.integer_tol = settings.tolerances.integrality_tolerance; simplex_settings.set_log(false); - dual_simplex::convert_user_problem( + simplex::convert_user_problem( user_problem, simplex_settings, lp_problem, new_slacks, dualize_info); auto var_types = user_problem.var_types; - var_types.resize(lp_problem.num_cols, dual_simplex::variable_type_t::CONTINUOUS); + var_types.resize(lp_problem.num_cols, simplex::variable_type_t::CONTINUOUS); - dual_simplex::csr_matrix_t Arow(1, 1, 1); + simplex::csr_matrix_t Arow(1, 1, 1); lp_problem.A.to_compressed_row(Arow); // convert_user_problem returns an equality-form LP. Empty row_sense makes // bounds_strengthening_t use rhs as both lower and upper row bounds. std::vector row_sense; - dual_simplex::bounds_strengthening_t strengthening( - lp_problem, Arow, row_sense, var_types); + simplex::bounds_strengthening_t strengthening(lp_problem, Arow, row_sense, var_types); std::vector bounds_changed(lp_problem.num_cols, false); for (i_t idx : sc_indices) { bounds_changed[idx] = true; @@ -416,4 +415,4 @@ template void expand_initial_solutions_for_semi_continuous(mip_solver_settings_t rmm::cuda_stream_view); #endif -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/presolve/semi_continuous.cuh b/cpp/src/mip_heuristics/presolve/semi_continuous.cuh index 6d37c62b4d..ce3edc16a5 100644 --- a/cpp/src/mip_heuristics/presolve/semi_continuous.cuh +++ b/cpp/src/mip_heuristics/presolve/semi_continuous.cuh @@ -7,10 +7,10 @@ #pragma once -#include -#include +#include +#include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { /** * @brief Reformulate semi-continuous variables in-place inside the MIP solver. @@ -67,4 +67,4 @@ template void strip_semi_continuous_auxiliaries_from_assignment(std::vector& assignment, i_t original_num_variables); -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/presolve/third_party_presolve.cpp b/cpp/src/mip_heuristics/presolve/third_party_presolve.cpp index d94cf5aa67..d842d2c9ef 100644 --- a/cpp/src/mip_heuristics/presolve/third_party_presolve.cpp +++ b/cpp/src/mip_heuristics/presolve/third_party_presolve.cpp @@ -44,7 +44,7 @@ #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template papilo::Problem build_papilo_problem(const optimization_problem_t& op_problem, @@ -550,7 +550,8 @@ void set_presolve_methods(papilo::Presolve& presolver, if (category == problem_category_t::MIP) { // cuOpt custom GF2 presolver - presolver.addPresolveMethod(uptr(new cuopt::linear_programming::detail::GF2Presolve())); + presolver.addPresolveMethod( + uptr(new cuopt::mathematical_optimization::mip::GF2Presolve())); } // fast presolvers presolver.addPresolveMethod(uptr(new papilo::SingletonCols())); @@ -661,7 +662,7 @@ template third_party_presolve_result_t third_party_presolve_t::apply( optimization_problem_t const& op_problem, problem_category_t category, - cuopt::linear_programming::presolver_t presolver, + cuopt::mathematical_optimization::presolver_t presolver, bool dual_postsolve, f_t absolute_tolerance, f_t relative_tolerance, @@ -671,12 +672,12 @@ third_party_presolve_result_t third_party_presolve_t::apply( presolver_ = presolver; maximize_ = op_problem.get_sense(); if (category == problem_category_t::MIP && - presolver == cuopt::linear_programming::presolver_t::PSLP) { + presolver == cuopt::mathematical_optimization::presolver_t::PSLP) { cuopt_expects( false, error_type_t::RuntimeError, "PSLP presolver is not supported for MIP problems"); } - if (presolver == cuopt::linear_programming::presolver_t::PSLP) { + if (presolver == cuopt::mathematical_optimization::presolver_t::PSLP) { return apply_pslp(op_problem, time_limit); } @@ -775,7 +776,7 @@ void third_party_presolve_t::undo(rmm::device_uvector& primal_sol bool dual_postsolve, rmm::cuda_stream_view stream_view) { - if (presolver_ == cuopt::linear_programming::presolver_t::PSLP) { + if (presolver_ == cuopt::mathematical_optimization::presolver_t::PSLP) { undo_pslp(primal_solution, dual_solution, reduced_costs, stream_view); return; } @@ -856,7 +857,7 @@ template void third_party_presolve_t::uncrush_primal_solution( const std::vector& reduced_primal, std::vector& full_primal) const { - if (presolver_ == cuopt::linear_programming::presolver_t::PSLP) { + if (presolver_ == cuopt::mathematical_optimization::presolver_t::PSLP) { cuopt_expects(false, error_type_t::RuntimeError, "This code path should be never called, as this is meant for callbacks and they " @@ -899,4 +900,4 @@ template struct papilo_postsolve_deleter; template class third_party_presolve_t; #endif -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/presolve/third_party_presolve.hpp b/cpp/src/mip_heuristics/presolve/third_party_presolve.hpp index a067f604e7..3b6b92a40d 100644 --- a/cpp/src/mip_heuristics/presolve/third_party_presolve.hpp +++ b/cpp/src/mip_heuristics/presolve/third_party_presolve.hpp @@ -11,7 +11,7 @@ #include #include -#include +#include #include @@ -20,7 +20,7 @@ template class PostsolveStorage; } -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template struct papilo_postsolve_deleter { @@ -58,14 +58,15 @@ class third_party_presolve_t { third_party_presolve_t(third_party_presolve_t&&) = delete; third_party_presolve_t& operator=(third_party_presolve_t&&) = delete; - third_party_presolve_result_t apply(optimization_problem_t const& op_problem, - problem_category_t category, - cuopt::linear_programming::presolver_t presolver, - bool dual_postsolve, - f_t absolute_tolerance, - f_t relative_tolerance, - double time_limit, - i_t num_cpu_threads = 0); + third_party_presolve_result_t apply( + optimization_problem_t const& op_problem, + problem_category_t category, + cuopt::mathematical_optimization::presolver_t presolver, + bool dual_postsolve, + f_t absolute_tolerance, + f_t relative_tolerance, + double time_limit, + i_t num_cpu_threads = 0); void undo(rmm::device_uvector& primal_solution, rmm::device_uvector& dual_solution, @@ -91,8 +92,9 @@ class third_party_presolve_t { rmm::device_uvector& reduced_costs, rmm::cuda_stream_view stream_view); - bool maximize_ = false; - cuopt::linear_programming::presolver_t presolver_ = cuopt::linear_programming::presolver_t::PSLP; + bool maximize_ = false; + cuopt::mathematical_optimization::presolver_t presolver_ = + cuopt::mathematical_optimization::presolver_t::PSLP; // PSLP settings Settings* pslp_stgs_{nullptr}; Presolver* pslp_presolver_{nullptr}; @@ -107,4 +109,4 @@ class third_party_presolve_t { std::vector original_to_reduced_map_{}; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/presolve/trivial_presolve.cu b/cpp/src/mip_heuristics/presolve/trivial_presolve.cu index 283998f142..9669e8b526 100644 --- a/cpp/src/mip_heuristics/presolve/trivial_presolve.cu +++ b/cpp/src/mip_heuristics/presolve/trivial_presolve.cu @@ -8,7 +8,7 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { #if MIP_INSTANTIATE_FLOAT template void trivial_presolve(problem_t& problem, bool remap_cache_ids); @@ -18,4 +18,4 @@ template void trivial_presolve(problem_t& problem, bool remap_cache_ template void trivial_presolve(problem_t& problem, bool remap_cache_ids); #endif -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/presolve/trivial_presolve.cuh b/cpp/src/mip_heuristics/presolve/trivial_presolve.cuh index 28162d7482..eff3b64910 100644 --- a/cpp/src/mip_heuristics/presolve/trivial_presolve.cuh +++ b/cpp/src/mip_heuristics/presolve/trivial_presolve.cuh @@ -33,7 +33,7 @@ #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template void test_renumbered_coo(raft::device_span coo_major, const problem_t& pb) @@ -365,10 +365,10 @@ void trivial_presolve(problem_t& problem, bool remap_cache_ids = false problem.recompute_auxilliary_data( false); // check problem representation later once cstr bounds are computed cuopt_func_call(test_reverse_matches(problem)); - combine_constraint_bounds(problem, problem.combined_bounds); + pdlp::combine_constraint_bounds(problem, problem.combined_bounds); // The problem has been solved by presolve. Mark its empty status as valid if (problem.n_variables == 0) { problem.empty = true; } problem.check_problem_representation(true); } -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/presolve/trivial_presolve_helpers.cuh b/cpp/src/mip_heuristics/presolve/trivial_presolve_helpers.cuh index 95471d325d..626c736ab8 100644 --- a/cpp/src/mip_heuristics/presolve/trivial_presolve_helpers.cuh +++ b/cpp/src/mip_heuristics/presolve/trivial_presolve_helpers.cuh @@ -13,7 +13,7 @@ #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template struct non_zero_degree_t { @@ -184,4 +184,4 @@ struct is_zero_t { __device__ bool operator()(const i_t x) { return (x == 0); } }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/presolve/utils.cuh b/cpp/src/mip_heuristics/presolve/utils.cuh index 4870b3180c..e7ef92637f 100644 --- a/cpp/src/mip_heuristics/presolve/utils.cuh +++ b/cpp/src/mip_heuristics/presolve/utils.cuh @@ -1,13 +1,13 @@ /* clang-format off */ /* - * SPDX-FileCopyrightText: Copyright (c) 2022-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-FileCopyrightText: Copyright (c) 2022-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. * SPDX-License-Identifier: Apache-2.0 */ /* clang-format on */ #pragma once -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { enum class termination_criterion_t { TIME_LIMIT, @@ -17,4 +17,4 @@ enum class termination_criterion_t { NO_UPDATE }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/problem/host_helper.cuh b/cpp/src/mip_heuristics/problem/host_helper.cuh index 00015282e9..17eecb41d8 100644 --- a/cpp/src/mip_heuristics/problem/host_helper.cuh +++ b/cpp/src/mip_heuristics/problem/host_helper.cuh @@ -10,11 +10,11 @@ #include #include -#include +#include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template struct constraints_delta_t { @@ -65,4 +65,4 @@ struct variables_delta_t { } }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/problem/load_balanced_problem.cu b/cpp/src/mip_heuristics/problem/load_balanced_problem.cu index 585cd1068f..3199750679 100644 --- a/cpp/src/mip_heuristics/problem/load_balanced_problem.cu +++ b/cpp/src/mip_heuristics/problem/load_balanced_problem.cu @@ -18,7 +18,7 @@ #include "load_balanced_problem.cuh" -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template std::tuple bin_meta(std::vector& bins, i_t deg_beg, i_t deg_end) @@ -406,4 +406,4 @@ template class load_balanced_problem_t; template class load_balanced_problem_t; #endif -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/problem/load_balanced_problem.cuh b/cpp/src/mip_heuristics/problem/load_balanced_problem.cuh index 85c54a622e..582f672b90 100644 --- a/cpp/src/mip_heuristics/problem/load_balanced_problem.cuh +++ b/cpp/src/mip_heuristics/problem/load_balanced_problem.cuh @@ -10,8 +10,8 @@ // THIS IS LIKELY THE INNER-MOST INCLUDE // FOR COMPILE TIME, WE SHOULD KEEP THE INCLUDES ON THIS HEADER MINIMAL -#include -#include +#include +#include #include "host_helper.cuh" #include @@ -28,7 +28,7 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template class load_balanced_bounds_presolve_t; @@ -86,4 +86,4 @@ class load_balanced_problem_t { vertex_bin_t vars_binner; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/problem/presolve_data.cu b/cpp/src/mip_heuristics/problem/presolve_data.cu index 884b5f9069..e834ce8c21 100644 --- a/cpp/src/mip_heuristics/problem/presolve_data.cu +++ b/cpp/src/mip_heuristics/problem/presolve_data.cu @@ -22,14 +22,14 @@ #include namespace cuopt { -namespace linear_programming::detail { +namespace mathematical_optimization::mip { template bool presolve_data_t::pre_process_assignment(problem_t& problem, rmm::device_uvector& assignment) { raft::common::nvtx::range fun_scope("pre_process_assignment"); - auto has_nans = cuopt::linear_programming::detail::has_nans(problem.handle_ptr, assignment); + auto has_nans = cuopt::mathematical_optimization::mip::has_nans(problem.handle_ptr, assignment); if (has_nans) { CUOPT_LOG_DEBUG("Solution discarded due to nans"); return false; @@ -80,18 +80,19 @@ bool presolve_data_t::pre_process_assignment(problem_t& prob assignment.begin()); problem.handle_ptr->sync_stream(); - auto has_integrality_discrepancy = cuopt::linear_programming::detail::has_integrality_discrepancy( - problem.handle_ptr, - problem.integer_indices, - assignment, - problem.tolerances.integrality_tolerance); + auto has_integrality_discrepancy = + cuopt::mathematical_optimization::mip::has_integrality_discrepancy( + problem.handle_ptr, + problem.integer_indices, + assignment, + problem.tolerances.integrality_tolerance); if (has_integrality_discrepancy) { CUOPT_LOG_DEBUG("Solution discarded due to integrality discrepancy"); return false; } auto has_variable_bounds_violation = - cuopt::linear_programming::detail::has_variable_bounds_violation( + cuopt::mathematical_optimization::mip::has_variable_bounds_violation( problem.handle_ptr, assignment, &problem); if (has_variable_bounds_violation) { CUOPT_LOG_DEBUG("Solution discarded due to variable bounds violation"); @@ -250,5 +251,5 @@ template class presolve_data_t; template class presolve_data_t; #endif -} // namespace linear_programming::detail +} // namespace mathematical_optimization::mip } // namespace cuopt diff --git a/cpp/src/mip_heuristics/problem/presolve_data.cuh b/cpp/src/mip_heuristics/problem/presolve_data.cuh index cac3e71650..5f0b7f53c3 100644 --- a/cpp/src/mip_heuristics/problem/presolve_data.cuh +++ b/cpp/src/mip_heuristics/problem/presolve_data.cuh @@ -7,14 +7,14 @@ #pragma once -#include +#include #include #include #include namespace cuopt { -namespace linear_programming::detail { +namespace mathematical_optimization::mip { template class problem_t; @@ -133,5 +133,5 @@ class presolve_data_t { std::vector> variable_substitutions; }; -} // namespace linear_programming::detail +} // namespace mathematical_optimization::mip } // namespace cuopt diff --git a/cpp/src/mip_heuristics/problem/problem.cu b/cpp/src/mip_heuristics/problem/problem.cu index 70007803d6..770c8c4623 100644 --- a/cpp/src/mip_heuristics/problem/problem.cu +++ b/cpp/src/mip_heuristics/problem/problem.cu @@ -48,7 +48,11 @@ #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { + +using simplex::csr_matrix_t; +using simplex::user_problem_t; +using simplex::variable_type_t; template void problem_t::op_problem_cstr_body(const optimization_problem_t& problem_) @@ -102,7 +106,7 @@ void problem_t::op_problem_cstr_body(const optimization_problem_t(*this, combined_bounds); + pdlp::combine_constraint_bounds(*this, combined_bounds); } template @@ -1223,7 +1227,7 @@ void problem_t::insert_constraints(constraints_delta_t& h_co cuopt_assert(offsets.element(n_constraints, handle_ptr->get_stream()) == nnz, "nnz and offset should match!"); cuopt_assert(offsets.size() == n_constraints + 1, "offset size should match!"); - combine_constraint_bounds(*this, combined_bounds); + pdlp::combine_constraint_bounds(*this, combined_bounds); } // Best rational approximation p/q to x with q <= max_denom, via continued fractions. @@ -1363,7 +1367,7 @@ void problem_t::set_implied_integers(const std::vector& implied_i template void problem_t::recompute_objective_integrality() { - using cuopt::linear_programming::detail::is_integer; + using cuopt::mathematical_optimization::mip::is_integer; objective_is_integral = thrust::all_of(handle_ptr->get_thrust_policy(), @@ -1415,7 +1419,7 @@ void problem_t::recompute_objective_integrality() template void problem_t::compute_objective_step() { - f_t start_time = dual_simplex::tic(); + f_t start_time = simplex::tic(); // Copy info from device to host auto h_obj_coefs = cuopt::host_copy(objective_coefficients, handle_ptr->get_stream()); auto h_var_types = cuopt::host_copy(variable_types, handle_ptr->get_stream()); @@ -1449,7 +1453,7 @@ void problem_t::compute_objective_step() } if (objective_is_integral) { - f_t g = dual_simplex::gcd_of_integer_values(nonzero_coefs); + f_t g = mip::gcd_of_integer_values(nonzero_coefs); if (g > 0) { objective_step.step_size = g; objective_step.bias = 0; @@ -1467,7 +1471,7 @@ void problem_t::compute_objective_step() for (f_t c : nonzero_coefs) { scaled_coefs.push_back(std::round(static_cast(scaling_factor) * c)); } - f_t g = dual_simplex::gcd_of_integer_values(scaled_coefs); + f_t g = mip::gcd_of_integer_values(scaled_coefs); if (g > 0) { f_t sf = static_cast(scaling_factor); objective_step.step_size = g / sf; @@ -1487,7 +1491,7 @@ void problem_t::compute_objective_step() auto h_con_lb = cuopt::host_copy(constraint_lower_bounds, handle_ptr->get_stream()); auto h_con_ub = cuopt::host_copy(constraint_upper_bounds, handle_ptr->get_stream()); - objective_step = dual_simplex::compute_objective_step_info( + objective_step = mip::compute_objective_step_info( h_obj_coefs, is_lattice_known_initially, h_offsets, h_vars, h_coefs, h_con_lb, h_con_ub); } @@ -1804,8 +1808,8 @@ problem_t problem_t::get_problem_after_fixing_vars( cuopt_assert(result_end - variable_map.data() == variable_map.size(), "Size issue in set_difference"); CUOPT_LOG_DEBUG("Fixing assignment hash 0x%x, vars to fix: 0x%x", - detail::compute_hash(assignment, handle_ptr->get_stream()), - detail::compute_hash(variables_to_fix, handle_ptr->get_stream())); + mip::compute_hash(assignment, handle_ptr->get_stream()), + mip::compute_hash(variables_to_fix, handle_ptr->get_stream())); problem.fix_given_variables(*this, assignment, variables_to_fix, handle_ptr); RAFT_CHECK_CUDA(handle_ptr->get_stream()); problem.remove_given_variables(*this, assignment, variable_map, handle_ptr); @@ -1911,7 +1915,7 @@ void problem_t::remove_given_variables(problem_t& original_p variables.resize(nnz, handle_ptr->get_stream()); compute_transpose_of_problem(); compute_auxiliary_data(); - combine_constraint_bounds(*this, combined_bounds); + pdlp::combine_constraint_bounds(*this, combined_bounds); handle_ptr->sync_stream(); recompute_auxilliary_data(); cuopt_func_call(check_problem_representation(true)); @@ -1982,8 +1986,8 @@ void problem_t::fill_integer_fixed_problem(rmm::device_uvector& a cuopt_assert(integer_fixed_problem->n_variables > 0, "Integer fixed problem not computed"); copy_rhs_from_problem(handle_ptr); integer_fixed_problem->fix_given_variables(*this, assignment, integer_indices, handle_ptr); - combine_constraint_bounds(*integer_fixed_problem, - integer_fixed_problem->combined_bounds); + pdlp::combine_constraint_bounds(*integer_fixed_problem, + integer_fixed_problem->combined_bounds); cuopt_func_call(integer_fixed_problem->check_problem_representation(true)); } @@ -2153,7 +2157,7 @@ void problem_t::preprocess_problem() template void problem_t::set_constraints_from_host_user_problem( - const cuopt::linear_programming::dual_simplex::user_problem_t& user_problem) + const user_problem_t& user_problem) { raft::common::nvtx::range fun_scope("set_constraints_from_host_user_problem"); cuopt_assert(user_problem.handle_ptr == handle_ptr, "handle mismatch"); @@ -2165,7 +2169,7 @@ void problem_t::set_constraints_from_host_user_problem( cuopt_assert(user_problem.range_rows.size() == user_problem.range_value.size(), "range rows/value size mismatch"); - dual_simplex::csr_matrix_t csr_A(n_constraints, n_variables, user_problem.A.nnz()); + csr_matrix_t csr_A(n_constraints, n_variables, user_problem.A.nnz()); user_problem.A.to_compressed_row(csr_A); nnz = csr_A.row_start[n_constraints]; empty = (nnz == 0 && n_constraints == 0 && n_variables == 0); @@ -2229,7 +2233,7 @@ void problem_t::set_constraints_from_host_user_problem( compute_transpose_of_problem(); combined_bounds.resize(n_constraints, stream); - combine_constraint_bounds(*this, combined_bounds); + pdlp::combine_constraint_bounds(*this, combined_bounds); } template @@ -2273,8 +2277,7 @@ void problem_t::papilo_uncrush_assignment(rmm::device_uvector& as } template -void problem_t::get_host_user_problem( - cuopt::linear_programming::dual_simplex::user_problem_t& user_problem) const +void problem_t::get_host_user_problem(user_problem_t& user_problem) const { raft::common::nvtx::range fun_scope("get_host_user_problem"); // std::lock_guard lock(problem_mutex); @@ -2286,7 +2289,7 @@ void problem_t::get_host_user_problem( auto stream = handle_ptr->get_stream(); user_problem.objective = cuopt::host_copy(objective_coefficients, stream); - dual_simplex::csr_matrix_t csr_A(m, n, nz); + csr_matrix_t csr_A(m, n, nz); csr_A.x = std::vector(cuopt::host_copy(coefficients, stream)); csr_A.j = std::vector(cuopt::host_copy(variables, stream)); csr_A.row_start = std::vector(cuopt::host_copy(offsets, stream)); @@ -2361,10 +2364,9 @@ void problem_t::get_host_user_problem( auto model_variable_types = cuopt::host_copy(variable_types, stream); for (int j = 0; j < n; ++j) { - user_problem.var_types[j] = - model_variable_types[j] == var_t::CONTINUOUS - ? cuopt::linear_programming::dual_simplex::variable_type_t::CONTINUOUS - : cuopt::linear_programming::dual_simplex::variable_type_t::INTEGER; + user_problem.var_types[j] = model_variable_types[j] == var_t::CONTINUOUS + ? variable_type_t::CONTINUOUS + : variable_type_t::INTEGER; } } @@ -2386,19 +2388,19 @@ uint32_t problem_t::get_fingerprint() const // CSR representation should be unique and sorted at this point auto stream = handle_ptr->get_stream(); - uint32_t h_coeff = detail::compute_hash(coefficients, stream); - uint32_t h_vars = detail::compute_hash(variables, stream); - uint32_t h_offsets = detail::compute_hash(offsets, stream); - uint32_t h_rev_coeff = detail::compute_hash(reverse_coefficients, stream); - uint32_t h_rev_off = detail::compute_hash(reverse_offsets, stream); - uint32_t h_rev_constr = detail::compute_hash(reverse_constraints, stream); - uint32_t h_obj = detail::compute_hash(objective_coefficients, stream); - uint32_t h_varbounds = detail::compute_hash(variable_bounds, stream); - uint32_t h_clb = detail::compute_hash(constraint_lower_bounds, stream); - uint32_t h_cub = detail::compute_hash(constraint_upper_bounds, stream); - uint32_t h_vartypes = detail::compute_hash(variable_types, stream); - uint32_t h_obj_off = detail::compute_hash(presolve_data.objective_offset); - uint32_t h_obj_scale = detail::compute_hash(presolve_data.objective_scaling_factor); + uint32_t h_coeff = mip::compute_hash(coefficients, stream); + uint32_t h_vars = mip::compute_hash(variables, stream); + uint32_t h_offsets = mip::compute_hash(offsets, stream); + uint32_t h_rev_coeff = mip::compute_hash(reverse_coefficients, stream); + uint32_t h_rev_off = mip::compute_hash(reverse_offsets, stream); + uint32_t h_rev_constr = mip::compute_hash(reverse_constraints, stream); + uint32_t h_obj = mip::compute_hash(objective_coefficients, stream); + uint32_t h_varbounds = mip::compute_hash(variable_bounds, stream); + uint32_t h_clb = mip::compute_hash(constraint_lower_bounds, stream); + uint32_t h_cub = mip::compute_hash(constraint_upper_bounds, stream); + uint32_t h_vartypes = mip::compute_hash(variable_types, stream); + uint32_t h_obj_off = cuopt::compute_hash(presolve_data.objective_offset); + uint32_t h_obj_scale = cuopt::compute_hash(presolve_data.objective_scaling_factor); std::vector hashes = { h_coeff, @@ -2415,7 +2417,7 @@ uint32_t problem_t::get_fingerprint() const h_obj_off, h_obj_scale, }; - return detail::compute_hash(hashes); + return cuopt::compute_hash(hashes); } template @@ -2496,4 +2498,4 @@ template class problem_t; template class problem_t; #endif -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/problem/problem.cuh b/cpp/src/mip_heuristics/problem/problem.cuh index bcc0454b24..5e84514cf6 100644 --- a/cpp/src/mip_heuristics/problem/problem.cuh +++ b/cpp/src/mip_heuristics/problem/problem.cuh @@ -16,10 +16,10 @@ #include #include -#include -#include -#include -#include +#include +#include +#include +#include #include "host_helper.cuh" #include "problem_fixing.cuh" @@ -37,7 +37,7 @@ namespace cuopt { -namespace linear_programming::detail { +namespace mathematical_optimization::mip { template struct clique_table_t; @@ -123,7 +123,7 @@ class problem_t { f_t get_user_obj_from_solver_obj(f_t solver_obj) const; f_t get_solver_obj_from_user_obj(f_t user_obj) const; bool is_objective_integral() const { return objective_is_integral; } - const cuopt::linear_programming::dual_simplex::objective_step_t& get_objective_step() const + const cuopt::mathematical_optimization::simplex::objective_step_t& get_objective_step() const { return objective_step; } @@ -139,9 +139,9 @@ class problem_t { std::shared_ptr> clique_table; void get_host_user_problem( - cuopt::linear_programming::dual_simplex::user_problem_t& user_problem) const; + cuopt::mathematical_optimization::simplex::user_problem_t& user_problem) const; void set_constraints_from_host_user_problem( - const cuopt::linear_programming::dual_simplex::user_problem_t& user_problem); + const cuopt::mathematical_optimization::simplex::user_problem_t& user_problem); uint32_t get_fingerprint() const; @@ -329,7 +329,7 @@ class problem_t { bool is_scaled_{false}; bool preprocess_called{false}; bool objective_is_integral{false}; - cuopt::linear_programming::dual_simplex::objective_step_t objective_step; + cuopt::mathematical_optimization::simplex::objective_step_t objective_step; // this LP state keeps the warm start data of some solution of // 1. Original problem: it is unchanged and part of it is used // to warm start slightly modified problems. @@ -346,5 +346,5 @@ class problem_t { std::vector Q_values; }; -} // namespace linear_programming::detail +} // namespace mathematical_optimization::mip } // namespace cuopt diff --git a/cpp/src/mip_heuristics/problem/problem_fixing.cuh b/cpp/src/mip_heuristics/problem/problem_fixing.cuh index 820b74e329..734822e265 100644 --- a/cpp/src/mip_heuristics/problem/problem_fixing.cuh +++ b/cpp/src/mip_heuristics/problem/problem_fixing.cuh @@ -1,6 +1,6 @@ /* clang-format off */ /* - * SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. * SPDX-License-Identifier: Apache-2.0 */ /* clang-format on */ @@ -10,7 +10,7 @@ #include namespace cuopt { -namespace linear_programming::detail { +namespace mathematical_optimization::mip { template struct problem_fixing_helpers_t { @@ -30,5 +30,5 @@ struct problem_fixing_helpers_t { rmm::device_uvector variable_fix_mask; }; -} // namespace linear_programming::detail +} // namespace mathematical_optimization::mip } // namespace cuopt diff --git a/cpp/src/mip_heuristics/problem/problem_helpers.cuh b/cpp/src/mip_heuristics/problem/problem_helpers.cuh index 77cc973aa0..c5a60b1bf7 100644 --- a/cpp/src/mip_heuristics/problem/problem_helpers.cuh +++ b/cpp/src/mip_heuristics/problem/problem_helpers.cuh @@ -24,7 +24,7 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template struct transform_bounds_functor { __device__ thrust::tuple operator()(const thrust::tuple& input) const @@ -53,7 +53,7 @@ struct transform_bounds_functor { }; template -static void set_variable_bounds(detail::problem_t& op_problem) +static void set_variable_bounds(mip::problem_t& op_problem) { op_problem.variable_bounds.resize(op_problem.n_variables, op_problem.handle_ptr->get_stream()); auto vars_bnd = make_span(op_problem.variable_bounds); @@ -83,7 +83,7 @@ static void set_variable_bounds(detail::problem_t& op_problem) } template -static void set_bounds_if_not_set(detail::problem_t& op_problem) +static void set_bounds_if_not_set(mip::problem_t& op_problem) { raft::common::nvtx::range scope("set_bounds_if_not_set"); @@ -132,7 +132,7 @@ struct negate { }; template -static void convert_to_maximization_problem(detail::problem_t& op_problem) +static void convert_to_maximization_problem(mip::problem_t& op_problem) { raft::common::nvtx::range scope("convert_to_maximization_problem"); @@ -141,7 +141,7 @@ static void convert_to_maximization_problem(detail::problem_t& op_prob raft::linalg::unaryOp(op_problem.objective_coefficients.data(), op_problem.objective_coefficients.data(), op_problem.objective_coefficients.size(), - detail::negate(), + mip::negate(), op_problem.handle_ptr->get_stream()); } // Negate objective scaling factor and objective offset so that primal / dual stay same sign after @@ -264,7 +264,7 @@ static void check_csr_representation([[maybe_unused]] const rmm::device_uvector< } template -static bool check_var_bounds_sanity(const detail::problem_t& problem) +static bool check_var_bounds_sanity(const mip::problem_t& problem) { bool crossing_bounds_detected = thrust::any_of(problem.handle_ptr->get_thrust_policy(), @@ -279,7 +279,7 @@ static bool check_var_bounds_sanity(const detail::problem_t& problem) } template -static bool check_constraint_bounds_sanity(const detail::problem_t& problem) +static bool check_constraint_bounds_sanity(const mip::problem_t& problem) { bool crossing_bounds_detected = thrust::any_of(problem.handle_ptr->get_thrust_policy(), @@ -294,7 +294,7 @@ static bool check_constraint_bounds_sanity(const detail::problem_t& pr } template -static void round_bounds(detail::problem_t& problem) +static void round_bounds(mip::problem_t& problem) { // round bounds to integer for integer variables thrust::for_each(problem.handle_ptr->get_thrust_policy(), @@ -311,7 +311,7 @@ static void round_bounds(detail::problem_t& problem) } template -static bool check_bounds_sanity(const detail::problem_t& problem) +static bool check_bounds_sanity(const mip::problem_t& problem) { return check_var_bounds_sanity(problem) && check_constraint_bounds_sanity(problem); @@ -402,7 +402,7 @@ static void csrsort_cusparse(rmm::device_uvector& values, } template -static void convert_greater_to_less(detail::problem_t& problem) +static void convert_greater_to_less(mip::problem_t& problem) { raft::common::nvtx::range scope("convert_greater_to_less"); @@ -424,4 +424,4 @@ static void convert_greater_to_less(detail::problem_t& problem) handle_ptr->sync_stream(); } -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/problem/problem_kernels.cuh b/cpp/src/mip_heuristics/problem/problem_kernels.cuh index 249b073724..f7578a275a 100644 --- a/cpp/src/mip_heuristics/problem/problem_kernels.cuh +++ b/cpp/src/mip_heuristics/problem/problem_kernels.cuh @@ -1,6 +1,6 @@ /* clang-format off */ /* - * SPDX-FileCopyrightText: Copyright (c) 2024-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-FileCopyrightText: Copyright (c) 2024-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. * SPDX-License-Identifier: Apache-2.0 */ /* clang-format on */ @@ -11,7 +11,7 @@ #include "problem.cuh" -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template __global__ void compute_new_offsets(const typename problem_t::view_t orig_problem, @@ -77,4 +77,4 @@ __global__ void compute_related_vars_unique(const typename problem_t:: } } -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/problem/write_mps.cu b/cpp/src/mip_heuristics/problem/write_mps.cu index 55d96c07e0..483b45a211 100644 --- a/cpp/src/mip_heuristics/problem/write_mps.cu +++ b/cpp/src/mip_heuristics/problem/write_mps.cu @@ -16,7 +16,7 @@ #include "utilities/copy_helpers.hpp" -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template void problem_t::write_as_mps(const std::string& path) @@ -162,4 +162,4 @@ template void problem_t::write_as_mps(const std::string& path); template void problem_t::write_as_mps(const std::string& path); #endif -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/relaxed_lp/lp_state.cuh b/cpp/src/mip_heuristics/relaxed_lp/lp_state.cuh index 3820758dc0..6c9191ad3b 100644 --- a/cpp/src/mip_heuristics/relaxed_lp/lp_state.cuh +++ b/cpp/src/mip_heuristics/relaxed_lp/lp_state.cuh @@ -11,7 +11,7 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template class problem_t; @@ -68,4 +68,4 @@ class lp_state_t { rmm::device_uvector prev_dual; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/relaxed_lp/relaxed_lp.cu b/cpp/src/mip_heuristics/relaxed_lp/relaxed_lp.cu index 84415f5372..14a56cb903 100644 --- a/cpp/src/mip_heuristics/relaxed_lp/relaxed_lp.cu +++ b/cpp/src/mip_heuristics/relaxed_lp/relaxed_lp.cu @@ -20,7 +20,7 @@ #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template optimization_problem_solution_t get_relaxed_lp_solution( @@ -55,7 +55,7 @@ optimization_problem_solution_t get_relaxed_lp_solution( pdlp_settings.presolver = presolver_t::None; set_pdlp_solver_mode(pdlp_settings); // TODO: set Stable3 here? - pdlp_solver_t lp_solver(op_problem, pdlp_settings); + pdlp::pdlp_solver_t lp_solver(op_problem, pdlp_settings); if (settings.has_initial_primal) { i_t prev_size = lp_state.prev_dual.size(); CUOPT_LOG_DEBUG( @@ -228,4 +228,4 @@ INSTANTIATE(double) #undef INSTANTIATE -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/relaxed_lp/relaxed_lp.cuh b/cpp/src/mip_heuristics/relaxed_lp/relaxed_lp.cuh index 9fe5fb9071..e13cc04aa8 100644 --- a/cpp/src/mip_heuristics/relaxed_lp/relaxed_lp.cuh +++ b/cpp/src/mip_heuristics/relaxed_lp/relaxed_lp.cuh @@ -7,14 +7,14 @@ #pragma once -#include -#include +#include +#include #include #include #include #include "lp_state.cuh" -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { struct relaxed_lp_settings_t { double tolerance = 1e-4; @@ -49,4 +49,4 @@ bool run_lp_with_vars_fixed(problem_t& op_problem, bool check_fixed_assignment_feasibility = false, bool use_integer_fixed_problem = false); -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/solution/feasibility_test.cuh b/cpp/src/mip_heuristics/solution/feasibility_test.cuh index 0fc7a3d119..140603c763 100644 --- a/cpp/src/mip_heuristics/solution/feasibility_test.cuh +++ b/cpp/src/mip_heuristics/solution/feasibility_test.cuh @@ -11,7 +11,7 @@ #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template __global__ void test_feasibility_kernel(typename solution_t::view_t sol) @@ -100,4 +100,4 @@ void solution_t::test_variable_bounds(bool check_integer, i_t* is_feas RAFT_CHECK_CUDA(handle_ptr->get_stream()); } -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/solution/solution.cu b/cpp/src/mip_heuristics/solution/solution.cu index 2a05a1ca56..3b00fca7a8 100644 --- a/cpp/src/mip_heuristics/solution/solution.cu +++ b/cpp/src/mip_heuristics/solution/solution.cu @@ -24,7 +24,7 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template rmm::device_uvector get_lower_bounds( @@ -318,7 +318,7 @@ f_t solution_t::compute_l2_residual() handle_ptr->get_cublas_handle(), CUBLAS_POINTER_MODE_DEVICE, handle_ptr->get_stream())); RAFT_CUSPARSE_TRY(raft::sparse::detail::cusparsesetpointermode( handle_ptr->get_cusparse_handle(), CUSPARSE_POINTER_MODE_DEVICE, handle_ptr->get_stream())); - my_l2_norm(combined_excess, l2_residual, handle_ptr); + pdlp::my_l2_norm(combined_excess, l2_residual, handle_ptr); return l2_residual.value(handle_ptr->get_stream()); } @@ -599,9 +599,8 @@ f_t solution_t::compute_max_variable_violation() // returns the solution after applying the conversions template -mip_solution_t solution_t::get_solution(bool output_feasible, - solver_stats_t stats, - bool log_stats) +cuopt::mathematical_optimization::mip_solution_t solution_t::get_solution( + bool output_feasible, solver_stats_t stats, bool log_stats) { cuopt::default_logger().flush(); cuopt_expects( @@ -624,22 +623,24 @@ mip_solution_t solution_t::get_solution(bool output_feasible auto term_reason = not_optimal ? mip_termination_status_t::FeasibleFound : mip_termination_status_t::Optimal; if (is_problem_fully_reduced) { term_reason = mip_termination_status_t::Optimal; } - auto sol = mip_solution_t(std::move(assignment), - problem_ptr->var_names, - h_user_obj, - rel_mip_gap, - term_reason, - max_constraint_violation, - max_int_violation, - max_variable_bound_violation, - stats); + auto sol = + cuopt::mathematical_optimization::mip_solution_t(std::move(assignment), + problem_ptr->var_names, + h_user_obj, + rel_mip_gap, + term_reason, + max_constraint_violation, + max_int_violation, + max_variable_bound_violation, + stats); if (log_stats) { sol.log_detailed_summary(); } return sol; } else { - return mip_solution_t{is_problem_fully_reduced ? mip_termination_status_t::Infeasible - : mip_termination_status_t::TimeLimit, - stats, - handle_ptr->get_stream()}; + return cuopt::mathematical_optimization::mip_solution_t{ + is_problem_fully_reduced ? mip_termination_status_t::Infeasible + : mip_termination_status_t::TimeLimit, + stats, + handle_ptr->get_stream()}; } } @@ -651,4 +652,4 @@ template class solution_t; template class solution_t; #endif -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/solution/solution.cuh b/cpp/src/mip_heuristics/solution/solution.cuh index 9de10ed980..f243937d3e 100644 --- a/cpp/src/mip_heuristics/solution/solution.cuh +++ b/cpp/src/mip_heuristics/solution/solution.cuh @@ -7,9 +7,9 @@ #pragma once -#include -#include -#include +#include +#include +#include #include #include #include @@ -19,7 +19,7 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template class solution_t { @@ -93,9 +93,8 @@ class solution_t { f_t get_total_excess(); // brings all vars within bounds void clamp_within_bounds(); - mip_solution_t get_solution(bool output_feasible, - solver_stats_t stats, - bool log_stats = true); + cuopt::mathematical_optimization::mip_solution_t get_solution( + bool output_feasible, solver_stats_t stats, bool log_stats = true); f_t compute_max_constraint_violation(); f_t compute_max_int_violation(); f_t compute_max_variable_violation(); @@ -154,4 +153,4 @@ class solution_t { void test_variable_bounds(bool check_integer = true, i_t* is_feasible = nullptr); }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/solution/solution_kernels.cuh b/cpp/src/mip_heuristics/solution/solution_kernels.cuh index 1383569bcd..e0625ee530 100644 --- a/cpp/src/mip_heuristics/solution/solution_kernels.cuh +++ b/cpp/src/mip_heuristics/solution/solution_kernels.cuh @@ -1,6 +1,6 @@ /* clang-format off */ /* - * SPDX-FileCopyrightText: Copyright (c) 2024-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-FileCopyrightText: Copyright (c) 2024-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. * SPDX-License-Identifier: Apache-2.0 */ /* clang-format on */ @@ -11,7 +11,7 @@ #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template __global__ void compute_constraint_values(typename solution_t::view_t sol) @@ -58,4 +58,4 @@ __global__ void compute_feasibility_kernel( } } -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/solve.cu b/cpp/src/mip_heuristics/solve.cu index ef474e7c12..891c7c3a8b 100644 --- a/cpp/src/mip_heuristics/solve.cu +++ b/cpp/src/mip_heuristics/solve.cu @@ -6,7 +6,7 @@ /* clang-format on */ #include -#include +#include #include #include @@ -29,15 +29,15 @@ #include #include -#include -#include -#include -#include -#include -#include -#include -#include -#include +#include +#include +#include +#include +#include +#include +#include +#include +#include #include #include @@ -50,7 +50,7 @@ // Presolve runs at full power; symmetry detection on whatever structure remains. #define DETECT_SYMMETRY_AFTER_PRESOLVE -#include +#include #include #include @@ -65,7 +65,10 @@ #include #include -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { + +using simplex::simplex_solver_settings_t; +using simplex::user_problem_t; // This serves as both a warm up but also a mandatory initial call to setup cuSparse and cuBLAS static void init_handler(const raft::handle_t* handle_ptr) @@ -87,8 +90,8 @@ static void invoke_solution_callbacks( f_t bound) { if (strip_semi_continuous_auxiliaries) { - detail::strip_semi_continuous_auxiliaries_from_assignment( - assignment, semi_continuous_original_num_variables); + mip::strip_semi_continuous_auxiliaries_from_assignment(assignment, + semi_continuous_original_num_variables); } std::vector obj_vec = {objective}; std::vector bound_vec = {bound}; @@ -104,26 +107,26 @@ static void invoke_solution_callbacks( template mip_solution_t run_mip_solver( - detail::problem_t& problem, + mip::problem_t& problem, mip_solver_settings_t const& settings, timer_t& timer, f_t& initial_upper_bound, std::vector& initial_incumbent_assignment, - std::unique_ptr> symmetry = nullptr) + std::unique_ptr> symmetry = nullptr) { try { raft::common::nvtx::range fun_scope("run_mip"); if (settings.get_mip_callbacks().size() > 0) { auto callback_num_variables = problem.original_problem_ptr->get_n_variables(); const bool has_semi_continuous_callback_translation = - detail::mip_solver_settings_accessor::has_semi_continuous_callback_translation( - settings); + mip_solver_settings_accessor::has_semi_continuous_callback_translation(settings); if (problem.has_papilo_presolve_data()) { callback_num_variables = problem.get_papilo_original_num_variables(); } if (has_semi_continuous_callback_translation) { - callback_num_variables = detail::mip_solver_settings_accessor:: - get_semi_continuous_original_num_variables(settings); + callback_num_variables = + mip_solver_settings_accessor::get_semi_continuous_original_num_variables( + settings); } for (auto callback : settings.get_mip_callbacks()) { callback->template setup(callback_num_variables); @@ -131,7 +134,7 @@ mip_solution_t run_mip_solver( } // if the input problem is empty: early exit if (problem.empty) { - detail::solution_t solution(problem); + mip::solution_t solution(problem); problem.preprocess_problem(); thrust::for_each( problem.handle_ptr->get_thrust_policy(), @@ -164,12 +167,12 @@ mip_solution_t run_mip_solver( temp_sol.assignment.size(), temp_sol.handle_ptr->get_stream()); solution.handle_ptr->sync_stream(); - if (detail::mip_solver_settings_accessor:: - has_semi_continuous_callback_translation(settings)) { - detail::strip_semi_continuous_auxiliaries_from_assignment( + if (mip_solver_settings_accessor::has_semi_continuous_callback_translation( + settings)) { + mip::strip_semi_continuous_auxiliaries_from_assignment( user_assignment_vec, - detail::mip_solver_settings_accessor:: - get_semi_continuous_original_num_variables(settings)); + mip_solver_settings_accessor::get_semi_continuous_original_num_variables( + settings)); } get_sol_callback->get_solution(user_assignment_vec.data(), user_objective_vec.data(), @@ -180,7 +183,7 @@ mip_solution_t run_mip_solver( return solution.get_solution(true, stats, false); } // problem contains unpreprocessed data - detail::problem_t scaled_problem(problem); + mip::problem_t scaled_problem(problem); cuopt_func_call(auto saved_problem = scaled_problem); CUOPT_LOG_INFO("Objective offset %f scaling_factor %f", problem.presolve_data.objective_offset, @@ -194,7 +197,7 @@ mip_solution_t run_mip_solver( scaled_problem.preprocess_problem(); scaled_problem.related_vars_time_limit = settings.heuristic_params.related_vars_time_limit; const i_t n_vars_before = scaled_problem.n_variables; - detail::trivial_presolve(scaled_problem); + mip::trivial_presolve(scaled_problem); #ifdef DETECT_SYMMETRY_BEFORE_PRESOLVE // Trivial presolve may remove unused variables and renumber the remaining ones. @@ -209,15 +212,14 @@ mip_solution_t run_mip_solver( scaled_problem.n_variables); symmetry.reset(); if (settings.symmetry != 0) { - dual_simplex::simplex_solver_settings_t simplex_settings; + simplex_solver_settings_t simplex_settings; simplex_settings.set_log(true); - simplex_settings.time_limit = settings.time_limit; - dual_simplex::user_problem_t reduced_user_problem = - cuopt_problem_to_user_problem( - scaled_problem.original_problem_ptr->get_handle_ptr(), scaled_problem); + simplex_settings.time_limit = settings.time_limit; + user_problem_t reduced_user_problem = cuopt_problem_to_user_problem( + scaled_problem.original_problem_ptr->get_handle_ptr(), scaled_problem); bool has_symmetry_reduced = false; - symmetry = dual_simplex::detect_symmetry( - reduced_user_problem, simplex_settings, has_symmetry_reduced); + symmetry = + mip::detect_symmetry(reduced_user_problem, simplex_settings, has_symmetry_reduced); } } #endif @@ -225,7 +227,7 @@ mip_solution_t run_mip_solver( // Note: DETECT_SYMMETRY_AFTER_PRESOLVE detection is done in solver.cu::run_solver() // after cuOpt's presolve (probing cache, bounds propagation, trivial presolve) completes. - detail::mip_solver_t solver(scaled_problem, settings, timer); + mip::mip_solver_t solver(scaled_problem, settings, timer); // initial_upper_bound is in user-space (representation-invariant). // It will be converted to the target solver-space at each consumption point. solver.context.initial_upper_bound = initial_upper_bound; @@ -233,7 +235,7 @@ mip_solution_t run_mip_solver( solver.context.symmetry = std::move(symmetry); if (timer.check_time_limit()) { CUOPT_LOG_INFO("Time limit reached before main solve"); - detail::solution_t sol(problem); + mip::solution_t sol(problem); auto stats = solver.get_solver_stats(); stats.total_solve_time = timer.elapsed_time(); sol.post_process_completed = true; @@ -246,7 +248,7 @@ mip_solution_t run_mip_solver( // optimization_problem_t). Its solver-space differs from both the first-pass FJ (original // problem) and B&B (post-trivial- presolve), so initial_upper_bound (user-space) is converted // via problem.get_solver_obj_from_user_obj. - std::unique_ptr> early_cpufj; + std::unique_ptr> early_cpufj; bool run_early_cpufj = problem.has_papilo_presolve_data() && settings.determinism_mode != CUOPT_MODE_DETERMINISTIC && problem.original_problem_ptr->get_n_integers() > 0; @@ -260,10 +262,11 @@ mip_solution_t run_mip_solver( mip_callbacks, no_bound, has_semi_continuous_callback_translation = - detail::mip_solver_settings_accessor::has_semi_continuous_callback_translation( + mip_solver_settings_accessor::has_semi_continuous_callback_translation( + settings), + semi_continuous_original_num_variables = + mip_solver_settings_accessor::get_semi_continuous_original_num_variables( settings), - semi_continuous_original_num_variables = detail::mip_solver_settings_accessor:: - get_semi_continuous_original_num_variables(settings), ctx_ptr = &solver.context, early_fj_start](f_t solver_obj, f_t user_obj, @@ -288,7 +291,7 @@ mip_solution_t run_mip_solver( user_assignment, no_bound); }; - early_cpufj = std::make_unique>( + early_cpufj = std::make_unique>( *problem.original_problem_ptr, settings.get_tolerances(), incumbent_callback); // Convert initial_upper_bound from user-space to the CPUFJ's solver-space (papilo-presolved). // problem.get_solver_obj_from_user_obj uses the papilo offset/scale (matching the CPUFJ). @@ -322,7 +325,7 @@ mip_solution_t run_mip_solver( int hidesol = std::getenv("CUOPT_MIP_HIDE_SOLUTION") ? atoi(std::getenv("CUOPT_MIP_HIDE_SOLUTION")) : 0; - if (!hidesol) { detail::print_solution(scaled_problem.handle_ptr, sol.get_solution()); } + if (!hidesol) { mip::print_solution(scaled_problem.handle_ptr, sol.get_solution()); } return sol; } catch (const std::exception& e) { CUOPT_LOG_ERROR("Unexpected error in run_mip: %s", e.what()); @@ -391,16 +394,15 @@ mip_solution_t solve_mip_helper(optimization_problem_t& op_p const auto original_variable_names = op_problem.get_variable_names(); std::vector sc_used_fallback_big_m; std::vector semi_continuous_binary_to_original_indices; - const bool has_semi_continuous = detail::reformulate_semi_continuous( + const bool has_semi_continuous = mip::reformulate_semi_continuous( op_problem, settings, &sc_used_fallback_big_m, &semi_continuous_binary_to_original_indices); if (has_semi_continuous && !settings.initial_solutions.empty()) { - detail::expand_initial_solutions_for_semi_continuous( - settings, - semi_continuous_binary_to_original_indices, - op_problem.get_handle_ptr()->get_stream()); + mip::expand_initial_solutions_for_semi_continuous(settings, + semi_continuous_binary_to_original_indices, + op_problem.get_handle_ptr()->get_stream()); } if (has_semi_continuous) { - detail::mip_solver_settings_accessor::set_semi_continuous_callback_translation( + mip_solver_settings_accessor::set_semi_continuous_callback_translation( settings, n_orig_before_sc, semi_continuous_binary_to_original_indices); } @@ -415,39 +417,40 @@ mip_solution_t solve_mip_helper(optimization_problem_t& op_p for (auto callback : settings.get_mip_callbacks()) { auto callback_num_variables = op_problem.get_n_variables(); - if (detail::mip_solver_settings_accessor::has_semi_continuous_callback_translation( + if (mip_solver_settings_accessor::has_semi_continuous_callback_translation( settings)) { - callback_num_variables = detail::mip_solver_settings_accessor:: - get_semi_continuous_original_num_variables(settings); + callback_num_variables = + mip_solver_settings_accessor::get_semi_continuous_original_num_variables( + settings); } callback->template setup(callback_num_variables); } // Start symmetry detection - std::unique_ptr> symmetry; + std::unique_ptr> symmetry; #ifdef DETECT_SYMMETRY_BEFORE_PRESOLVE bool has_symmetry = false; if (settings.symmetry != 0) { - detail::problem_t problem(op_problem); - dual_simplex::simplex_solver_settings_t simplex_settings; + mip::problem_t problem(op_problem); + simplex_solver_settings_t simplex_settings; simplex_settings.set_log(true); simplex_settings.time_limit = settings.time_limit; - dual_simplex::user_problem_t user_problem = + user_problem_t user_problem = cuopt_problem_to_user_problem(op_problem.get_handle_ptr(), problem); - symmetry = dual_simplex::detect_symmetry(user_problem, simplex_settings, has_symmetry); + symmetry = mip::detect_symmetry(user_problem, simplex_settings, has_symmetry); if (has_symmetry) { settings.presolver = presolver_t::None; } } #endif if (settings.mip_scaling != CUOPT_MIP_SCALING_OFF) { - detail::mip_scaling_strategy_t scaling(op_problem); + mip::mip_scaling_strategy_t scaling(op_problem); scaling.scale_problem(settings.mip_scaling != CUOPT_MIP_SCALING_NO_OBJECTIVE); } double presolve_time = 0.0; - std::unique_ptr> presolver; - std::optional> presolve_result_opt; - detail::problem_t problem( + std::unique_ptr> presolver; + std::optional> presolve_result_opt; + mip::problem_t problem( op_problem, settings.get_tolerances(), settings.determinism_mode == CUOPT_MODE_DETERMINISTIC); auto run_presolve = settings.presolver != presolver_t::None; @@ -481,8 +484,8 @@ mip_solution_t solve_mip_helper(optimization_problem_t& op_p std::vector early_best_user_assignment; std::mutex early_callback_mutex; - std::unique_ptr> early_cpufj; - std::unique_ptr> early_gpufj; + std::unique_ptr> early_cpufj; + std::unique_ptr> early_gpufj; bool run_early_fj = run_presolve && settings.determinism_mode != CUOPT_MODE_DETERMINISTIC && op_problem.get_n_integers() > 0 && op_problem.get_n_constraints() > 0; @@ -497,10 +500,11 @@ mip_solution_t solve_mip_helper(optimization_problem_t& op_p early_fj_start, mip_callbacks = settings.get_mip_callbacks(), has_semi_continuous_callback_translation = - detail::mip_solver_settings_accessor::has_semi_continuous_callback_translation( + mip_solver_settings_accessor::has_semi_continuous_callback_translation( + settings), + semi_continuous_original_num_variables = + mip_solver_settings_accessor::get_semi_continuous_original_num_variables( settings), - semi_continuous_original_num_variables = detail::mip_solver_settings_accessor:: - get_semi_continuous_original_num_variables(settings), no_bound](f_t solver_obj, f_t user_obj, const std::vector& assignment, @@ -528,21 +532,21 @@ mip_solution_t solve_mip_helper(optimization_problem_t& op_p }; // Start early CPUFJ on original problem (will restart on presolved problem after Papilo) - early_cpufj = std::make_unique>( + early_cpufj = std::make_unique>( op_problem, settings.get_tolerances(), early_fj_callback); early_cpufj->start(); CUOPT_LOG_DEBUG("Started early CPUFJ on original problem"); // Start early GPU FJ (uses GPU while CPU is busy with Papilo) early_gpufj = - std::make_unique>(op_problem, settings, early_fj_callback); + std::make_unique>(op_problem, settings, early_fj_callback); early_gpufj->start(); CUOPT_LOG_DEBUG("Started early GPUFJ during presolve"); } auto constexpr const dual_postsolve = false; if (run_presolve) { - detail::sort_csr(op_problem); + mip::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 auto& hp = settings.heuristic_params; @@ -551,9 +555,9 @@ mip_solution_t solve_mip_helper(optimization_problem_t& op_p if (settings.determinism_mode == CUOPT_MODE_DETERMINISTIC) { presolve_time_limit = std::numeric_limits::infinity(); } - presolver = std::make_unique>(); + presolver = std::make_unique>(); auto result = presolver->apply(op_problem, - cuopt::linear_programming::problem_category_t::MIP, + cuopt::mathematical_optimization::problem_category_t::MIP, settings.presolver, dual_postsolve, settings.tolerances.absolute_tolerance, @@ -561,24 +565,24 @@ mip_solution_t solve_mip_helper(optimization_problem_t& op_p presolve_time_limit, settings.num_cpu_threads); - if (result.status == detail::third_party_presolve_status_t::INFEASIBLE) { + if (result.status == mip::third_party_presolve_status_t::INFEASIBLE) { return mip_solution_t(mip_termination_status_t::Infeasible, solver_stats_t{}, op_problem.get_handle_ptr()->get_stream()); } - if (result.status == detail::third_party_presolve_status_t::UNBNDORINFEAS) { + if (result.status == mip::third_party_presolve_status_t::UNBNDORINFEAS) { return mip_solution_t(mip_termination_status_t::UnboundedOrInfeasible, solver_stats_t{}, op_problem.get_handle_ptr()->get_stream()); } - if (result.status == detail::third_party_presolve_status_t::UNBOUNDED) { + if (result.status == mip::third_party_presolve_status_t::UNBOUNDED) { return mip_solution_t(mip_termination_status_t::Unbounded, solver_stats_t{}, op_problem.get_handle_ptr()->get_stream()); } presolve_result_opt.emplace(std::move(result)); - problem = detail::problem_t(presolve_result_opt->reduced_problem); + problem = mip::problem_t(presolve_result_opt->reduced_problem); problem.set_papilo_presolve_data(presolver.get(), presolve_result_opt->reduced_to_original_map, presolve_result_opt->original_to_reduced_map, @@ -642,7 +646,7 @@ mip_solution_t solve_mip_helper(optimization_problem_t& op_p presolver->undo(primal_solution, dual_solution, reduced_costs, - cuopt::linear_programming::problem_category_t::MIP, + cuopt::mathematical_optimization::problem_category_t::MIP, status_to_skip, dual_postsolve, op_problem.get_handle_ptr()->get_stream()); @@ -655,8 +659,8 @@ mip_solution_t solve_mip_helper(optimization_problem_t& op_p reduced_costs.data(), reduced_costs.data() + reduced_costs.size(), std::numeric_limits::signaling_NaN()); - detail::problem_t full_problem(op_problem); - detail::solution_t full_sol(full_problem); + mip::problem_t full_problem(op_problem); + mip::solution_t full_sol(full_problem); full_sol.copy_new_assignment( cuopt::host_copy(primal_solution, op_problem.get_handle_ptr()->get_stream())); full_sol.compute_feasibility(); @@ -686,8 +690,8 @@ mip_solution_t solve_mip_helper(optimization_problem_t& op_p !sol_has_incumbent || (is_maximization ? early_best_user_obj > sol.get_objective_value() : early_best_user_obj < sol.get_objective_value()); if (early_heuristic_is_better) { - detail::problem_t full_problem(op_problem); - detail::solution_t fallback_sol(full_problem); + mip::problem_t full_problem(op_problem); + mip::solution_t fallback_sol(full_problem); fallback_sol.copy_new_assignment(early_best_user_assignment); fallback_sol.compute_feasibility(); if (fallback_sol.get_feasible()) { @@ -909,20 +913,20 @@ std::unique_ptr> solve_mip( } } -#define INSTANTIATE(F_TYPE) \ - template mip_solution_t solve_mip( \ - optimization_problem_t& op_problem, \ - mip_solver_settings_t const& settings); \ - \ - template mip_solution_t solve_mip( \ - raft::handle_t const* handle_ptr, \ - const cuopt::linear_programming::io::mps_data_model_t& mps_data_model, \ - mip_solver_settings_t const& settings); \ - \ - template std::unique_ptr> solve_mip( \ - cpu_optimization_problem_t&, mip_solver_settings_t const&); \ - \ - template std::unique_ptr> solve_mip( \ +#define INSTANTIATE(F_TYPE) \ + template mip_solution_t solve_mip( \ + optimization_problem_t& op_problem, \ + mip_solver_settings_t const& settings); \ + \ + template mip_solution_t solve_mip( \ + raft::handle_t const* handle_ptr, \ + const cuopt::mathematical_optimization::io::mps_data_model_t& mps_data_model, \ + mip_solver_settings_t const& settings); \ + \ + template std::unique_ptr> solve_mip( \ + cpu_optimization_problem_t&, mip_solver_settings_t const&); \ + \ + template std::unique_ptr> solve_mip( \ optimization_problem_interface_t*, mip_solver_settings_t const&); #if MIP_INSTANTIATE_FLOAT @@ -933,4 +937,4 @@ INSTANTIATE(float) INSTANTIATE(double) #endif -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/mip_heuristics/solver.cu b/cpp/src/mip_heuristics/solver.cu index 858e865bc3..0ede00964a 100644 --- a/cpp/src/mip_heuristics/solver.cu +++ b/cpp/src/mip_heuristics/solver.cu @@ -33,7 +33,10 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { + +using simplex::simplex_solver_settings_t; +using simplex::user_problem_t; // This serves as both a warm up but also a mandatory initial call to setup cuSparse and cuBLAS static void init_handler(const raft::handle_t* handle_ptr) @@ -60,7 +63,7 @@ mip_solver_t::mip_solver_t(const problem_t& op_problem, template struct branch_and_bound_solution_helper_t { branch_and_bound_solution_helper_t(diversity_manager_t* dm, - dual_simplex::simplex_solver_settings_t& settings) + simplex_solver_settings_t& settings) : dm(dm), settings_(settings) {}; void solution_callback(std::vector& solution, f_t objective) @@ -83,21 +86,20 @@ struct branch_and_bound_solution_helper_t { void preempt_heuristic_solver() { dm->population.preempt_heuristic_solver(); } diversity_manager_t* dm; - dual_simplex::simplex_solver_settings_t& settings_; + simplex_solver_settings_t& settings_; }; // Extract probing cache into CPU-only CSR struct for implied bounds cuts template -void extract_probing_implied_bounds( - const problem_t& op_problem, - const dual_simplex::user_problem_t& branch_and_bound_problem, - const probing_cache_t& probing_cache, - dual_simplex::probing_implied_bound_t& probing_implied_bound) +void extract_probing_implied_bounds(const problem_t& op_problem, + const user_problem_t& branch_and_bound_problem, + const probing_cache_t& probing_cache, + mip::probing_implied_bound_t& probing_implied_bound) { auto& pc = probing_cache.probing_cache; const i_t num_cols = branch_and_bound_problem.num_cols; - probing_implied_bound = dual_simplex::probing_implied_bound_t(num_cols); + probing_implied_bound = mip::probing_implied_bound_t(num_cols); // First pass: count entries per binary variable // Probing cache indices are in pre-trivial-presolve space; remap to post-presolve (B&B) space @@ -296,21 +298,20 @@ solution_t mip_solver_t::run_solver() // Detect symmetry after all presolve steps (PaPILO, cuOpt probing, bounds, trivial presolve). // context.problem_ptr is the final reduced problem with correct variable indices. if (context.settings.symmetry != 0 && !context.problem_ptr->empty) { - cuopt::linear_programming::dual_simplex::simplex_solver_settings_t simplex_settings; + simplex_solver_settings_t simplex_settings; simplex_settings.set_log(true); - simplex_settings.time_limit = context.settings.time_limit; - cuopt::linear_programming::dual_simplex::user_problem_t post_presolve_problem = - cuopt_problem_to_user_problem(context.problem_ptr->handle_ptr, - *context.problem_ptr); + simplex_settings.time_limit = context.settings.time_limit; + user_problem_t post_presolve_problem = cuopt_problem_to_user_problem( + context.problem_ptr->handle_ptr, *context.problem_ptr); bool has_symmetry_post = false; - context.symmetry = cuopt::linear_programming::dual_simplex::detect_symmetry( + context.symmetry = cuopt::mathematical_optimization::mip::detect_symmetry( post_presolve_problem, simplex_settings, has_symmetry_post); } #endif - namespace dual_simplex = cuopt::linear_programming::dual_simplex; - dual_simplex::mip_status_t branch_and_bound_status = dual_simplex::mip_status_t::UNSET; - dual_simplex::user_problem_t branch_and_bound_problem(context.problem_ptr->handle_ptr); + namespace simplex = cuopt::mathematical_optimization::simplex; + mip::mip_status_t branch_and_bound_status = mip::mip_status_t::UNSET; + user_problem_t branch_and_bound_problem(context.problem_ptr->handle_ptr); context.problem_ptr->recompute_objective_integrality(); if (context.settings.objective_step) { context.problem_ptr->compute_objective_step(); } if (context.problem_ptr->is_objective_integral()) { @@ -328,17 +329,17 @@ solution_t mip_solver_t::run_solver() if (context.settings.objective_step) { branch_and_bound_problem.objective_step = context.problem_ptr->get_objective_step(); } - dual_simplex::simplex_solver_settings_t branch_and_bound_settings; - std::unique_ptr> branch_and_bound; + simplex_solver_settings_t branch_and_bound_settings; + std::unique_ptr> branch_and_bound; branch_and_bound_solution_helper_t solution_helper(&dm, branch_and_bound_settings); - dual_simplex::mip_solution_t branch_and_bound_solution(1); + simplex::mip_solution_t branch_and_bound_solution(1); - dual_simplex::probing_implied_bound_t probing_implied_bound; + mip::probing_implied_bound_t probing_implied_bound; i_t num_threads = omp_get_num_threads(); if (!context.settings.heuristics_only) { - // Convert the presolved problem to dual_simplex::user_problem_t + // Convert the presolved problem to user_problem_t op_problem_.get_host_user_problem(branch_and_bound_problem); // Resize the solution now that we know the number of columns/variables branch_and_bound_solution.resize(branch_and_bound_problem.num_cols); @@ -426,13 +427,13 @@ solution_t mip_solver_t::run_solver() } // Create the branch and bound object - branch_and_bound = std::make_unique>( - branch_and_bound_problem, - branch_and_bound_settings, - timer_.get_tic_start(), - probing_implied_bound, - context.problem_ptr->clique_table, - context.symmetry.get()); + branch_and_bound = + std::make_unique>(branch_and_bound_problem, + branch_and_bound_settings, + timer_.get_tic_start(), + probing_implied_bound, + context.problem_ptr->clique_table, + context.symmetry.get()); context.branch_and_bound_ptr = branch_and_bound.get(); // Convert the best external upper bound from user-space to B&B's internal objective space. @@ -456,7 +457,7 @@ solution_t mip_solver_t::run_solver() branch_and_bound->set_concurrent_lp_root_solve(true); context.problem_ptr->branch_and_bound_callback = - std::bind(&dual_simplex::branch_and_bound_t::set_solution_from_heuristics, + std::bind(&mip::branch_and_bound_t::set_solution_from_heuristics, branch_and_bound.get(), std::placeholders::_1); } else if (context.settings.determinism_mode == CUOPT_MODE_DETERMINISTIC) { @@ -472,7 +473,7 @@ solution_t mip_solver_t::run_solver() // context.work_unit_scheduler_.verbose = true; context.problem_ptr->set_root_relaxation_solution_callback = - std::bind(&dual_simplex::branch_and_bound_t::set_root_relaxation_solution, + std::bind(&mip::branch_and_bound_t::set_root_relaxation_solution, branch_and_bound.get(), std::placeholders::_1, std::placeholders::_2, @@ -509,7 +510,7 @@ solution_t mip_solver_t::run_solver() context.stats.set_solution_bound( context.problem_ptr->get_user_obj_from_solver_obj(branch_and_bound_solution.lower_bound)); } - if (branch_and_bound_status == dual_simplex::mip_status_t::INFEASIBLE) { + if (branch_and_bound_status == mip::mip_status_t::INFEASIBLE) { sol.set_problem_fully_reduced(); } context.stats.num_nodes = branch_and_bound_solution.nodes_explored; @@ -541,4 +542,4 @@ template class mip_solver_t; template class mip_solver_t; #endif -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/solver.cuh b/cpp/src/mip_heuristics/solver.cuh index 9b9024a1dc..37905458c3 100644 --- a/cpp/src/mip_heuristics/solver.cuh +++ b/cpp/src/mip_heuristics/solver.cuh @@ -5,15 +5,15 @@ */ /* clang-format on */ -#include -#include -#include +#include +#include +#include #include #include #include #pragma once -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template class mip_solver_t { @@ -32,4 +32,4 @@ class mip_solver_t { timer_t timer_; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/solver_context.cuh b/cpp/src/mip_heuristics/solver_context.cuh index 739f7d130a..f98386cbaf 100644 --- a/cpp/src/mip_heuristics/solver_context.cuh +++ b/cpp/src/mip_heuristics/solver_context.cuh @@ -5,7 +5,7 @@ */ /* clang-format on */ -#include +#include #include #include @@ -18,14 +18,14 @@ #pragma once // Forward declare -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::mathematical_optimization::mip { template class branch_and_bound_t; } #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { template class diversity_manager_t; @@ -53,7 +53,7 @@ struct mip_solver_context_t { raft::handle_t const* const handle_ptr; problem_t* problem_ptr; - dual_simplex::branch_and_bound_t* branch_and_bound_ptr{nullptr}; + mip::branch_and_bound_t* branch_and_bound_ptr{nullptr}; diversity_manager_t* diversity_manager_ptr{nullptr}; std::atomic preempt_heuristic_solver_ = false; const mip_solver_settings_t settings; @@ -76,7 +76,7 @@ struct mip_solver_context_t { std::vector initial_incumbent_assignment{}; // Symmetry information for orbital fixing during B&B. Null if no exploitable symmetry. - std::unique_ptr> symmetry; + std::unique_ptr> symmetry; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/solver_settings.cu b/cpp/src/mip_heuristics/solver_settings.cu index dededa2f91..645b8c8b6e 100644 --- a/cpp/src/mip_heuristics/solver_settings.cu +++ b/cpp/src/mip_heuristics/solver_settings.cu @@ -6,11 +6,11 @@ /* clang-format on */ #include -#include +#include #include #include -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { template void mip_solver_settings_t::add_initial_solution(const f_t* initial_solution, @@ -55,4 +55,4 @@ template class mip_solver_settings_t; template class mip_solver_settings_t; #endif -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/mip_heuristics/solver_solution.cu b/cpp/src/mip_heuristics/solver_solution.cu index 8f6f8de05f..7782260dd5 100644 --- a/cpp/src/mip_heuristics/solver_solution.cu +++ b/cpp/src/mip_heuristics/solver_solution.cu @@ -5,7 +5,7 @@ */ /* clang-format on */ -#include +#include #include #include @@ -15,7 +15,7 @@ #include #include -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { template mip_solution_t::mip_solution_t(rmm::device_uvector solution, @@ -262,4 +262,4 @@ template class mip_solution_t; #if MIP_INSTANTIATE_DOUBLE template class mip_solution_t; #endif -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/mip_heuristics/utilities/sort_csr.cuh b/cpp/src/mip_heuristics/utilities/sort_csr.cuh index 92e560dbb9..dffc2e004f 100644 --- a/cpp/src/mip_heuristics/utilities/sort_csr.cuh +++ b/cpp/src/mip_heuristics/utilities/sort_csr.cuh @@ -15,7 +15,7 @@ namespace cuopt { -namespace linear_programming::detail { +namespace mathematical_optimization::mip { template void sort_csr(optimization_problem_t& op_problem) @@ -53,5 +53,5 @@ void sort_csr(optimization_problem_t& op_problem) RAFT_CUDA_TRY(cudaStreamSynchronize(stream_view)); } -} // namespace linear_programming::detail +} // namespace mathematical_optimization::mip } // namespace cuopt diff --git a/cpp/src/mip_heuristics/utils.cuh b/cpp/src/mip_heuristics/utils.cuh index ffadc1f510..faf4718a5e 100644 --- a/cpp/src/mip_heuristics/utils.cuh +++ b/cpp/src/mip_heuristics/utils.cuh @@ -17,11 +17,11 @@ #include #include -#include +#include #pragma once -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::mip { // TODO templatize as needed constexpr double default_cont_upper = std::numeric_limits::infinity(); @@ -35,7 +35,7 @@ inline uint32_t compute_hash(raft::device_span values, rmm::cuda_stream_vie { auto h_contents = cuopt::host_copy(values, stream); RAFT_CHECK_CUDA(stream); - return compute_hash(h_contents); + return cuopt::compute_hash(h_contents); } template @@ -43,7 +43,7 @@ inline uint32_t compute_hash(const rmm::device_uvector& values, rmm::cuda_s { auto h_contents = cuopt::host_copy(values, stream); RAFT_CHECK_CUDA(stream); - return compute_hash(h_contents); + return cuopt::compute_hash(h_contents); } template @@ -61,7 +61,7 @@ HDI f_t get_cstr_tolerance(f_t lb, f_t ub, f_t abs_tol, f_t rel_tol) // we normally have combined bounds in the problem, but to reduce a memory request we can // recompute here if (USE_REL_TOLERANCE) { - f_t max_bound = combine_finite_abs_bounds{}(lb, ub); + f_t max_bound = pdlp::combine_finite_abs_bounds{}(lb, ub); tolerance += max_bound * rel_tol; } return tolerance; @@ -421,4 +421,4 @@ bool has_variable_bounds_violation(const raft::handle_t* handle_ptr, has_variable_bounds_violation_functor(assignment.data(), problem_ptr->view())); } -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/pdlp/backend_selection.cpp b/cpp/src/pdlp/backend_selection.cpp index 4f2dc62bcf..a6f6addbaf 100644 --- a/cpp/src/pdlp/backend_selection.cpp +++ b/cpp/src/pdlp/backend_selection.cpp @@ -5,7 +5,7 @@ */ /* clang-format on */ -#include +#include #include #include @@ -14,7 +14,7 @@ #include #include -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { bool is_remote_execution_enabled() { @@ -47,4 +47,4 @@ memory_backend_t get_memory_backend_type() return use_cpu_memory_for_local() ? memory_backend_t::CPU : memory_backend_t::GPU; } -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/pdlp/cpu_optimization_problem.cpp b/cpp/src/pdlp/cpu_optimization_problem.cpp index 5bb3e25cad..599d0a630e 100644 --- a/cpp/src/pdlp/cpu_optimization_problem.cpp +++ b/cpp/src/pdlp/cpu_optimization_problem.cpp @@ -6,13 +6,13 @@ /* clang-format on */ #include -#include -#include -#include -#include -#include +#include +#include +#include +#include +#include -#include +#include #include #include @@ -22,7 +22,7 @@ #include #include -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { // ============================================================================== // Constructor @@ -723,7 +723,7 @@ template void cpu_optimization_problem_t::write_to_mps(const std::string& mps_file_path) { // Data is already in host memory, so we can directly create a view and write - cuopt::linear_programming::io::data_model_view_t data_model_view; + cuopt::mathematical_optimization::io::data_model_view_t data_model_view; // Set optimization sense data_model_view.set_maximize(maximize_); @@ -785,7 +785,7 @@ void cpu_optimization_problem_t::write_to_mps(const std::string& mps_f var_types_char.resize(variable_types_.size()); for (size_t i = 0; i < var_types_char.size(); ++i) { - var_types_char[i] = detail::var_type_to_char(variable_types_[i]); + var_types_char[i] = var_type_to_char(variable_types_[i]); } } else if (get_n_variables() > 0) { // Variable types not set (e.g. pure LP); default to all continuous @@ -811,7 +811,7 @@ void cpu_optimization_problem_t::write_to_mps(const std::string& mps_f data_model_view.set_quadratic_constraints(quadratic_constraints_); } - cuopt::linear_programming::io::write_mps(data_model_view, mps_file_path); + cuopt::mathematical_optimization::io::write_mps(data_model_view, mps_file_path); } // ============================================================================== @@ -1104,4 +1104,4 @@ template class cpu_optimization_problem_t; template class cpu_optimization_problem_t; #endif -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/pdlp/cpu_pdlp_warm_start_data.cu b/cpp/src/pdlp/cpu_pdlp_warm_start_data.cu index b078bc4779..94c8ed5466 100644 --- a/cpp/src/pdlp/cpu_pdlp_warm_start_data.cu +++ b/cpp/src/pdlp/cpu_pdlp_warm_start_data.cu @@ -5,12 +5,12 @@ */ /* clang-format on */ -#include -#include +#include +#include #include #include -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { // Helper to copy device_uvector to std::vector (D2H) template @@ -123,4 +123,4 @@ template pdlp_warm_start_data_t convert_to_gpu_warmstart( const cpu_pdlp_warm_start_data_t&, rmm::cuda_stream_view); #endif -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/pdlp/cuopt_c.cpp b/cpp/src/pdlp/cuopt_c.cpp index bf3f6f7433..0288014f40 100644 --- a/cpp/src/pdlp/cuopt_c.cpp +++ b/cpp/src/pdlp/cuopt_c.cpp @@ -5,19 +5,19 @@ */ /* clang-format on */ -#include - -#include -#include -#include -#include -#include -#include +#include + +#include +#include +#include +#include +#include +#include #include #include #include -#include +#include #include @@ -27,8 +27,15 @@ #include #include -using namespace cuopt::linear_programming::io; -using namespace cuopt::linear_programming; +using cuopt::mathematical_optimization::char_to_var_type; +using cuopt::mathematical_optimization::get_memory_backend_type; +using cuopt::mathematical_optimization::is_valid_public_var_type_code; +using cuopt::mathematical_optimization::problem_and_stream_view_t; +using cuopt::mathematical_optimization::problem_category_t; +using cuopt::mathematical_optimization::solution_and_stream_view_t; +using cuopt::mathematical_optimization::solver_settings_t; +using cuopt::mathematical_optimization::var_t; +using cuopt::mathematical_optimization::io::mps_data_model_t; class c_get_solution_callback_t : public cuopt::internals::get_solution_callback_t { public: @@ -197,7 +204,7 @@ cuopt_int_t cuOptReadProblem(const char* filename, cuOptOptimizationProblem* pro try { // Dispatches on file extension; see read for the enumerated rules. mps_data_model_ptr = std::make_unique>( - read(filename_str)); + cuopt::mathematical_optimization::io::read(filename_str)); } catch (const std::exception& e) { CUOPT_LOG_INFO("Error parsing input file: %s", e.what()); delete problem_and_stream; @@ -211,7 +218,8 @@ cuopt_int_t cuOptReadProblem(const char* filename, cuOptOptimizationProblem* pro } // Populate interface directly from MPS data model (avoids temporary GPU allocation) - populate_from_mps_data_model(problem_and_stream->get_problem(), *mps_data_model_ptr); + cuopt::mathematical_optimization::populate_from_mps_data_model(problem_and_stream->get_problem(), + *mps_data_model_ptr); *problem_ptr = static_cast(problem_and_stream); return CUOPT_SUCCESS; @@ -263,9 +271,7 @@ cuopt_int_t cuOptCreateProblem(cuopt_int_t num_constraints, return CUOPT_INVALID_ARGUMENT; } for (int j = 0; j < num_variables; j++) { - if (!detail::is_valid_public_var_type_code(variable_types[j])) { - return CUOPT_INVALID_ARGUMENT; - } + if (!is_valid_public_var_type_code(variable_types[j])) { return CUOPT_INVALID_ARGUMENT; } } problem_and_stream_view_t* problem_and_stream = @@ -290,7 +296,7 @@ cuopt_int_t cuOptCreateProblem(cuopt_int_t num_constraints, // Set variable types (problem category is auto-detected) std::vector variable_types_host(num_variables); for (int j = 0; j < num_variables; j++) { - variable_types_host[j] = detail::char_to_var_type(variable_types[j]); + variable_types_host[j] = char_to_var_type(variable_types[j]); } problem->set_variable_types(variable_types_host.data(), num_variables); @@ -328,9 +334,7 @@ cuopt_int_t cuOptCreateRangedProblem(cuopt_int_t num_constraints, } if (variable_types != nullptr) { for (int j = 0; j < num_variables; j++) { - if (!detail::is_valid_public_var_type_code(variable_types[j])) { - return CUOPT_INVALID_ARGUMENT; - } + if (!is_valid_public_var_type_code(variable_types[j])) { return CUOPT_INVALID_ARGUMENT; } } } @@ -358,7 +362,7 @@ cuopt_int_t cuOptCreateRangedProblem(cuopt_int_t num_constraints, std::vector variable_types_host(num_variables); if (variable_types != nullptr) { for (cuopt_int_t j = 0; j < num_variables; ++j) { - variable_types_host[j] = detail::char_to_var_type(variable_types[j]); + variable_types_host[j] = char_to_var_type(variable_types[j]); } } else { // Default to all continuous @@ -828,13 +832,14 @@ cuopt_int_t cuOptGetVariableTypes(cuOptOptimizationProblem problem, char* variab static_cast(problem); cuopt_int_t size = problem_and_stream_view->get_problem()->get_n_variables(); - std::vector variable_types_host(size); + std::vector variable_types_host(size); problem_and_stream_view->get_problem()->copy_variable_types_to_host(variable_types_host.data(), size); // Convert var_t enum to C API char values for (size_t j = 0; j < variable_types_host.size(); j++) { - variable_types_ptr[j] = detail::var_type_to_char(variable_types_host[j]); + variable_types_ptr[j] = + cuopt::mathematical_optimization::var_type_to_char(variable_types_host[j]); } return CUOPT_SUCCESS; } @@ -1079,20 +1084,21 @@ cuopt_int_t cuOptSolve(cuOptOptimizationProblem problem, static_cast(problem); // Get the problem interface (GPU or CPU backed) - optimization_problem_interface_t* problem_interface = - problem_and_stream_view->get_problem(); + cuopt::mathematical_optimization::optimization_problem_interface_t* + problem_interface = problem_and_stream_view->get_problem(); try { if (problem_interface->get_problem_category() == problem_category_t::MIP || problem_interface->get_problem_category() == problem_category_t::IP) { solver_settings_t* solver_settings = get_settings_handle(settings)->settings; - mip_solver_settings_t& mip_settings = - solver_settings->get_mip_settings(); + cuopt::mathematical_optimization::mip_solver_settings_t& + mip_settings = solver_settings->get_mip_settings(); // Solve returns unique_ptr auto solution_interface = - solve_mip(problem_interface, mip_settings); + cuopt::mathematical_optimization::solve_mip(problem_interface, + mip_settings); auto solution_holder = std::make_unique(true, problem_and_stream_view->memory_backend); @@ -1107,12 +1113,13 @@ cuopt_int_t cuOptSolve(cuOptOptimizationProblem problem, } else { solver_settings_t* solver_settings = get_settings_handle(settings)->settings; - pdlp_solver_settings_t& pdlp_settings = - solver_settings->get_pdlp_settings(); + cuopt::mathematical_optimization::pdlp_solver_settings_t& + pdlp_settings = solver_settings->get_pdlp_settings(); // Solve returns unique_ptr auto solution_interface = - solve_lp(problem_interface, pdlp_settings); + cuopt::mathematical_optimization::solve_lp(problem_interface, + pdlp_settings); auto solution_holder = std::make_unique( false, problem_and_stream_view->memory_backend); diff --git a/cpp/src/pdlp/cuopt_c_internal.hpp b/cpp/src/pdlp/cuopt_c_internal.hpp index f10b1d023e..338e998df2 100644 --- a/cpp/src/pdlp/cuopt_c_internal.hpp +++ b/cpp/src/pdlp/cuopt_c_internal.hpp @@ -7,13 +7,13 @@ #pragma once -#include -#include -#include -#include -#include -#include -#include +#include +#include +#include +#include +#include +#include +#include #include @@ -21,7 +21,7 @@ #include -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { struct problem_and_stream_view_t { problem_and_stream_view_t(memory_backend_t mem_backend) @@ -187,4 +187,4 @@ struct solution_and_stream_view_t { memory_backend_t memory_backend; // Track if GPU or CPU memory for data access }; -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/pdlp/cusparse_view.cu b/cpp/src/pdlp/cusparse_view.cu index 736aa4628a..0974a49c82 100644 --- a/cpp/src/pdlp/cusparse_view.cu +++ b/cpp/src/pdlp/cusparse_view.cu @@ -27,7 +27,7 @@ struct double_to_float_functor { __host__ __device__ float operator()(double val) const { return static_cast(val); } }; -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::pdlp { // cusparse_sp_mat_descr_wrapper_t implementation template @@ -512,14 +512,14 @@ void cusparse_spmvop_run(cusparseHandle_t handle, template cusparse_view_t::cusparse_view_t( raft::handle_t const* handle_ptr, - const problem_t& op_problem_scaled, + const mip::problem_t& op_problem_scaled, saddle_point_state_t& current_saddle_point_state, rmm::device_uvector& _tmp_primal, rmm::device_uvector& _tmp_dual, rmm::device_uvector& _potential_next_dual_solution, rmm::device_uvector& _reflected_primal_solution, const std::vector& climber_strategies, - const pdlp_hyper_params::pdlp_hyper_params_t& hyper_params, + const pdlp::pdlp_hyper_params_t& hyper_params, bool enable_mixed_precision_spmv) : batch_mode_(climber_strategies.size() > 1), handle_ptr_(handle_ptr), @@ -927,7 +927,7 @@ cusparse_view_t::cusparse_view_t( template cusparse_view_t::cusparse_view_t( raft::handle_t const* handle_ptr, - const problem_t& op_problem, + const mip::problem_t& op_problem, rmm::device_uvector& _primal_solution, rmm::device_uvector& _dual_solution, rmm::device_uvector& _tmp_primal, @@ -938,7 +938,7 @@ cusparse_view_t::cusparse_view_t( const rmm::device_uvector& _A_T_offsets, const rmm::device_uvector& _A_T_indices, const std::vector& climber_strategies, - const pdlp_hyper_params::pdlp_hyper_params_t& hyper_params) + const pdlp::pdlp_hyper_params_t& hyper_params) : batch_mode_(climber_strategies.size() > 1), handle_ptr_(handle_ptr), A{}, @@ -1150,7 +1150,7 @@ cusparse_view_t::cusparse_view_t( template cusparse_view_t::cusparse_view_t( raft::handle_t const* handle_ptr, - const problem_t& op_problem, // Just used for the sizes + const mip::problem_t& op_problem, // Just used for the sizes const cusparse_view_t& existing_cusparse_view, f_t* _primal_solution, // Solutions of each duality gap container f_t* _dual_solution, @@ -1331,7 +1331,7 @@ void cusparse_view_t::update_mixed_precision_matrices() // so the duplicated row/column buffers can be freed. template void cusparse_view_t::redirect_cusparse_csr_structure_pointers( - const problem_t& original_problem) + const mip::problem_t& original_problem) { RAFT_CUSPARSE_TRY(cusparseCsrSetPointers(A, const_cast(original_problem.offsets.data()), @@ -1542,4 +1542,4 @@ template void my_cusparsespmm_preprocess(cusparseHandle_t, #endif #endif -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::pdlp diff --git a/cpp/src/pdlp/cusparse_view.hpp b/cpp/src/pdlp/cusparse_view.hpp index 67dbb5a570..22fcf016f1 100644 --- a/cpp/src/pdlp/cusparse_view.hpp +++ b/cpp/src/pdlp/cusparse_view.hpp @@ -6,7 +6,7 @@ /* clang-format on */ #pragma once -#include +#include #include #include @@ -25,7 +25,7 @@ // cuSPARSE 12.8 ships with CUDA Toolkit 13.3 #define CUOPT_CUSPARSE_VER_12_8_UP (CUSPARSE_VERSION >= 12800) -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::pdlp { template class cusparse_sp_mat_descr_wrapper_t { @@ -158,18 +158,18 @@ template class cusparse_view_t { public: cusparse_view_t(raft::handle_t const* handle_ptr, - const problem_t& op_problem, + const mip::problem_t& op_problem, saddle_point_state_t& current_saddle_point_state, rmm::device_uvector& _tmp_primal, rmm::device_uvector& _tmp_dual, rmm::device_uvector& _potential_next_dual_solution, rmm::device_uvector& _reflected_primal_solution, const std::vector& climber_strategies, - const pdlp_hyper_params::pdlp_hyper_params_t& hyper_params, + const pdlp::pdlp_hyper_params_t& hyper_params, bool enable_mixed_precision_spmv); cusparse_view_t(raft::handle_t const* handle_ptr, - const problem_t& op_problem, + const mip::problem_t& op_problem, rmm::device_uvector& _primal_solution, rmm::device_uvector& _dual_solution, rmm::device_uvector& _tmp_primal, @@ -180,10 +180,10 @@ class cusparse_view_t { const rmm::device_uvector& _A_T_offsets, const rmm::device_uvector& _A_T_indices, const std::vector& climber_strategies, - const pdlp_hyper_params::pdlp_hyper_params_t& hyper_params); + const pdlp::pdlp_hyper_params_t& hyper_params); cusparse_view_t(raft::handle_t const* handle_ptr, - const problem_t& op_problem, + const mip::problem_t& op_problem, const cusparse_view_t& existing_cusparse_view, f_t* _primal_solution, f_t* _dual_solution, @@ -297,7 +297,7 @@ class cusparse_view_t { // Redirects the cuSPARSE CSR structure pointers from op_problem_scaled_ to the original problem // so the duplicated row/column buffers can be freed. - void redirect_cusparse_csr_structure_pointers(const problem_t& original_problem); + void redirect_cusparse_csr_structure_pointers(const mip::problem_t& original_problem); // Creates SpMVOp plans. Must be called after scale_problem() so plans use the scaled matrix. void create_spmv_op_plans(bool is_reflected); }; @@ -373,4 +373,4 @@ void cusparse_spmvop_run(cusparseHandle_t handle, cudaStream_t stream); #endif // CUOPT_CUSPARSE_VER_12_7_UP -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::pdlp diff --git a/cpp/src/pdlp/initial_scaling_strategy/initial_scaling.cu b/cpp/src/pdlp/initial_scaling_strategy/initial_scaling.cu index c79249c45d..551c23bd3a 100644 --- a/cpp/src/pdlp/initial_scaling_strategy/initial_scaling.cu +++ b/cpp/src/pdlp/initial_scaling_strategy/initial_scaling.cu @@ -9,8 +9,8 @@ #include -#include -#include +#include +#include #include #include #include @@ -29,7 +29,7 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::pdlp { template struct weighted_square_op { @@ -70,14 +70,14 @@ __global__ void scaling_swap_rescaling_kernel(const swap_pair_t* swap_pairs template pdlp_initial_scaling_strategy_t::pdlp_initial_scaling_strategy_t( raft::handle_t const* handle_ptr, - problem_t& op_problem_scaled, + mip::problem_t& op_problem_scaled, i_t number_of_ruiz_iterations, f_t alpha, rmm::device_uvector& A_T, rmm::device_uvector& A_T_offsets, rmm::device_uvector& A_T_indices, pdhg_solver_t* pdhg_solver_ptr, - const pdlp_hyper_params::pdlp_hyper_params_t& hyper_params, + const pdlp::pdlp_hyper_params_t& hyper_params, i_t original_batch_size, bool running_mip) : handle_ptr_(handle_ptr), @@ -150,7 +150,7 @@ template void pdlp_initial_scaling_strategy_t::bound_objective_rescaling() { // TODO: test bound obj scaling w/ MIP - segmented_sum_handler_t segmented_sum_handler(stream_view_); + cuopt::segmented_sum_handler_t segmented_sum_handler(stream_view_); // ------- Constraints bounds scaling ------- // This works whether we have different bounds per climber or not because of the @@ -185,7 +185,7 @@ void pdlp_initial_scaling_strategy_t::bound_objective_rescaling() template __global__ void inf_norm_row_and_col_kernel( - const typename problem_t::view_t op_problem, + const typename mip::problem_t::view_t op_problem, typename pdlp_initial_scaling_strategy_t::view_t initial_scaling_view) { for (int row = blockIdx.x; row < op_problem.n_constraints; row += gridDim.x) { @@ -267,7 +267,7 @@ void pdlp_initial_scaling_strategy_t::reset_integer_variables() template __global__ void pock_chambolle_scaling_kernel_row( - const typename problem_t::view_t op_problem, + const typename mip::problem_t::view_t op_problem, f_t alpha, typename pdlp_initial_scaling_strategy_t::view_t initial_scaling_view) { @@ -306,7 +306,7 @@ __global__ void pock_chambolle_scaling_kernel_row( // This is to avoid multiple atomic between blocks and having indeterminism template __global__ void pock_chambolle_scaling_kernel_col( - const typename problem_t::view_t op_problem, + const typename mip::problem_t::view_t op_problem, f_t alpha, typename pdlp_initial_scaling_strategy_t::view_t initial_scaling_view, const f_t* A_T, @@ -401,7 +401,7 @@ void pdlp_initial_scaling_strategy_t::pock_chambolle_scaling(f_t alpha template __global__ void scale_problem_kernel( const typename pdlp_initial_scaling_strategy_t::view_t initial_scaling_view, - const typename problem_t::view_t op_problem) + const typename mip::problem_t::view_t op_problem) { for (int row = blockIdx.x; row < op_problem.n_constraints; row += gridDim.x) { i_t row_offset = op_problem.offsets[row]; @@ -877,7 +877,7 @@ void pdlp_initial_scaling_strategy_t::unscale_solutions( template void pdlp_initial_scaling_strategy_t::unscale_solutions( - solution_t& solution) const + mip::solution_t& solution) const { auto& primal_solution = solution.assignment; rmm::device_uvector dummy(0, solution.handle_ptr->get_stream()); @@ -894,7 +894,7 @@ void pdlp_initial_scaling_strategy_t::unscale_solutions( } template -const problem_t& pdlp_initial_scaling_strategy_t::get_scaled_op_problem() +const mip::problem_t& pdlp_initial_scaling_strategy_t::get_scaled_op_problem() { return op_problem_scaled_; } @@ -938,11 +938,11 @@ pdlp_initial_scaling_strategy_t::view() template class pdlp_initial_scaling_strategy_t; \ \ template __global__ void inf_norm_row_and_col_kernel( \ - const typename problem_t::view_t op_problem, \ + const typename mip::problem_t::view_t op_problem, \ typename pdlp_initial_scaling_strategy_t::view_t initial_scaling_view); \ \ template __global__ void pock_chambolle_scaling_kernel_col( \ - const typename problem_t::view_t op_problem, \ + const typename mip::problem_t::view_t op_problem, \ F_TYPE alpha, \ typename pdlp_initial_scaling_strategy_t::view_t initial_scaling_view, \ const F_TYPE* A_T, \ @@ -950,13 +950,13 @@ pdlp_initial_scaling_strategy_t::view() const int* A_T_indices); \ \ template __global__ void pock_chambolle_scaling_kernel_row( \ - const typename problem_t::view_t op_problem, \ + const typename mip::problem_t::view_t op_problem, \ F_TYPE alpha, \ typename pdlp_initial_scaling_strategy_t::view_t initial_scaling_view); \ \ template __global__ void scale_problem_kernel( \ const typename pdlp_initial_scaling_strategy_t::view_t initial_scaling_view, \ - const typename problem_t::view_t op_problem); \ + const typename mip::problem_t::view_t op_problem); \ \ template __global__ void scale_transposed_problem_kernel( \ const typename pdlp_initial_scaling_strategy_t::view_t initial_scaling_view, \ @@ -972,4 +972,4 @@ INSTANTIATE(float) INSTANTIATE(double) #endif -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::pdlp diff --git a/cpp/src/pdlp/initial_scaling_strategy/initial_scaling.cuh b/cpp/src/pdlp/initial_scaling_strategy/initial_scaling.cuh index 99d1472b6f..aee91f895e 100644 --- a/cpp/src/pdlp/initial_scaling_strategy/initial_scaling.cuh +++ b/cpp/src/pdlp/initial_scaling_strategy/initial_scaling.cuh @@ -7,7 +7,7 @@ #pragma once -#include +#include #include #include @@ -21,7 +21,7 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::pdlp { template class pdlp_initial_scaling_strategy_t { @@ -47,14 +47,14 @@ class pdlp_initial_scaling_strategy_t { }; // struct view_t pdlp_initial_scaling_strategy_t(raft::handle_t const* handle_ptr, - problem_t& op_problem_scaled, + mip::problem_t& op_problem_scaled, i_t number_of_ruiz_iterations, f_t alpha, rmm::device_uvector& A_T, rmm::device_uvector& A_T_offsets, rmm::device_uvector& A_T_indices, pdhg_solver_t* pdhg_solver_ptr, - const pdlp_hyper_params::pdlp_hyper_params_t& hyper_params, + const pdlp::pdlp_hyper_params_t& hyper_params, i_t original_batch_size, bool running_mip = false); @@ -73,10 +73,10 @@ class pdlp_initial_scaling_strategy_t { void unscale_solutions(rmm::device_uvector& primal_solution, rmm::device_uvector& dual_solution, rmm::device_uvector& dual_slack) const; - void unscale_solutions(solution_t& solution) const; + void unscale_solutions(mip::solution_t& solution) const; const rmm::device_uvector& get_constraint_matrix_scaling_vector() const; const rmm::device_uvector& get_variable_scaling_vector() const; - const problem_t& get_scaled_op_problem(); + const mip::problem_t& get_scaled_op_problem(); f_t get_h_bound_rescaling() const; f_t get_h_objective_rescaling() const; @@ -104,7 +104,7 @@ class pdlp_initial_scaling_strategy_t { i_t primal_size_h_; i_t dual_size_h_; - problem_t& op_problem_scaled_; + mip::problem_t& op_problem_scaled_; rmm::device_uvector iteration_constraint_matrix_scaling_; rmm::device_uvector iteration_variable_scaling_; @@ -122,7 +122,7 @@ class pdlp_initial_scaling_strategy_t { rmm::device_uvector& A_T_; rmm::device_uvector& A_T_offsets_; rmm::device_uvector& A_T_indices_; - const pdlp_hyper_params::pdlp_hyper_params_t& hyper_params_; + const pdlp::pdlp_hyper_params_t& hyper_params_; bool running_mip_; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::pdlp diff --git a/cpp/src/pdlp/optimal_batch_size_handler/optimal_batch_size_handler.cu b/cpp/src/pdlp/optimal_batch_size_handler/optimal_batch_size_handler.cu index cbfb03618d..04991c652c 100644 --- a/cpp/src/pdlp/optimal_batch_size_handler/optimal_batch_size_handler.cu +++ b/cpp/src/pdlp/optimal_batch_size_handler/optimal_batch_size_handler.cu @@ -15,7 +15,7 @@ #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::pdlp { template struct SpMM_benchmarks_context_t { @@ -220,7 +220,7 @@ int optimal_batch_size_handler(const optimization_problem_t& op_proble double best_ratio; rmm::cuda_stream_view stream_view = op_problem.get_handle_ptr()->get_stream(); - detail::problem_t problem(op_problem); + mip::problem_t problem(op_problem); // Init cuSparse views cusparse_sp_mat_descr_wrapper_t A; @@ -443,4 +443,4 @@ template int optimal_batch_size_handler( const optimization_problem_t& op_problem, int max_batch_size); #endif -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::pdlp diff --git a/cpp/src/pdlp/optimal_batch_size_handler/optimal_batch_size_handler.hpp b/cpp/src/pdlp/optimal_batch_size_handler/optimal_batch_size_handler.hpp index 96a1fdc776..3f0f5a28b3 100644 --- a/cpp/src/pdlp/optimal_batch_size_handler/optimal_batch_size_handler.hpp +++ b/cpp/src/pdlp/optimal_batch_size_handler/optimal_batch_size_handler.hpp @@ -6,8 +6,8 @@ /* clang-format on */ #pragma once -#include -namespace cuopt::linear_programming::detail { +#include +namespace cuopt::mathematical_optimization::pdlp { template int optimal_batch_size_handler(const optimization_problem_t& op_problem, diff --git a/cpp/src/pdlp/optimization_problem.cu b/cpp/src/pdlp/optimization_problem.cu index 70b9fb7e68..56baca496c 100644 --- a/cpp/src/pdlp/optimization_problem.cu +++ b/cpp/src/pdlp/optimization_problem.cu @@ -5,14 +5,14 @@ */ /* clang-format on */ -#include -#include -#include -#include +#include +#include +#include +#include #include -#include -#include +#include +#include #include #include #include @@ -49,7 +49,7 @@ #include #include -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { template optimization_problem_t::optimization_problem_t(raft::handle_t const* handle_ptr) @@ -795,7 +795,7 @@ typename optimization_problem_t::view_t optimization_problem_t void optimization_problem_t::write_to_mps(const std::string& mps_file_path) { - cuopt::linear_programming::io::data_model_view_t data_model_view; + cuopt::mathematical_optimization::io::data_model_view_t data_model_view; // Set optimization sense data_model_view.set_maximize(get_sense()); @@ -882,7 +882,7 @@ void optimization_problem_t::write_to_mps(const std::string& mps_file_ variable_types.resize(enum_variable_types.size()); // Convert enum types to char types for (size_t i = 0; i < variable_types.size(); ++i) { - variable_types[i] = detail::var_type_to_char(enum_variable_types[i]); + variable_types[i] = var_type_to_char(enum_variable_types[i]); } } @@ -905,7 +905,7 @@ void optimization_problem_t::write_to_mps(const std::string& mps_file_ data_model_view.set_quadratic_constraints(quadratic_constraints_); } - cuopt::linear_programming::io::write_mps(data_model_view, mps_file_path); + cuopt::mathematical_optimization::io::write_mps(data_model_view, mps_file_path); } template @@ -1641,4 +1641,4 @@ template optimization_problem_t rmm::cuda_stream_view) const; #endif -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/pdlp/pdhg.cu b/cpp/src/pdlp/pdhg.cu index e88366a295..89fc01faeb 100644 --- a/cpp/src/pdlp/pdhg.cu +++ b/cpp/src/pdlp/pdhg.cu @@ -38,15 +38,15 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::pdlp { template pdhg_solver_t::pdhg_solver_t( raft::handle_t const* handle_ptr, - problem_t& op_problem_scaled, + mip::problem_t& op_problem_scaled, bool is_legacy_batch_mode, // Batch mode with streams const std::vector& climber_strategies, - const pdlp_hyper_params::pdlp_hyper_params_t& hyper_params, + const pdlp::pdlp_hyper_params_t& hyper_params, const std::vector>& new_bounds, bool enable_mixed_precision_spmv) : batch_mode_(climber_strategies.size() > 1), @@ -1502,4 +1502,4 @@ template class pdhg_solver_t; template class pdhg_solver_t; #endif -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::pdlp diff --git a/cpp/src/pdlp/pdhg.hpp b/cpp/src/pdlp/pdhg.hpp index 01eabe967a..1860f0e8f2 100644 --- a/cpp/src/pdlp/pdhg.hpp +++ b/cpp/src/pdlp/pdhg.hpp @@ -6,7 +6,7 @@ /* clang-format on */ #pragma once -#include +#include #include #include #include @@ -23,15 +23,15 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::pdlp { template class pdhg_solver_t { public: pdhg_solver_t(raft::handle_t const* handle_ptr, - problem_t& op_problem, + mip::problem_t& op_problem, bool is_legacy_batch_mode, const std::vector& climber_strategies, - const pdlp_hyper_params::pdlp_hyper_params_t& hyper_params, + const pdlp::pdlp_hyper_params_t& hyper_params, const std::vector>& new_bounds, bool enable_mixed_precision_spmv = false); @@ -102,7 +102,7 @@ class pdhg_solver_t { raft::handle_t const* handle_ptr_{nullptr}; rmm::cuda_stream_view stream_view_; - problem_t* problem_ptr; + mip::problem_t* problem_ptr; i_t primal_size_h_; i_t dual_size_h_; @@ -144,7 +144,7 @@ class pdhg_solver_t { rmm::device_scalar d_total_pdhg_iterations_; const std::vector& climber_strategies_; - const pdlp_hyper_params::pdlp_hyper_params_t& hyper_params_; + const pdlp::pdlp_hyper_params_t& hyper_params_; rmm::device_uvector new_bounds_climber_id_; rmm::device_uvector new_bounds_idx_; rmm::device_uvector new_bounds_lower_; @@ -152,4 +152,4 @@ class pdhg_solver_t { cuda::fast_mod_div batch_size_divisor_; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::pdlp diff --git a/cpp/src/pdlp/pdlp.cu b/cpp/src/pdlp/pdlp.cu index dadc54cc08..a936763fd4 100644 --- a/cpp/src/pdlp/pdlp.cu +++ b/cpp/src/pdlp/pdlp.cu @@ -6,9 +6,9 @@ /* clang-format on */ #include -#include -#include -#include +#include +#include +#include #include #include @@ -16,7 +16,7 @@ #include #include -#include "cuopt/linear_programming/pdlp/solver_solution.hpp" +#include "cuopt/mathematical_optimization/pdlp/solver_solution.hpp" #include #include @@ -45,7 +45,7 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::pdlp { // Templated wrapper for cuBLAS geam function // cublasSgeam for float, cublasDgeam for double @@ -153,7 +153,7 @@ static size_t batch_size_handler(const pdlp_solver_settings_t& setting } template -pdlp_solver_t::pdlp_solver_t(problem_t& op_problem, +pdlp_solver_t::pdlp_solver_t(mip::problem_t& op_problem, pdlp_solver_settings_t const& settings, bool is_legacy_batch_mode) : original_batch_size_(batch_size_handler(settings)), @@ -576,8 +576,8 @@ void pdlp_solver_t::set_inside_mip(bool inside_mip) template void pdlp_solver_t::record_best_primal_so_far( - const detail::pdlp_termination_strategy_t& current, - const detail::pdlp_termination_strategy_t& average, + const pdlp::pdlp_termination_strategy_t& current, + const pdlp::pdlp_termination_strategy_t& average, const pdlp_termination_status_t& termination_current, const pdlp_termination_status_t& termination_average) { @@ -617,7 +617,7 @@ void pdlp_solver_t::record_best_primal_so_far( rmm::device_uvector* primal_to_set; rmm::device_uvector* dual_to_set; - detail::pdlp_termination_strategy_t* termination_strategy_to_use; + pdlp::pdlp_termination_strategy_t* termination_strategy_to_use; std::string_view debug_string; if (best_overall == current_quality) { @@ -2690,7 +2690,7 @@ optimization_problem_solution_t pdlp_solver_t::run_solver(co if (settings_.hyper_params.restart_strategy != static_cast( - detail::pdlp_restart_strategy_t::restart_strategy_t::NO_RESTART) && + pdlp::pdlp_restart_strategy_t::restart_strategy_t::NO_RESTART) && (is_major_iteration || artificial_restart_check_main_loop)) { restart_strategy_.compute_restart( pdhg_solver_, @@ -2939,7 +2939,7 @@ void pdlp_solver_t::compute_initial_step_size() void* d_temp_storage = NULL; size_t temp_storage_bytes = 0; - detail::max_abs_value red_op; + pdlp::max_abs_value red_op; cub::DeviceReduce::Reduce(d_temp_storage, temp_storage_bytes, op_problem_scaled_.coefficients.data(), @@ -3090,7 +3090,7 @@ __global__ void compute_weights_initial_primal_weight_from_squared_norms( raft::device_span primal_weight, raft::device_span best_primal_weight, int batch_size, - const pdlp_hyper_params::pdlp_hyper_params_t hyper_params) + const pdlp::pdlp_hyper_params_t hyper_params) { const int id = threadIdx.x + blockIdx.x * blockDim.x; if (id >= batch_size) { return; } @@ -3123,21 +3123,20 @@ void pdlp_solver_t::compute_initial_primal_weight() // Here we use the combined bounds of the op_problem_scaled which may or may not be scaled yet // based on pdlp config - detail::combine_constraint_bounds(op_problem_scaled_, - op_problem_scaled_.combined_bounds); + pdlp::combine_constraint_bounds(op_problem_scaled_, op_problem_scaled_.combined_bounds); rmm::device_scalar c_vec_norm{0.0, stream_view_}; - detail::my_l2_weighted_norm(op_problem_scaled_.objective_coefficients, - settings_.hyper_params.initial_primal_weight_c_scaling, - c_vec_norm, - stream_view_); + pdlp::my_l2_weighted_norm(op_problem_scaled_.objective_coefficients, + settings_.hyper_params.initial_primal_weight_c_scaling, + c_vec_norm, + stream_view_); rmm::device_scalar b_vec_norm{0.0, stream_view_}; if (settings_.hyper_params.initial_primal_weight_combined_bounds) { // => same as sqrt(dot(b,b)) - detail::my_l2_weighted_norm(op_problem_scaled_.combined_bounds, - settings_.hyper_params.initial_primal_weight_b_scaling, - b_vec_norm, - stream_view_); + pdlp::my_l2_weighted_norm(op_problem_scaled_.combined_bounds, + settings_.hyper_params.initial_primal_weight_b_scaling, + b_vec_norm, + stream_view_); } else { if (settings_.hyper_params.bound_objective_rescaling) { @@ -3196,7 +3195,7 @@ i_t pdlp_solver_t::get_total_pdhg_iterations() const } template -detail::pdlp_termination_strategy_t& +pdlp::pdlp_termination_strategy_t& pdlp_solver_t::get_current_termination_strategy() { return current_termination_strategy_; @@ -3211,7 +3210,7 @@ template __global__ void compute_weights_initial_primal_weight_from_squared_norm raft::device_span primal_weight, raft::device_span best_primal_weight, int batch_size, - const pdlp_hyper_params::pdlp_hyper_params_t hyper_params); + const pdlp::pdlp_hyper_params_t hyper_params); #endif #if MIP_INSTANTIATE_DOUBLE @@ -3223,7 +3222,7 @@ template __global__ void compute_weights_initial_primal_weight_from_squared_norm raft::device_span primal_weight, raft::device_span best_primal_weight, int batch_size, - const pdlp_hyper_params::pdlp_hyper_params_t hyper_params); + const pdlp::pdlp_hyper_params_t hyper_params); #endif -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::pdlp diff --git a/cpp/src/pdlp/pdlp.cuh b/cpp/src/pdlp/pdlp.cuh index 9447eaeaf3..3735db0cd4 100644 --- a/cpp/src/pdlp/pdlp.cuh +++ b/cpp/src/pdlp/pdlp.cuh @@ -8,8 +8,8 @@ #pragma once #include -#include -#include +#include +#include #include #include @@ -33,7 +33,7 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::pdlp { /** * @brief Solver for an optimization problem (Currently only linear program) to be solved, * pdlp_parameters and pdlp_internal_state @@ -55,10 +55,10 @@ class pdlp_solver_t { * * For full description of algorithm, see https://arxiv.org/abs/2106.04756 * - * @param[in] op_problem An problem_t object with a + * @param[in] op_problem An mip::problem_t object with a * representation of a linear program */ - pdlp_solver_t(problem_t& op_problem, + pdlp_solver_t(mip::problem_t& op_problem, pdlp_solver_settings_t const& settings, bool is_batch_mode = false); @@ -67,7 +67,7 @@ class pdlp_solver_t { f_t get_primal_weight_h(i_t id) const; f_t get_step_size_h(i_t id) const; i_t get_total_pdhg_iterations() const; - detail::pdlp_termination_strategy_t& get_current_termination_strategy(); + pdlp::pdlp_termination_strategy_t& get_current_termination_strategy(); void swap_context(const thrust::universal_host_pinned_vector>& swap_pairs); void resize_context(i_t new_size); @@ -76,7 +76,7 @@ class pdlp_solver_t { void resize_and_swap_all_context_loop( const std::unordered_set& climber_strategies_to_remove); - void set_problem_ptr(problem_t* problem_ptr_); + void set_problem_ptr(mip::problem_t* problem_ptr_); // Interface to let MIP set an initial solution // Users will keep on using the optimization_problem to provide an initial solution @@ -116,8 +116,8 @@ class pdlp_solver_t { optimization_problem_solution_t finalize_batch_return_with_limit_reached( pdlp_termination_status_t limit_reached_status); std::optional> check_limits(const timer_t& timer); - void record_best_primal_so_far(const detail::pdlp_termination_strategy_t& current, - const detail::pdlp_termination_strategy_t& average, + void record_best_primal_so_far(const pdlp::pdlp_termination_strategy_t& current, + const pdlp::pdlp_termination_strategy_t& average, const pdlp_termination_status_t& termination_current, const pdlp_termination_status_t& termination_average); @@ -148,13 +148,12 @@ class pdlp_solver_t { rmm::cuda_stream_view stream_view_; // Intentionnaly take a copy to avoid an unintentional modification in the calling context const pdlp_solver_settings_t settings_; - dual_simplex::shared_strong_branching_context_view_t sb_view_{ - settings_.shared_sb_solved}; + mip::shared_strong_branching_context_view_t sb_view_{settings_.shared_sb_solved}; - problem_t* problem_ptr; + mip::problem_t* problem_ptr; // Combined bounds in op_problem_scaled_ will only be scaled if // compute_initial_primal_weight_before_scaling is false because of compute_initial_primal_weight - problem_t op_problem_scaled_; + mip::problem_t op_problem_scaled_; rmm::device_uvector unscaled_primal_avg_solution_; rmm::device_uvector unscaled_dual_avg_solution_; @@ -182,11 +181,11 @@ class pdlp_solver_t { rmm::device_uvector step_size_; // Step size strategy - detail::adaptive_step_size_strategy_t step_size_strategy_; + pdlp::adaptive_step_size_strategy_t step_size_strategy_; public: // Inner solver - detail::pdhg_solver_t pdhg_solver_; + pdlp::pdhg_solver_t pdhg_solver_; void halpern_update(); private: @@ -203,17 +202,17 @@ class pdlp_solver_t { rmm::device_uvector& dual_slack_to_transpose); // Initial scaling strategy - detail::pdlp_initial_scaling_strategy_t initial_scaling_strategy_; + pdlp::pdlp_initial_scaling_strategy_t initial_scaling_strategy_; // For the average evaluation - detail::cusparse_view_t average_op_problem_evaluation_cusparse_view_; - detail::cusparse_view_t current_op_problem_evaluation_cusparse_view_; + pdlp::cusparse_view_t average_op_problem_evaluation_cusparse_view_; + pdlp::cusparse_view_t current_op_problem_evaluation_cusparse_view_; // Restart strategy - detail::pdlp_restart_strategy_t restart_strategy_; + pdlp::pdlp_restart_strategy_t restart_strategy_; // Termination strategy - detail::pdlp_termination_strategy_t average_termination_strategy_; - detail::pdlp_termination_strategy_t current_termination_strategy_; + pdlp::pdlp_termination_strategy_t average_termination_strategy_; + pdlp::pdlp_termination_strategy_t current_termination_strategy_; /* Two counters are necessary because of the PDLP warm start data * total_pdlp_iterations_: total, counting potential previous PDLP iterations @@ -249,4 +248,4 @@ class pdlp_solver_t { bool inside_mip_{false}; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::pdlp diff --git a/cpp/src/pdlp/pdlp_constants.hpp b/cpp/src/pdlp/pdlp_constants.hpp index 568d7d00b0..1651fd4212 100644 --- a/cpp/src/pdlp/pdlp_constants.hpp +++ b/cpp/src/pdlp/pdlp_constants.hpp @@ -9,7 +9,7 @@ #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::pdlp { inline constexpr int block_size = 128; [[maybe_unused]] static std::pair inline kernel_config_from_batch_size( @@ -69,4 +69,4 @@ template <> inline constexpr double safe_guard_for_extreme_values_in_primal_weight_computation = 1.0e-10; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::pdlp diff --git a/cpp/src/pdlp/pdlp_warm_start_data.cu b/cpp/src/pdlp/pdlp_warm_start_data.cu index 80abf015d8..6039710423 100644 --- a/cpp/src/pdlp/pdlp_warm_start_data.cu +++ b/cpp/src/pdlp/pdlp_warm_start_data.cu @@ -5,8 +5,8 @@ */ /* clang-format on */ -#include -#include +#include +#include #include @@ -16,7 +16,7 @@ #include -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { template pdlp_warm_start_data_t::pdlp_warm_start_data_t( @@ -185,4 +185,4 @@ template class pdlp_warm_start_data_t; #if MIP_INSTANTIATE_DOUBLE template class pdlp_warm_start_data_t; #endif -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/pdlp/restart_strategy/localized_duality_gap_container.cu b/cpp/src/pdlp/restart_strategy/localized_duality_gap_container.cu index bb79e5b6e6..7610e4f7dc 100644 --- a/cpp/src/pdlp/restart_strategy/localized_duality_gap_container.cu +++ b/cpp/src/pdlp/restart_strategy/localized_duality_gap_container.cu @@ -13,16 +13,16 @@ #include -#include +#include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::pdlp { template localized_duality_gap_container_t::localized_duality_gap_container_t( raft::handle_t const* handle_ptr, i_t primal_size, i_t dual_size, const std::vector& climber_strategies, - const pdlp_hyper_params::pdlp_hyper_params_t& hyper_params) + const pdlp::pdlp_hyper_params_t& hyper_params) : primal_size_h_(primal_size), dual_size_h_(dual_size), lagrangian_value_{handle_ptr->get_stream()}, @@ -151,4 +151,4 @@ template struct localized_duality_gap_container_t; template struct localized_duality_gap_container_t; #endif -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::pdlp diff --git a/cpp/src/pdlp/restart_strategy/localized_duality_gap_container.hpp b/cpp/src/pdlp/restart_strategy/localized_duality_gap_container.hpp index 3a179521c1..283d00c4db 100644 --- a/cpp/src/pdlp/restart_strategy/localized_duality_gap_container.hpp +++ b/cpp/src/pdlp/restart_strategy/localized_duality_gap_container.hpp @@ -6,7 +6,7 @@ /* clang-format on */ #pragma once -#include +#include #include #include @@ -17,7 +17,7 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::pdlp { template struct localized_duality_gap_container_t { public: @@ -25,7 +25,7 @@ struct localized_duality_gap_container_t { i_t primal_size, i_t dual_size, const std::vector& climber_strategies, - const pdlp_hyper_params::pdlp_hyper_params_t& hyper_params); + const pdlp::pdlp_hyper_params_t& hyper_params); struct view_t { /** size of primal problem */ @@ -48,7 +48,7 @@ struct localized_duality_gap_container_t { f_t* primal_solution_tr; f_t* dual_solution_tr; - pdlp_hyper_params::pdlp_hyper_params_t hyper_params; + pdlp::pdlp_hyper_params_t hyper_params; }; void swap_context(const thrust::universal_host_pinned_vector>& swap_pairs); @@ -77,4 +77,4 @@ struct localized_duality_gap_container_t { rmm::device_uvector primal_solution_tr_; rmm::device_uvector dual_solution_tr_; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::pdlp diff --git a/cpp/src/pdlp/restart_strategy/pdlp_restart_strategy.cu b/cpp/src/pdlp/restart_strategy/pdlp_restart_strategy.cu index 17c7abcac5..85bc703a05 100644 --- a/cpp/src/pdlp/restart_strategy/pdlp_restart_strategy.cu +++ b/cpp/src/pdlp/restart_strategy/pdlp_restart_strategy.cu @@ -7,7 +7,7 @@ #include -#include +#include #include #include #include @@ -50,12 +50,12 @@ namespace cg = cooperative_groups; -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::pdlp { template __global__ void solve_bound_constrained_trust_region_kernel( typename pdlp_restart_strategy_t::view_t restart_strategy_view, - typename problem_t::view_t op_problem_view, + typename mip::problem_t::view_t op_problem_view, i_t* testing_range_low, i_t* testing_range_high, f_t* test_radius_squared, @@ -66,13 +66,13 @@ __global__ void solve_bound_constrained_trust_region_kernel( template pdlp_restart_strategy_t::pdlp_restart_strategy_t( raft::handle_t const* handle_ptr, - problem_t& op_problem, + mip::problem_t& op_problem, const cusparse_view_t& cusparse_view, const i_t primal_size, const i_t dual_size, bool is_legacy_batch_mode, const std::vector& climber_strategies, - const pdlp_hyper_params::pdlp_hyper_params_t& hyper_params) + const pdlp::pdlp_hyper_params_t& hyper_params) : handle_ptr_(handle_ptr), stream_view_(handle_ptr_->get_stream()), batch_mode_(climber_strategies.size() > 1), @@ -1585,7 +1585,7 @@ compute_median(const typename pdlp_restart_strategy_t::view_t& restart template DI void clamp_test_points( const typename pdlp_restart_strategy_t::view_t& restart_strategy_view, - const typename problem_t::view_t& op_problem_view, + const typename mip::problem_t::view_t& op_problem_view, f_t test_threshold, i_t range_low, i_t range_high) @@ -1756,7 +1756,7 @@ DI void update_range_low( template __global__ void solve_bound_constrained_trust_region_kernel( typename pdlp_restart_strategy_t::view_t restart_strategy_view, - typename problem_t::view_t op_problem_view, + typename mip::problem_t::view_t op_problem_view, i_t* testing_range_low, i_t* testing_range_high, f_t* test_radius_squared, @@ -2222,7 +2222,7 @@ void pdlp_restart_strategy_t::compute_primal_gradient( template __global__ void compute_subgradient_kernel( const typename pdlp_restart_strategy_t::view_t restart_strategy_view, - const typename problem_t::view_t op_problem_view, + const typename mip::problem_t::view_t op_problem_view, const typename localized_duality_gap_container_t::view_t duality_gap_view, f_t* subgradient) { @@ -2500,7 +2500,7 @@ bool pdlp_restart_strategy_t::get_last_restart_was_average() const \ template __global__ void solve_bound_constrained_trust_region_kernel( \ typename pdlp_restart_strategy_t::view_t restart_strategy_view, \ - typename problem_t::view_t op_problem_view, \ + typename mip::problem_t::view_t op_problem_view, \ int* testing_range_low, \ int* testing_range_high, \ F_TYPE* test_radius_squared, \ @@ -2527,7 +2527,7 @@ bool pdlp_restart_strategy_t::get_last_restart_was_average() const \ template __global__ void compute_subgradient_kernel( \ const typename pdlp_restart_strategy_t::view_t restart_strategy_view, \ - const typename problem_t::view_t op_problem_view, \ + const typename mip::problem_t::view_t op_problem_view, \ const typename localized_duality_gap_container_t::view_t duality_gap_view, \ F_TYPE* primal_product); @@ -2539,4 +2539,4 @@ INSTANTIATE(float) INSTANTIATE(double) #endif -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::pdlp diff --git a/cpp/src/pdlp/restart_strategy/pdlp_restart_strategy.cuh b/cpp/src/pdlp/restart_strategy/pdlp_restart_strategy.cuh index 0c00e50240..03f9350314 100644 --- a/cpp/src/pdlp/restart_strategy/pdlp_restart_strategy.cuh +++ b/cpp/src/pdlp/restart_strategy/pdlp_restart_strategy.cuh @@ -15,7 +15,7 @@ #include #include -#include +#include #include @@ -28,7 +28,7 @@ #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::pdlp { template class pdlp_restart_strategy_t { public: @@ -80,7 +80,7 @@ class pdlp_restart_strategy_t { i_t* testing_range_high; raft::device_span shared_live_kernel_accumulator; - pdlp_hyper_params::pdlp_hyper_params_t hyper_params; + pdlp::pdlp_hyper_params_t hyper_params; }; struct cupdlpx_restart_view_t { @@ -98,7 +98,7 @@ class pdlp_restart_strategy_t { raft::device_span new_primal_step_size; raft::device_span new_dual_step_size; raft::device_span best_primal_dual_residual_gap; - pdlp_hyper_params::pdlp_hyper_params_t hyper_params; + pdlp::pdlp_hyper_params_t hyper_params; }; enum class restart_strategy_t { @@ -112,13 +112,13 @@ class pdlp_restart_strategy_t { void resize_context(i_t new_size); pdlp_restart_strategy_t(raft::handle_t const* handle_ptr, - problem_t& op_problem, + mip::problem_t& op_problem, const cusparse_view_t& cusparse_view, const i_t primal_size, const i_t dual_size, bool is_legacy_batch_mode, const std::vector& climber_strategies_, - const pdlp_hyper_params::pdlp_hyper_params_t& hyper_params); + const pdlp::pdlp_hyper_params_t& hyper_params); // Compute kkt score on passed argument using the container tmp_kkt score and stream view f_t compute_kkt_score(const rmm::device_uvector& l2_primal_residual, @@ -308,7 +308,7 @@ class pdlp_restart_strategy_t { i_t primal_size_h_; i_t dual_size_h_; - problem_t* problem_ptr; + mip::problem_t* problem_ptr; rmm::device_scalar primal_norm_weight_; rmm::device_scalar dual_norm_weight_; @@ -386,11 +386,11 @@ class pdlp_restart_strategy_t { thrust::universal_host_pinned_vector best_primal_dual_residual_gap_; const std::vector& climber_strategies_; - const pdlp_hyper_params::pdlp_hyper_params_t& hyper_params_; + const pdlp::pdlp_hyper_params_t& hyper_params_; }; template -bool is_trust_region_restart(const pdlp_hyper_params::pdlp_hyper_params_t& hyper_params) +bool is_trust_region_restart(const pdlp::pdlp_hyper_params_t& hyper_params) { return hyper_params.restart_strategy == static_cast( @@ -398,17 +398,17 @@ bool is_trust_region_restart(const pdlp_hyper_params::pdlp_hyper_params_t& hyper } template -bool is_kkt_restart(const pdlp_hyper_params::pdlp_hyper_params_t& hyper_params) +bool is_kkt_restart(const pdlp::pdlp_hyper_params_t& hyper_params) { return hyper_params.restart_strategy == static_cast(pdlp_restart_strategy_t::restart_strategy_t::KKT_RESTART); } template -bool is_cupdlpx_restart(const pdlp_hyper_params::pdlp_hyper_params_t& hyper_params) +bool is_cupdlpx_restart(const pdlp::pdlp_hyper_params_t& hyper_params) { return hyper_params.restart_strategy == static_cast(pdlp_restart_strategy_t::restart_strategy_t::CUPDLPX_RESTART); } -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::pdlp diff --git a/cpp/src/pdlp/restart_strategy/weighted_average_solution.cu b/cpp/src/pdlp/restart_strategy/weighted_average_solution.cu index 098ad7911b..9dc75e0620 100644 --- a/cpp/src/pdlp/restart_strategy/weighted_average_solution.cu +++ b/cpp/src/pdlp/restart_strategy/weighted_average_solution.cu @@ -15,7 +15,7 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::pdlp { template weighted_average_solution_t::weighted_average_solution_t(raft::handle_t const* handle_ptr, i_t primal_size, @@ -152,4 +152,4 @@ template __global__ void add_weight_sums(const double* primal_weight, template class weighted_average_solution_t; #endif -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::pdlp diff --git a/cpp/src/pdlp/restart_strategy/weighted_average_solution.hpp b/cpp/src/pdlp/restart_strategy/weighted_average_solution.hpp index c30ec0dceb..777f9ea804 100644 --- a/cpp/src/pdlp/restart_strategy/weighted_average_solution.hpp +++ b/cpp/src/pdlp/restart_strategy/weighted_average_solution.hpp @@ -15,7 +15,7 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::pdlp { template class weighted_average_solution_t { public: @@ -52,4 +52,4 @@ class weighted_average_solution_t { // Graph to capture the average computation ping_pong_graph_t graph; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::pdlp diff --git a/cpp/src/pdlp/saddle_point.cu b/cpp/src/pdlp/saddle_point.cu index f740176a3c..9267a7ced6 100644 --- a/cpp/src/pdlp/saddle_point.cu +++ b/cpp/src/pdlp/saddle_point.cu @@ -15,15 +15,14 @@ #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::pdlp { template -saddle_point_state_t::saddle_point_state_t( - raft::handle_t const* handle_ptr, - const i_t primal_size, - const i_t dual_size, - const size_t batch_size, - const pdlp_hyper_params::pdlp_hyper_params_t& hyper_params) +saddle_point_state_t::saddle_point_state_t(raft::handle_t const* handle_ptr, + const i_t primal_size, + const i_t dual_size, + const size_t batch_size, + const pdlp::pdlp_hyper_params_t& hyper_params) : primal_size_{primal_size}, dual_size_{dual_size}, primal_solution_{batch_size * primal_size, handle_ptr->get_stream()}, @@ -179,4 +178,4 @@ template class saddle_point_state_t; template class saddle_point_state_t; #endif -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::pdlp diff --git a/cpp/src/pdlp/saddle_point.hpp b/cpp/src/pdlp/saddle_point.hpp index eb6b8025cf..c6fc962016 100644 --- a/cpp/src/pdlp/saddle_point.hpp +++ b/cpp/src/pdlp/saddle_point.hpp @@ -7,7 +7,7 @@ #pragma once -#include +#include #include @@ -17,7 +17,7 @@ #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::pdlp { /** * @brief Structure to hold the current solution to the saddle point problem * @@ -67,7 +67,7 @@ class saddle_point_state_t { i_t primal_size, i_t dual_size, size_t batch_size, - const pdlp_hyper_params::pdlp_hyper_params_t& hyper_params); + const pdlp::pdlp_hyper_params_t& hyper_params); /** * @brief Copies the values of the solutions in another saddle_point_state_t @@ -115,4 +115,4 @@ class saddle_point_state_t { rmm::device_uvector next_AtY_; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::pdlp diff --git a/cpp/src/pdlp/solution_conversion.cu b/cpp/src/pdlp/solution_conversion.cu index 8ec3c20b27..4e7336ea93 100644 --- a/cpp/src/pdlp/solution_conversion.cu +++ b/cpp/src/pdlp/solution_conversion.cu @@ -10,14 +10,14 @@ * @brief Implementations of conversion methods from solution classes to Cython ret structs */ -#include -#include -#include +#include +#include +#include #include #include -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { // =========================== // GPU LP Solution Conversion @@ -222,4 +222,4 @@ template cuopt::cython::linear_programming_ret_t cpu_lp_solution_t::to_cpu_linear_programming_ret_t(); template cuopt::cython::mip_ret_t cpu_mip_solution_t::to_cpu_mip_ret_t(); -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/pdlp/solve.cu b/cpp/src/pdlp/solve.cu index 5d29e97fa0..08b580b6a6 100644 --- a/cpp/src/pdlp/solve.cu +++ b/cpp/src/pdlp/solve.cu @@ -6,7 +6,7 @@ /* clang-format on */ #include -#include +#include #include #include #include @@ -25,17 +25,17 @@ #include #include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include #include #include #include @@ -68,7 +68,7 @@ #define CUOPT_LOG_CONDITIONAL_INFO(condition, ...) \ if ((condition)) { CUOPT_LOG_INFO(__VA_ARGS__); } -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { template extern rmm::device_uvector gpu_cast(const rmm::device_uvector& src, @@ -86,7 +86,7 @@ static void init_handler(const raft::handle_t* handle_ptr) // Corresponds to the first good general settings we found // It's what was used for the GTC results -static void set_Stable1(pdlp_hyper_params::pdlp_hyper_params_t& hyper_params) +static void set_Stable1(pdlp::pdlp_hyper_params_t& hyper_params) { hyper_params.initial_step_size_scaling = 1.6; hyper_params.default_l_inf_ruiz_iterations = 1; @@ -129,7 +129,7 @@ static void set_Stable1(pdlp_hyper_params::pdlp_hyper_params_t& hyper_params) // Even better general setting due to proper primal gradient handling for KKT restart and initial // projection -static void set_Stable2(pdlp_hyper_params::pdlp_hyper_params_t& hyper_params) +static void set_Stable2(pdlp::pdlp_hyper_params_t& hyper_params) { hyper_params.initial_step_size_scaling = 1.0; hyper_params.default_l_inf_ruiz_iterations = 10; @@ -186,7 +186,7 @@ static void set_Stable2(pdlp_hyper_params::pdlp_hyper_params_t& hyper_params) * year={2024} * } */ -static void set_Stable3(pdlp_hyper_params::pdlp_hyper_params_t& hyper_params) +static void set_Stable3(pdlp::pdlp_hyper_params_t& hyper_params) { hyper_params.initial_step_size_scaling = 1.0; hyper_params.default_l_inf_ruiz_iterations = 10; @@ -229,7 +229,7 @@ static void set_Stable3(pdlp_hyper_params::pdlp_hyper_params_t& hyper_params) } // Legacy/Original/Initial PDLP settings -static void set_Methodical1(pdlp_hyper_params::pdlp_hyper_params_t& hyper_params) +static void set_Methodical1(pdlp::pdlp_hyper_params_t& hyper_params) { hyper_params.initial_step_size_scaling = 1.0; hyper_params.default_l_inf_ruiz_iterations = 5; @@ -272,7 +272,7 @@ static void set_Methodical1(pdlp_hyper_params::pdlp_hyper_params_t& hyper_params // Can be extremly faster but usually leads to more divergence // Used for the blog post results -static void set_Fast1(pdlp_hyper_params::pdlp_hyper_params_t& hyper_params) +static void set_Fast1(pdlp::pdlp_hyper_params_t& hyper_params) { hyper_params.initial_step_size_scaling = 0.8; hyper_params.default_l_inf_ruiz_iterations = 6; @@ -354,30 +354,28 @@ void adjust_dual_solution_and_reduced_cost(rmm::device_uvector& dual_soluti template optimization_problem_solution_t convert_dual_simplex_sol( - const dual_simplex::lp_solution_t& solution, + const simplex::lp_solution_t& solution, raft::handle_t const* handle_ptr, std::string const& objective_name, std::vector const& var_names, std::vector const& row_names, bool maximize, - dual_simplex::lp_status_t status, + simplex::lp_status_t status, f_t duration, f_t norm_user_objective, f_t norm_rhs, method_t method) { - auto to_termination_status = [](dual_simplex::lp_status_t status) { + auto to_termination_status = [](simplex::lp_status_t status) { switch (status) { - case dual_simplex::lp_status_t::OPTIMAL: return pdlp_termination_status_t::Optimal; - case dual_simplex::lp_status_t::INFEASIBLE: - return pdlp_termination_status_t::PrimalInfeasible; - case dual_simplex::lp_status_t::UNBOUNDED: return pdlp_termination_status_t::DualInfeasible; - case dual_simplex::lp_status_t::TIME_LIMIT: return pdlp_termination_status_t::TimeLimit; - case dual_simplex::lp_status_t::ITERATION_LIMIT: - return pdlp_termination_status_t::IterationLimit; - case dual_simplex::lp_status_t::CONCURRENT_LIMIT: + case simplex::lp_status_t::OPTIMAL: return pdlp_termination_status_t::Optimal; + case simplex::lp_status_t::INFEASIBLE: return pdlp_termination_status_t::PrimalInfeasible; + case simplex::lp_status_t::UNBOUNDED: return pdlp_termination_status_t::DualInfeasible; + case simplex::lp_status_t::TIME_LIMIT: return pdlp_termination_status_t::TimeLimit; + case simplex::lp_status_t::ITERATION_LIMIT: return pdlp_termination_status_t::IterationLimit; + case simplex::lp_status_t::CONCURRENT_LIMIT: return pdlp_termination_status_t::ConcurrentLimit; - case dual_simplex::lp_status_t::UNBOUNDED_OR_INFEASIBLE: + case simplex::lp_status_t::UNBOUNDED_OR_INFEASIBLE: return pdlp_termination_status_t::UnboundedOrInfeasible; default: return pdlp_termination_status_t::NumericalError; } @@ -443,9 +441,9 @@ optimization_problem_solution_t convert_dual_simplex_sol( template optimization_problem_solution_t convert_dual_simplex_sol( - detail::problem_t& problem, - const dual_simplex::lp_solution_t& solution, - dual_simplex::lp_status_t status, + mip::problem_t& problem, + const simplex::lp_solution_t& solution, + simplex::lp_status_t status, f_t duration, f_t norm_user_objective, f_t norm_rhs, @@ -467,8 +465,8 @@ optimization_problem_solution_t convert_dual_simplex_sol( template optimization_problem_solution_t convert_dual_simplex_sol( optimization_problem_t& op_problem, - const dual_simplex::lp_solution_t& solution, - dual_simplex::lp_status_t status, + const simplex::lp_solution_t& solution, + simplex::lp_status_t status, f_t duration, f_t norm_user_objective, f_t norm_rhs, @@ -488,15 +486,15 @@ optimization_problem_solution_t convert_dual_simplex_sol( } template -std::tuple, dual_simplex::lp_status_t, f_t, f_t, f_t> -run_barrier(dual_simplex::user_problem_t& user_problem, - pdlp_solver_settings_t const& settings, - const timer_t& timer) +std::tuple, simplex::lp_status_t, f_t, f_t, f_t> run_barrier( + simplex::user_problem_t& user_problem, + pdlp_solver_settings_t const& settings, + const timer_t& timer) { - f_t norm_user_objective = dual_simplex::vector_norm2(user_problem.objective); - f_t norm_rhs = dual_simplex::vector_norm2(user_problem.rhs); + f_t norm_user_objective = simplex::vector_norm2(user_problem.objective); + f_t norm_rhs = simplex::vector_norm2(user_problem.rhs); - dual_simplex::simplex_solver_settings_t barrier_settings; + simplex::simplex_solver_settings_t barrier_settings; barrier_settings.num_gpus = settings.num_gpus; barrier_settings.time_limit = settings.time_limit; barrier_settings.iteration_limit = settings.iteration_limit; @@ -521,20 +519,19 @@ run_barrier(dual_simplex::user_problem_t& user_problem, barrier_settings.log.log = false; } - dual_simplex::lp_solution_t solution(user_problem.num_rows, user_problem.num_cols); - auto status = dual_simplex::solve_linear_program_with_barrier( + simplex::lp_solution_t solution(user_problem.num_rows, user_problem.num_cols); + auto status = simplex::solve_linear_program_with_barrier( user_problem, barrier_settings, timer.get_tic_start(), solution); - detail::project_barrier_solution_to_model_variables(user_problem, solution); + barrier::project_barrier_solution_to_model_variables(user_problem, solution); CUOPT_LOG_CONDITIONAL_INFO( !settings.inside_mip, "Barrier finished in %.2f seconds", timer.elapsed_time()); 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 || - status == dual_simplex::lp_status_t::UNBOUNDED_OR_INFEASIBLE)) { + (status == simplex::lp_status_t::OPTIMAL || status == simplex::lp_status_t::UNBOUNDED || + status == simplex::lp_status_t::INFEASIBLE || + status == simplex::lp_status_t::UNBOUNDED_OR_INFEASIBLE)) { // We finished. Tell PDLP to stop if it is still running. *settings.concurrent_halt = 1; } @@ -544,12 +541,12 @@ run_barrier(dual_simplex::user_problem_t& user_problem, template optimization_problem_solution_t run_barrier( - detail::problem_t& problem, + mip::problem_t& problem, pdlp_solver_settings_t const& settings, const timer_t& timer) { // Convert data structures to dual simplex format and back - dual_simplex::user_problem_t dual_simplex_problem = + simplex::user_problem_t dual_simplex_problem = cuopt_problem_to_user_problem(problem.handle_ptr, problem); auto sol_dual_simplex = run_barrier(dual_simplex_problem, settings, timer); return convert_dual_simplex_sol(problem, @@ -563,16 +560,15 @@ optimization_problem_solution_t run_barrier( template void run_barrier_thread( - dual_simplex::user_problem_t& problem, + simplex::user_problem_t& problem, pdlp_solver_settings_t const& settings, std::unique_ptr< - std::tuple, dual_simplex::lp_status_t, f_t, f_t, f_t>>& - sol_ptr, + std::tuple, simplex::lp_status_t, f_t, f_t, f_t>>& sol_ptr, const timer_t& timer) { // We will return the solution from the thread as a unique_ptr sol_ptr = std::make_unique< - std::tuple, dual_simplex::lp_status_t, f_t, f_t, f_t>>( + std::tuple, simplex::lp_status_t, f_t, f_t, f_t>>( run_barrier(problem, settings, timer)); // Wait for barrier thread to finish @@ -580,15 +576,15 @@ void run_barrier_thread( } template -std::tuple, dual_simplex::lp_status_t, f_t, f_t, f_t> -run_dual_simplex(dual_simplex::user_problem_t& user_problem, - pdlp_solver_settings_t const& settings, - const timer_t& timer) +std::tuple, simplex::lp_status_t, f_t, f_t, f_t> run_dual_simplex( + simplex::user_problem_t& user_problem, + pdlp_solver_settings_t const& settings, + const timer_t& timer) { - f_t norm_user_objective = dual_simplex::vector_norm2(user_problem.objective); - f_t norm_rhs = dual_simplex::vector_norm2(user_problem.rhs); + f_t norm_user_objective = simplex::vector_norm2(user_problem.objective); + f_t norm_rhs = simplex::vector_norm2(user_problem.rhs); - dual_simplex::simplex_solver_settings_t dual_simplex_settings; + simplex::simplex_solver_settings_t dual_simplex_settings; dual_simplex_settings.time_limit = settings.time_limit; dual_simplex_settings.iteration_limit = settings.iteration_limit; dual_simplex_settings.concurrent_halt = settings.concurrent_halt; @@ -597,18 +593,17 @@ run_dual_simplex(dual_simplex::user_problem_t& user_problem, dual_simplex_settings.log.log = false; } - dual_simplex::lp_solution_t solution(user_problem.num_rows, user_problem.num_cols); - auto status = dual_simplex::solve_linear_program( + simplex::lp_solution_t solution(user_problem.num_rows, user_problem.num_cols); + auto status = simplex::solve_linear_program( user_problem, dual_simplex_settings, timer.get_tic_start(), solution); CUOPT_LOG_CONDITIONAL_INFO( !settings.inside_mip, "Dual simplex finished in %.2f seconds", timer.elapsed_time()); 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 || - status == dual_simplex::lp_status_t::UNBOUNDED_OR_INFEASIBLE)) { + (status == simplex::lp_status_t::OPTIMAL || status == simplex::lp_status_t::UNBOUNDED || + status == simplex::lp_status_t::INFEASIBLE || + status == simplex::lp_status_t::UNBOUNDED_OR_INFEASIBLE)) { // We finished. Tell PDLP to stop if it is still running. *settings.concurrent_halt = 1; } @@ -618,12 +613,12 @@ run_dual_simplex(dual_simplex::user_problem_t& user_problem, template optimization_problem_solution_t run_dual_simplex( - detail::problem_t& problem, + mip::problem_t& problem, pdlp_solver_settings_t const& settings, const timer_t& timer) { // Convert data structures to dual simplex format and back - dual_simplex::user_problem_t dual_simplex_problem = + simplex::user_problem_t dual_simplex_problem = cuopt_problem_to_user_problem(problem.handle_ptr, problem); auto sol_dual_simplex = run_dual_simplex(dual_simplex_problem, settings, timer); return convert_dual_simplex_sol(problem, @@ -639,7 +634,7 @@ optimization_problem_solution_t run_dual_simplex( template static optimization_problem_solution_t run_pdlp_solver_in_fp32( - detail::problem_t& problem, + mip::problem_t& problem, pdlp_solver_settings_t const& settings, const timer_t& timer, bool is_batch_mode) @@ -653,7 +648,7 @@ static optimization_problem_solution_t run_pdlp_solver_in_fp32( float_op.set_objective_scaling_factor( static_cast(problem.presolve_data.objective_scaling_factor)); - detail::problem_t float_problem(float_op); + mip::problem_t float_problem(float_op); auto objective_name = problem.objective_name; auto var_names = problem.var_names; @@ -662,7 +657,7 @@ static optimization_problem_solution_t run_pdlp_solver_in_fp32( // When crossover is on, run_pdlp needs the problem data after we return. if (!settings.crossover) { { - [[maybe_unused]] auto discard = detail::problem_t(std::move(problem)); + [[maybe_unused]] auto discard = mip::problem_t(std::move(problem)); } } @@ -706,7 +701,7 @@ static optimization_problem_solution_t run_pdlp_solver_in_fp32( fs.num_gpus = settings.num_gpus; fs.concurrent_halt = settings.concurrent_halt; - detail::pdlp_solver_t solver(float_problem, fs, is_batch_mode); + pdlp::pdlp_solver_t solver(float_problem, fs, is_batch_mode); if (settings.inside_mip) { solver.set_inside_mip(true); } auto float_sol = solver.run_solver(timer); @@ -756,7 +751,7 @@ static optimization_problem_solution_t run_pdlp_solver_in_fp32( template static optimization_problem_solution_t run_pdlp_solver( - detail::problem_t& problem, + mip::problem_t& problem, pdlp_solver_settings_t const& settings, const timer_t& timer, bool is_batch_mode) @@ -775,13 +770,13 @@ static optimization_problem_solution_t run_pdlp_solver( } } #endif - detail::pdlp_solver_t solver(problem, settings, is_batch_mode); + pdlp::pdlp_solver_t solver(problem, settings, is_batch_mode); if (settings.inside_mip) { solver.set_inside_mip(true); } return solver.run_solver(timer); } template -optimization_problem_solution_t run_pdlp(detail::problem_t& problem, +optimization_problem_solution_t run_pdlp(mip::problem_t& problem, pdlp_solver_settings_t const& settings, const timer_t& timer, bool is_batch_mode) @@ -792,7 +787,7 @@ optimization_problem_solution_t run_pdlp(detail::problem_t& "PDLP batch mode is not supported for float precision. Use double precision."); } cuopt_expects(!(settings.pdlp_precision == pdlp_precision_t::MixedPrecision && - !detail::is_cusparse_runtime_mixed_precision_supported()), + !pdlp::is_cusparse_runtime_mixed_precision_supported()), error_type_t::ValidationError, "Mixed-precision SpMV requires cuSPARSE runtime 12.5 or later."); cuopt_expects( @@ -831,41 +826,39 @@ optimization_problem_solution_t run_pdlp(detail::problem_t& if (do_crossover && sol.get_termination_status() == pdlp_termination_status_t::Optimal) { crossover_info = -1; - dual_simplex::lp_problem_t lp(problem.handle_ptr, 1, 1, 1); - dual_simplex::lp_solution_t initial_solution(1, 1); + simplex::lp_problem_t lp(problem.handle_ptr, 1, 1, 1); + simplex::lp_solution_t initial_solution(1, 1); translate_to_crossover_problem(problem, sol, lp, initial_solution); - dual_simplex::simplex_solver_settings_t dual_simplex_settings; + simplex::simplex_solver_settings_t dual_simplex_settings; dual_simplex_settings.time_limit = settings.time_limit; dual_simplex_settings.iteration_limit = settings.iteration_limit; dual_simplex_settings.concurrent_halt = settings.concurrent_halt; - dual_simplex::lp_solution_t vertex_solution(lp.num_rows, lp.num_cols); - std::vector vstatus(lp.num_cols); - dual_simplex::crossover_status_t crossover_status = - dual_simplex::crossover(lp, - dual_simplex_settings, - initial_solution, - timer.get_tic_start(), - vertex_solution, - vstatus); + simplex::lp_solution_t vertex_solution(lp.num_rows, lp.num_cols); + std::vector vstatus(lp.num_cols); + simplex::crossover_status_t crossover_status = simplex::crossover(lp, + dual_simplex_settings, + initial_solution, + timer.get_tic_start(), + vertex_solution, + vstatus); pdlp_termination_status_t termination_status = pdlp_termination_status_t::TimeLimit; - auto to_termination_status = [](dual_simplex::crossover_status_t status) { + auto to_termination_status = [](simplex::crossover_status_t status) { switch (status) { - case dual_simplex::crossover_status_t::OPTIMAL: return pdlp_termination_status_t::Optimal; - case dual_simplex::crossover_status_t::PRIMAL_FEASIBLE: + case simplex::crossover_status_t::OPTIMAL: return pdlp_termination_status_t::Optimal; + case simplex::crossover_status_t::PRIMAL_FEASIBLE: return pdlp_termination_status_t::PrimalFeasible; - case dual_simplex::crossover_status_t::DUAL_FEASIBLE: + case simplex::crossover_status_t::DUAL_FEASIBLE: return pdlp_termination_status_t::NumericalError; - case dual_simplex::crossover_status_t::NUMERICAL_ISSUES: + case simplex::crossover_status_t::NUMERICAL_ISSUES: return pdlp_termination_status_t::NumericalError; - case dual_simplex::crossover_status_t::CONCURRENT_LIMIT: + case simplex::crossover_status_t::CONCURRENT_LIMIT: return pdlp_termination_status_t::ConcurrentLimit; - case dual_simplex::crossover_status_t::TIME_LIMIT: - return pdlp_termination_status_t::TimeLimit; + case simplex::crossover_status_t::TIME_LIMIT: return pdlp_termination_status_t::TimeLimit; default: return pdlp_termination_status_t::NumericalError; } }; termination_status = to_termination_status(crossover_status); - if (crossover_status == dual_simplex::crossover_status_t::OPTIMAL) { crossover_info = 0; } + if (crossover_status == simplex::crossover_status_t::OPTIMAL) { crossover_info = 0; } rmm::device_uvector final_primal_solution = cuopt::device_copy(vertex_solution.x, problem.handle_ptr->get_stream()); rmm::device_uvector final_dual_solution = @@ -1016,7 +1009,7 @@ static void apply_batch_settings_overrides( return given_value == default_value ? override_value : given_value; }; - batch_settings.method = cuopt::linear_programming::method_t::PDLP; + batch_settings.method = cuopt::mathematical_optimization::method_t::PDLP; batch_settings.presolver = presolver_t::None; batch_settings.pdlp_solver_mode = pdlp_solver_mode_t::Stable3; batch_settings.detect_infeasibility = false; @@ -1327,7 +1320,7 @@ static optimization_problem_solution_t run_batch_pdlp_splitting( } size_t optimal_batch_size = use_optimal_batch_size - ? detail::optimal_batch_size_handler(problem, memory_max_batch_size) + ? pdlp::optimal_batch_size_handler(problem, memory_max_batch_size) : max_batch_size; if (settings.fixed_batch_size > 0) { optimal_batch_size = settings.fixed_batch_size; } cuopt_assert(optimal_batch_size != 0 && optimal_batch_size <= max_batch_size, @@ -1448,7 +1441,7 @@ size_t compute_optimal_batch_size(const optimization_problem_t& proble // Now find the optimal batch size [0, memory_max_batch_size] const size_t optimal_batch_size = static_cast( - detail::optimal_batch_size_handler(problem, static_cast(memory_max_batch_size))); + pdlp::optimal_batch_size_handler(problem, static_cast(memory_max_batch_size))); #ifdef BATCH_VERBOSE_MODE std::cout << "Optimal batch size: " << optimal_batch_size << std::endl; #endif @@ -1458,7 +1451,7 @@ size_t compute_optimal_batch_size(const optimization_problem_t& proble template optimization_problem_solution_t batch_pdlp_solve( raft::handle_t const* handle_ptr, - const cuopt::linear_programming::io::mps_data_model_t& mps_model, + const cuopt::mathematical_optimization::io::mps_data_model_t& mps_model, const std::vector& fractional, const std::vector& root_soln_x, pdlp_solver_settings_t const& settings_const) @@ -1496,22 +1489,21 @@ optimization_problem_solution_t batch_pdlp_solve( template void run_dual_simplex_thread( - dual_simplex::user_problem_t& problem, + simplex::user_problem_t& problem, pdlp_solver_settings_t const& settings, std::unique_ptr< - std::tuple, dual_simplex::lp_status_t, f_t, f_t, f_t>>& - sol_ptr, + std::tuple, simplex::lp_status_t, f_t, f_t, f_t>>& sol_ptr, const timer_t& timer) { // We will return the solution from the thread as a unique_ptr sol_ptr = std::make_unique< - std::tuple, dual_simplex::lp_status_t, f_t, f_t, f_t>>( + std::tuple, simplex::lp_status_t, f_t, f_t, f_t>>( run_dual_simplex(problem, settings, timer)); } template optimization_problem_solution_t run_concurrent( - detail::problem_t& problem, + mip::problem_t& problem, pdlp_solver_settings_t const& settings, const timer_t& timer, bool is_batch_mode) @@ -1550,11 +1542,10 @@ optimization_problem_solution_t run_concurrent( // Initialize the dual simplex structures before we run PDLP. // Otherwise, CUDA API calls to the problem stream may occur in both threads and throw graph // capture off - dual_simplex::user_problem_t dual_simplex_problem = + simplex::user_problem_t dual_simplex_problem = cuopt_problem_to_user_problem(problem.handle_ptr, problem); // Dual simplex / barrier results — written by tasks, read after the taskgroup barrier. - std::unique_ptr< - std::tuple, dual_simplex::lp_status_t, f_t, f_t, f_t>> + std::unique_ptr, simplex::lp_status_t, f_t, f_t, f_t>> sol_dual_simplex_ptr; std::exception_ptr dual_simplex_exception; auto request_concurrent_halt = [&settings_pdlp]() { @@ -1576,8 +1567,7 @@ optimization_problem_solution_t run_concurrent( // Dispatch barrier + dual simplex as OMP tasks (not std::threads) so they consume slots from // the upstream MIP OMP team and respect num_cpu_threads. PDLP runs synchronously on the // dispatching thread; the taskgroup implicit barrier joins the tasks. - std::unique_ptr< - std::tuple, dual_simplex::lp_status_t, f_t, f_t, f_t>> + std::unique_ptr, simplex::lp_status_t, f_t, f_t, f_t>> sol_barrier_ptr; std::exception_ptr barrier_exception; std::exception_ptr pdlp_exception; @@ -1756,7 +1746,7 @@ optimization_problem_solution_t run_concurrent( template optimization_problem_solution_t solve_lp_with_method( - detail::problem_t& problem, + mip::problem_t& problem, pdlp_solver_settings_t const& settings, const timer_t& timer, bool is_batch_mode) @@ -1832,7 +1822,7 @@ optimization_problem_solution_t solve_qcqp( op_problem.write_to_mps(settings.user_problem_file); } // Convert data structures to dual simplex format and back - dual_simplex::user_problem_t dual_simplex_problem = + simplex::user_problem_t dual_simplex_problem = cuopt_optimization_problem_to_user_problem(op_problem.get_handle_ptr(), op_problem); auto sol_dual_simplex = run_barrier(dual_simplex_problem, settings, qcqp_timer); auto solution = convert_dual_simplex_sol(op_problem, @@ -1927,7 +1917,7 @@ optimization_problem_solution_t solve_lp( validate_new_bounds(op_problem, settings); auto lp_timer = cuopt::timer_t(settings.time_limit); - detail::problem_t problem(op_problem); + mip::problem_t problem(op_problem); // handle default presolve if (settings.presolver == presolver_t::Default) { constexpr i_t presolve_nnz_threshold = 8000; @@ -1948,39 +1938,39 @@ optimization_problem_solution_t solve_lp( } [[maybe_unused]] double presolve_time = 0.0; - std::unique_ptr> presolver; + std::unique_ptr> presolver; auto run_presolve = settings.presolver != presolver_t::None; run_presolve = run_presolve && settings.get_pdlp_warm_start_data().total_pdlp_iterations_ == -1; // Declare result at outer scope so that result.reduced_problem (which may be // referenced by problem.original_problem_ptr) remains alive through the solve. - std::optional> result; + std::optional> result; if (run_presolve) { - detail::sort_csr(op_problem); + mip::sort_csr(op_problem); // allocate no more than 10% of the time limit to presolve. // Note that this is not the presolve time, but the time limit for presolve. // But no less than 1 second, to avoid early timeout triggering known crashes const double presolve_time_limit = std::max(1.0, std::min(0.1 * lp_timer.remaining_time(), 60.0)); - presolver = std::make_unique>(); + presolver = std::make_unique>(); result = presolver->apply(op_problem, - cuopt::linear_programming::problem_category_t::LP, + cuopt::mathematical_optimization::problem_category_t::LP, settings.presolver, settings.dual_postsolve, settings.tolerances.absolute_primal_tolerance, settings.tolerances.relative_primal_tolerance, presolve_time_limit); - if (result->status == detail::third_party_presolve_status_t::INFEASIBLE) { + if (result->status == mip::third_party_presolve_status_t::INFEASIBLE) { return optimization_problem_solution_t( pdlp_termination_status_t::PrimalInfeasible, op_problem.get_handle_ptr()->get_stream()); } - if (result->status == detail::third_party_presolve_status_t::UNBNDORINFEAS) { + if (result->status == mip::third_party_presolve_status_t::UNBNDORINFEAS) { return optimization_problem_solution_t( pdlp_termination_status_t::UnboundedOrInfeasible, op_problem.get_handle_ptr()->get_stream()); } - if (result->status == detail::third_party_presolve_status_t::UNBOUNDED) { + if (result->status == mip::third_party_presolve_status_t::UNBOUNDED) { return optimization_problem_solution_t(pdlp_termination_status_t::DualInfeasible, op_problem.get_handle_ptr()->get_stream()); } @@ -2004,7 +1994,7 @@ optimization_problem_solution_t solve_lp( presolver->undo(empty_primal, empty_dual, empty_reduced_costs, - cuopt::linear_programming::problem_category_t::LP, + cuopt::mathematical_optimization::problem_category_t::LP, false, // status_to_skip settings.dual_postsolve, op_problem.get_handle_ptr()->get_stream()); @@ -2036,7 +2026,7 @@ optimization_problem_solution_t solve_lp( std::move(status_vec)); } - problem = detail::problem_t(result->reduced_problem); + problem = mip::problem_t(result->reduced_problem); presolve_time = lp_timer.elapsed_time(); CUOPT_LOG_INFO("%s presolve time: %.2fs", settings.presolver == presolver_t::PSLP ? "PSLP" : "Papilo", @@ -2075,7 +2065,7 @@ optimization_problem_solution_t solve_lp( presolver->undo(primal_solution, dual_solution, reduced_costs, - cuopt::linear_programming::problem_category_t::LP, + cuopt::mathematical_optimization::problem_category_t::LP, status_to_skip, settings.dual_postsolve, op_problem.get_handle_ptr()->get_stream()); @@ -2116,14 +2106,15 @@ optimization_problem_solution_t solve_lp( } template -cuopt::linear_programming::optimization_problem_t mps_data_model_to_optimization_problem( +cuopt::mathematical_optimization::optimization_problem_t +mps_data_model_to_optimization_problem( raft::handle_t const* handle_ptr, - const cuopt::linear_programming::io::mps_data_model_t& data_model) + const cuopt::mathematical_optimization::io::mps_data_model_t& data_model) { cuopt_expects(handle_ptr != nullptr, error_type_t::ValidationError, "handle_ptr must not be null for GPU-backed problem construction"); - cuopt::linear_programming::optimization_problem_t op_problem(handle_ptr); + cuopt::mathematical_optimization::optimization_problem_t op_problem(handle_ptr); op_problem.set_maximize(data_model.get_sense()); if (data_model.get_constraint_matrix_values().size() != 0) { @@ -2162,7 +2153,7 @@ cuopt::linear_programming::optimization_problem_t mps_data_model_to_op std::transform(data_model.get_variable_types().cbegin(), data_model.get_variable_types().cend(), enum_variable_types.begin(), - detail::char_to_var_type); + char_to_var_type); op_problem.set_variable_types(enum_variable_types.data(), enum_variable_types.size()); } @@ -2208,7 +2199,7 @@ cuopt::linear_programming::optimization_problem_t mps_data_model_to_op template optimization_problem_solution_t solve_lp( raft::handle_t const* handle_ptr, - const cuopt::linear_programming::io::mps_data_model_t& mps_data_model, + const cuopt::mathematical_optimization::io::mps_data_model_t& mps_data_model, pdlp_solver_settings_t const& settings, bool problem_checking, bool use_pdlp_solver_mode) @@ -2313,7 +2304,7 @@ std::unique_ptr> solve_lp( \ template optimization_problem_solution_t solve_lp( \ raft::handle_t const* handle_ptr, \ - const cuopt::linear_programming::io::mps_data_model_t& mps_data_model, \ + const cuopt::mathematical_optimization::io::mps_data_model_t& mps_data_model, \ pdlp_solver_settings_t const& settings, \ bool problem_checking, \ bool use_pdlp_solver_mode); \ @@ -2333,14 +2324,14 @@ std::unique_ptr> solve_lp( bool); \ \ template optimization_problem_solution_t solve_lp_with_method( \ - detail::problem_t& problem, \ + mip::problem_t& problem, \ pdlp_solver_settings_t const& settings, \ const timer_t& timer, \ bool is_batch_mode); \ \ template optimization_problem_solution_t batch_pdlp_solve( \ raft::handle_t const* handle_ptr, \ - const cuopt::linear_programming::io::mps_data_model_t& mps_data_model, \ + const cuopt::mathematical_optimization::io::mps_data_model_t& mps_data_model, \ const std::vector& fractional, \ const std::vector& root_soln_x, \ pdlp_solver_settings_t const& settings); \ @@ -2356,7 +2347,7 @@ std::unique_ptr> solve_lp( \ template optimization_problem_t mps_data_model_to_optimization_problem( \ raft::handle_t const* handle_ptr, \ - const cuopt::linear_programming::io::mps_data_model_t& data_model); \ + const cuopt::mathematical_optimization::io::mps_data_model_t& data_model); \ template void set_pdlp_solver_mode(pdlp_solver_settings_t& settings); #if MIP_INSTANTIATE_FLOAT @@ -2367,4 +2358,4 @@ INSTANTIATE(float) INSTANTIATE(double) #endif -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/pdlp/solve.cuh b/cpp/src/pdlp/solve.cuh index 90e5e4fe95..dd249a825d 100644 --- a/cpp/src/pdlp/solve.cuh +++ b/cpp/src/pdlp/solve.cuh @@ -7,27 +7,28 @@ #pragma once -#include +#include -#include +#include #include -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { -namespace detail { +namespace mip { template class problem_t; -} // namespace detail +} // namespace mip template -cuopt::linear_programming::optimization_problem_t mps_data_model_to_optimization_problem( +cuopt::mathematical_optimization::optimization_problem_t +mps_data_model_to_optimization_problem( raft::handle_t const* handle_ptr, - const cuopt::linear_programming::io::mps_data_model_t& data_model); + const cuopt::mathematical_optimization::io::mps_data_model_t& data_model); template -cuopt::linear_programming::optimization_problem_solution_t solve_lp_with_method( - detail::problem_t& problem, +cuopt::mathematical_optimization::optimization_problem_solution_t solve_lp_with_method( + mip::problem_t& problem, pdlp_solver_settings_t const& settings, const timer_t& timer, bool is_batch_mode = false); @@ -82,8 +83,8 @@ cuopt::linear_programming::optimization_problem_solution_t solve_lp_wi * @endcode */ template -cuopt::linear_programming::optimization_problem_solution_t run_batch_pdlp( - cuopt::linear_programming::optimization_problem_t& problem, +cuopt::mathematical_optimization::optimization_problem_solution_t run_batch_pdlp( + cuopt::mathematical_optimization::optimization_problem_t& problem, pdlp_solver_settings_t const& settings); /** @@ -101,7 +102,7 @@ cuopt::linear_programming::optimization_problem_solution_t run_batch_p */ template size_t compute_optimal_batch_size( - const cuopt::linear_programming::optimization_problem_t& problem, + const cuopt::mathematical_optimization::optimization_problem_t& problem, bool per_climber_objectives, bool per_climber_constraint_bounds, bool collect_solutions = false); // Only for testing @@ -109,4 +110,4 @@ size_t compute_optimal_batch_size( template void set_pdlp_solver_mode(pdlp_solver_settings_t& settings); -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/pdlp/solver_settings.cu b/cpp/src/pdlp/solver_settings.cu index 28e7428fac..3b8e34ce5b 100644 --- a/cpp/src/pdlp/solver_settings.cu +++ b/cpp/src/pdlp/solver_settings.cu @@ -6,8 +6,8 @@ /* clang-format on */ #include -#include -#include +#include +#include #include #include #include @@ -20,7 +20,7 @@ #include #include -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { template void pdlp_solver_settings_t::set_optimality_tolerance(f_t eps_optimal) @@ -422,4 +422,4 @@ template class pdlp_solver_settings_t; template class pdlp_solver_settings_t; #endif -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/pdlp/solver_solution.cu b/cpp/src/pdlp/solver_solution.cu index ec0492dac3..0da8649dc4 100644 --- a/cpp/src/pdlp/solver_solution.cu +++ b/cpp/src/pdlp/solver_solution.cu @@ -5,7 +5,7 @@ */ /* clang-format on */ -#include +#include #include @@ -20,7 +20,7 @@ #include #include -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { template optimization_problem_solution_t::optimization_problem_solution_t( @@ -459,4 +459,4 @@ template class optimization_problem_solution_t; #if MIP_INSTANTIATE_DOUBLE template class optimization_problem_solution_t; #endif -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/pdlp/step_size_strategy/adaptive_step_size_strategy.cu b/cpp/src/pdlp/step_size_strategy/adaptive_step_size_strategy.cu index 1f137dc9ea..5bc66dd7d0 100644 --- a/cpp/src/pdlp/step_size_strategy/adaptive_step_size_strategy.cu +++ b/cpp/src/pdlp/step_size_strategy/adaptive_step_size_strategy.cu @@ -5,7 +5,7 @@ */ /* clang-format on */ -#include +#include #include #include @@ -33,7 +33,7 @@ #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::pdlp { template adaptive_step_size_strategy_t::adaptive_step_size_strategy_t( @@ -44,7 +44,7 @@ adaptive_step_size_strategy_t::adaptive_step_size_strategy_t( i_t primal_size, i_t dual_size, const std::vector& climber_strategies, - const pdlp_hyper_params::pdlp_hyper_params_t& hyper_params) + const pdlp::pdlp_hyper_params_t& hyper_params) : batch_mode_(climber_strategies.size() > 1), handle_ptr_(handle_ptr), stream_view_(handle_ptr_->get_stream()), @@ -585,4 +585,4 @@ INSTANTIATE(float) INSTANTIATE(double) #endif -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::pdlp diff --git a/cpp/src/pdlp/step_size_strategy/adaptive_step_size_strategy.hpp b/cpp/src/pdlp/step_size_strategy/adaptive_step_size_strategy.hpp index 1e969150e7..1a31cd5c28 100644 --- a/cpp/src/pdlp/step_size_strategy/adaptive_step_size_strategy.hpp +++ b/cpp/src/pdlp/step_size_strategy/adaptive_step_size_strategy.hpp @@ -6,7 +6,7 @@ /* clang-format on */ #pragma once -#include +#include #include #include @@ -24,7 +24,7 @@ #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::pdlp { template class adaptive_step_size_strategy_t { public: @@ -47,7 +47,7 @@ class adaptive_step_size_strategy_t { f_t* norm_squared_delta_primal; f_t* norm_squared_delta_dual; - pdlp_hyper_params::pdlp_hyper_params_t hyper_params; + pdlp::pdlp_hyper_params_t hyper_params; }; adaptive_step_size_strategy_t(raft::handle_t const* handle_ptr, @@ -57,7 +57,7 @@ class adaptive_step_size_strategy_t { i_t primal_size, i_t dual_size, const std::vector& climber_strategies, - const pdlp_hyper_params::pdlp_hyper_params_t& hyper_params); + const pdlp::pdlp_hyper_params_t& hyper_params); void compute_step_sizes(pdhg_solver_t& pdhg_solver, rmm::device_uvector& primal_step_size, @@ -118,6 +118,6 @@ class adaptive_step_size_strategy_t { ping_pong_graph_t graph; const std::vector& climber_strategies_; - const pdlp_hyper_params::pdlp_hyper_params_t& hyper_params_; + const pdlp::pdlp_hyper_params_t& hyper_params_; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::pdlp diff --git a/cpp/src/pdlp/swap_and_resize_helper.cuh b/cpp/src/pdlp/swap_and_resize_helper.cuh index 6ed05df241..e09ba4f9ed 100644 --- a/cpp/src/pdlp/swap_and_resize_helper.cuh +++ b/cpp/src/pdlp/swap_and_resize_helper.cuh @@ -23,7 +23,7 @@ #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::pdlp { template struct swap_pair_t { @@ -97,4 +97,4 @@ void host_vector_swap(host_vector_t& host_vector, int left_swap_index, int right // Swap the id to swap to the end std::swap(host_vector[left_swap_index], host_vector[right_swap_index]); } -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::pdlp diff --git a/cpp/src/pdlp/termination_strategy/convergence_information.cu b/cpp/src/pdlp/termination_strategy/convergence_information.cu index a6d6d14d96..966bf59724 100644 --- a/cpp/src/pdlp/termination_strategy/convergence_information.cu +++ b/cpp/src/pdlp/termination_strategy/convergence_information.cu @@ -14,7 +14,7 @@ #include #include -#include +#include #include #include @@ -33,11 +33,11 @@ #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::pdlp { template convergence_information_t::convergence_information_t( raft::handle_t const* handle_ptr, - problem_t& op_problem, + mip::problem_t& op_problem, cusparse_view_t& cusparse_view, i_t primal_size, i_t dual_size, @@ -1027,4 +1027,4 @@ template __global__ void compute_remaining_stats_kernel( int batch_size); #endif -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::pdlp diff --git a/cpp/src/pdlp/termination_strategy/convergence_information.hpp b/cpp/src/pdlp/termination_strategy/convergence_information.hpp index 2389a60fae..41e5f06f26 100644 --- a/cpp/src/pdlp/termination_strategy/convergence_information.hpp +++ b/cpp/src/pdlp/termination_strategy/convergence_information.hpp @@ -12,9 +12,9 @@ #include #include -#include -#include -#include +#include +#include +#include #include @@ -25,12 +25,12 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::pdlp { template class convergence_information_t { public: convergence_information_t(raft::handle_t const* handle_ptr, - problem_t& op_problem, + mip::problem_t& op_problem, cusparse_view_t& cusparse_view, i_t primal_size, i_t dual_size, @@ -157,7 +157,7 @@ class convergence_information_t { i_t primal_size_h_; i_t dual_size_h_; - problem_t* problem_ptr; + mip::problem_t* problem_ptr; cusparse_view_t& op_problem_cusparse_view_; rmm::device_uvector l2_norm_primal_linear_objective_; @@ -201,12 +201,12 @@ class convergence_information_t { const rmm::device_scalar reusable_device_scalar_value_1_; const rmm::device_scalar reusable_device_scalar_value_0_; const rmm::device_scalar reusable_device_scalar_value_neg_1_; - segmented_sum_handler_t segmented_sum_handler_; + cuopt::segmented_sum_handler_t segmented_sum_handler_; rmm::device_uvector dual_dot_; rmm::device_uvector sum_primal_slack_; const std::vector& climber_strategies_; - const pdlp_hyper_params::pdlp_hyper_params_t& hyper_params_; + const pdlp::pdlp_hyper_params_t& hyper_params_; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::pdlp diff --git a/cpp/src/pdlp/termination_strategy/infeasibility_information.cu b/cpp/src/pdlp/termination_strategy/infeasibility_information.cu index 9268e17910..47c2148693 100644 --- a/cpp/src/pdlp/termination_strategy/infeasibility_information.cu +++ b/cpp/src/pdlp/termination_strategy/infeasibility_information.cu @@ -11,7 +11,7 @@ #include #include -#include +#include #include @@ -34,12 +34,12 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::pdlp { template infeasibility_information_t::infeasibility_information_t( raft::handle_t const* handle_ptr, - problem_t& op_problem, - const problem_t& op_problem_scaled, + mip::problem_t& op_problem, + const mip::problem_t& op_problem_scaled, cusparse_view_t& cusparse_view, const cusparse_view_t& scaled_cusparse_view, i_t primal_size, @@ -47,7 +47,7 @@ infeasibility_information_t::infeasibility_information_t( const pdlp_initial_scaling_strategy_t& scaling_strategy, bool infeasibility_detection, const std::vector& climber_strategies, - const pdlp_hyper_params::pdlp_hyper_params_t& hyper_params) + const pdlp::pdlp_hyper_params_t& hyper_params) : handle_ptr_(handle_ptr), stream_view_(handle_ptr_->get_stream()), primal_size_h_(primal_size), @@ -769,4 +769,4 @@ template __global__ void compute_remaining_stats_kernel( typename infeasibility_information_t::view_t infeasibility_information_view); #endif -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::pdlp diff --git a/cpp/src/pdlp/termination_strategy/infeasibility_information.hpp b/cpp/src/pdlp/termination_strategy/infeasibility_information.hpp index df746e8541..2ccae0633f 100644 --- a/cpp/src/pdlp/termination_strategy/infeasibility_information.hpp +++ b/cpp/src/pdlp/termination_strategy/infeasibility_information.hpp @@ -11,8 +11,8 @@ #include #include -#include -#include +#include +#include #include @@ -23,23 +23,23 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::pdlp { template class infeasibility_information_t { public: - infeasibility_information_t( - raft::handle_t const* handle_ptr, - problem_t& op_problem, - const problem_t& op_problem_scaled, // Only used for cuPDLPx infeasibility detection - cusparse_view_t& cusparse_view, - const cusparse_view_t& scaled_cusparse_view, - i_t primal_size, - i_t dual_size, - const pdlp_initial_scaling_strategy_t& - scaling_strategy, // Only used for cuPDLPx infeasibility detection - bool infeasibility_detection, - const std::vector& climber_strategies, - const pdlp_hyper_params::pdlp_hyper_params_t& hyper_params); + infeasibility_information_t(raft::handle_t const* handle_ptr, + mip::problem_t& op_problem, + const mip::problem_t& + op_problem_scaled, // Only used for cuPDLPx infeasibility detection + cusparse_view_t& cusparse_view, + const cusparse_view_t& scaled_cusparse_view, + i_t primal_size, + i_t dual_size, + const pdlp_initial_scaling_strategy_t& + scaling_strategy, // Only used for cuPDLPx infeasibility detection + bool infeasibility_detection, + const std::vector& climber_strategies, + const pdlp::pdlp_hyper_params_t& hyper_params); void compute_infeasibility_information(pdhg_solver_t& current_pdhg_solver, rmm::device_uvector& primal_ray, @@ -90,7 +90,7 @@ class infeasibility_information_t { i_t primal_size_h_; i_t dual_size_h_; - problem_t* problem_ptr; + mip::problem_t* problem_ptr; cusparse_view_t& op_problem_cusparse_view_; const cusparse_view_t& scaled_cusparse_view_; @@ -130,10 +130,10 @@ class infeasibility_information_t { const rmm::device_scalar reusable_device_scalar_value_neg_1_; const pdlp_initial_scaling_strategy_t& scaling_strategy_; - const problem_t& op_problem_scaled_; + const mip::problem_t& op_problem_scaled_; - segmented_sum_handler_t segmented_sum_handler_; + cuopt::segmented_sum_handler_t segmented_sum_handler_; const std::vector& climber_strategies_; - const pdlp_hyper_params::pdlp_hyper_params_t& hyper_params_; + const pdlp::pdlp_hyper_params_t& hyper_params_; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::pdlp diff --git a/cpp/src/pdlp/termination_strategy/termination_strategy.cu b/cpp/src/pdlp/termination_strategy/termination_strategy.cu index d1a88799d6..1218c60fa4 100644 --- a/cpp/src/pdlp/termination_strategy/termination_strategy.cu +++ b/cpp/src/pdlp/termination_strategy/termination_strategy.cu @@ -12,20 +12,20 @@ #include -#include -#include -#include +#include +#include +#include #include #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::pdlp { template pdlp_termination_strategy_t::pdlp_termination_strategy_t( raft::handle_t const* handle_ptr, - problem_t& op_problem, - const problem_t& scaled_op_problem, + mip::problem_t& op_problem, + const mip::problem_t& scaled_op_problem, cusparse_view_t& cusparse_view, const cusparse_view_t& scaled_cusparse_view, const i_t primal_size, @@ -710,4 +710,4 @@ INSTANTIATE(double) #undef INSTANTIATE -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::pdlp diff --git a/cpp/src/pdlp/termination_strategy/termination_strategy.hpp b/cpp/src/pdlp/termination_strategy/termination_strategy.hpp index 5cd43d7be7..42d7cc038a 100644 --- a/cpp/src/pdlp/termination_strategy/termination_strategy.hpp +++ b/cpp/src/pdlp/termination_strategy/termination_strategy.hpp @@ -12,9 +12,9 @@ #include #include -#include -#include -#include +#include +#include +#include #include #include @@ -27,13 +27,13 @@ #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::pdlp { template class pdlp_termination_strategy_t { public: pdlp_termination_strategy_t(raft::handle_t const* handle_ptr, - problem_t& op_problem, - const problem_t& scaled_op_problem, + mip::problem_t& op_problem, + const mip::problem_t& scaled_op_problem, cusparse_view_t& cusparse_view, const cusparse_view_t& scaled_cusparse_view, const i_t primal_size, @@ -215,7 +215,7 @@ class pdlp_termination_strategy_t { raft::handle_t const* handle_ptr_{nullptr}; rmm::cuda_stream_view stream_view_; - problem_t* problem_ptr; + mip::problem_t* problem_ptr; convergence_information_t convergence_information_; infeasibility_information_t infeasibility_information_; @@ -235,4 +235,4 @@ class pdlp_termination_strategy_t { const std::vector& climber_strategies_; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::pdlp diff --git a/cpp/src/pdlp/translate.hpp b/cpp/src/pdlp/translate.hpp index be832e082d..3c6119e164 100644 --- a/cpp/src/pdlp/translate.hpp +++ b/cpp/src/pdlp/translate.hpp @@ -7,8 +7,8 @@ #pragma once -#include -#include +#include +#include #include #include @@ -23,13 +23,13 @@ #include #include -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { template -static dual_simplex::user_problem_t cuopt_problem_to_user_problem( +static simplex::user_problem_t cuopt_problem_to_user_problem( raft::handle_t const* handle_ptr, const optimization_problem_interface_t& problem) { - dual_simplex::user_problem_t user_problem(handle_ptr); + simplex::user_problem_t user_problem(handle_ptr); int m = problem.get_n_constraints(); int n = problem.get_n_variables(); @@ -40,7 +40,7 @@ static dual_simplex::user_problem_t cuopt_problem_to_user_problem( user_problem.num_cols = n; user_problem.objective = problem.get_objective_coefficients_host(); - dual_simplex::csr_matrix_t csr_A(m, n, static_cast(A_values.size())); + simplex::csr_matrix_t csr_A(m, n, static_cast(A_values.size())); csr_A.x = std::move(A_values); csr_A.j = std::move(A_indices); csr_A.row_start = std::move(A_offsets); @@ -88,8 +88,8 @@ static dual_simplex::user_problem_t cuopt_problem_to_user_problem( for (int j = 0; j < n; ++j) { user_problem.var_types[j] = variable_types[j] == var_t::CONTINUOUS - ? cuopt::linear_programming::dual_simplex::variable_type_t::CONTINUOUS - : cuopt::linear_programming::dual_simplex::variable_type_t::INTEGER; + ? cuopt::mathematical_optimization::simplex::variable_type_t::CONTINUOUS + : cuopt::mathematical_optimization::simplex::variable_type_t::INTEGER; } user_problem.Q_offsets = problem.get_quadratic_objective_offsets(); @@ -100,10 +100,10 @@ static dual_simplex::user_problem_t cuopt_problem_to_user_problem( } template -static dual_simplex::user_problem_t cuopt_problem_to_user_problem( - raft::handle_t const* handle_ptr, detail::problem_t& model) +static simplex::user_problem_t cuopt_problem_to_user_problem( + raft::handle_t const* handle_ptr, mip::problem_t& model) { - dual_simplex::user_problem_t user_problem(handle_ptr); + simplex::user_problem_t user_problem(handle_ptr); int m = model.n_constraints; int n = model.n_variables; @@ -112,7 +112,7 @@ static dual_simplex::user_problem_t cuopt_problem_to_user_problem( user_problem.num_cols = n; user_problem.objective = cuopt::host_copy(model.objective_coefficients, handle_ptr->get_stream()); - dual_simplex::csr_matrix_t csr_A(m, n, nz); + simplex::csr_matrix_t csr_A(m, n, nz); csr_A.x = std::vector(cuopt::host_copy(model.coefficients, handle_ptr->get_stream())); csr_A.j = std::vector(cuopt::host_copy(model.variables, handle_ptr->get_stream())); csr_A.row_start = std::vector(cuopt::host_copy(model.offsets, handle_ptr->get_stream())); @@ -182,8 +182,8 @@ static dual_simplex::user_problem_t cuopt_problem_to_user_problem( for (int j = 0; j < n; ++j) { user_problem.var_types[j] = model_variable_types[j] == var_t::CONTINUOUS - ? cuopt::linear_programming::dual_simplex::variable_type_t::CONTINUOUS - : cuopt::linear_programming::dual_simplex::variable_type_t::INTEGER; + ? cuopt::mathematical_optimization::simplex::variable_type_t::CONTINUOUS + : cuopt::mathematical_optimization::simplex::variable_type_t::INTEGER; } user_problem.Q_offsets = model.Q_offsets; @@ -191,7 +191,7 @@ static dual_simplex::user_problem_t cuopt_problem_to_user_problem( user_problem.Q_values = model.Q_values; if (model.original_problem_ptr->has_quadratic_constraints()) { - detail::convert_quadratic_constraints_to_second_order_cones( + barrier::convert_quadratic_constraints_to_second_order_cones( n, model.original_problem_ptr->get_quadratic_constraints(), csr_A, user_problem); } @@ -201,10 +201,10 @@ static dual_simplex::user_problem_t cuopt_problem_to_user_problem( } template -static dual_simplex::user_problem_t cuopt_optimization_problem_to_user_problem( +static simplex::user_problem_t cuopt_optimization_problem_to_user_problem( raft::handle_t const* handle_ptr, optimization_problem_t& model) { - dual_simplex::user_problem_t user_problem(handle_ptr); + simplex::user_problem_t user_problem(handle_ptr); i_t const m = model.get_n_constraints(); i_t const n = model.get_n_variables(); @@ -224,7 +224,7 @@ static dual_simplex::user_problem_t cuopt_optimization_problem_to_user } } - dual_simplex::csr_matrix_t csr_A(m, n, nz); + simplex::csr_matrix_t csr_A(m, n, nz); csr_A.x = model.get_constraint_matrix_values_host(); csr_A.j = model.get_constraint_matrix_indices_host(); csr_A.row_start = model.get_constraint_matrix_offsets_host(); @@ -304,8 +304,8 @@ static dual_simplex::user_problem_t cuopt_optimization_problem_to_user user_problem.var_types[j] = model_variable_types.empty() || model_variable_types[static_cast(j)] == var_t::CONTINUOUS - ? cuopt::linear_programming::dual_simplex::variable_type_t::CONTINUOUS - : cuopt::linear_programming::dual_simplex::variable_type_t::INTEGER; + ? cuopt::mathematical_optimization::simplex::variable_type_t::CONTINUOUS + : cuopt::mathematical_optimization::simplex::variable_type_t::INTEGER; } user_problem.Q_offsets = model.get_quadratic_objective_offsets(); @@ -313,7 +313,7 @@ static dual_simplex::user_problem_t cuopt_optimization_problem_to_user user_problem.Q_values = model.get_quadratic_objective_values(); if (model.has_quadratic_constraints()) { - detail::convert_quadratic_constraints_to_second_order_cones( + barrier::convert_quadratic_constraints_to_second_order_cones( static_cast(n), model.get_quadratic_constraints(), csr_A, user_problem); } @@ -323,18 +323,17 @@ static dual_simplex::user_problem_t cuopt_optimization_problem_to_user } template -void translate_to_crossover_problem(const detail::problem_t& problem, +void translate_to_crossover_problem(const mip::problem_t& problem, optimization_problem_solution_t& sol, - dual_simplex::lp_problem_t& lp, - dual_simplex::lp_solution_t& initial_solution) + simplex::lp_problem_t& lp, + simplex::lp_solution_t& initial_solution) { CUOPT_LOG_DEBUG("Starting translation"); auto stream = problem.handle_ptr->get_stream(); std::vector pdlp_objective = cuopt::host_copy(problem.objective_coefficients, stream); - dual_simplex::csr_matrix_t csr_A( - problem.n_constraints, problem.n_variables, problem.nnz); + simplex::csr_matrix_t csr_A(problem.n_constraints, problem.n_variables, problem.nnz); csr_A.x = std::vector(cuopt::host_copy(problem.coefficients, stream)); csr_A.j = std::vector(cuopt::host_copy(problem.variables, stream)); csr_A.row_start = std::vector(cuopt::host_copy(problem.offsets, stream)); @@ -347,7 +346,7 @@ void translate_to_crossover_problem(const detail::problem_t& problem, std::vector slack(problem.n_constraints); std::vector tmp_x = cuopt::host_copy(sol.get_primal_solution(), stream); stream.synchronize(); - dual_simplex::matrix_vector_multiply(lp.A, f_t(1.0), tmp_x, f_t(0.0), slack); + simplex::matrix_vector_multiply(lp.A, f_t(1.0), tmp_x, f_t(0.0), slack); CUOPT_LOG_DEBUG("Multiplied A and x"); lp.A.col_start.resize(problem.n_variables + problem.n_constraints + 1); @@ -415,4 +414,4 @@ void translate_to_crossover_problem(const detail::problem_t& problem, CUOPT_LOG_DEBUG("Finished translating"); } -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/pdlp/utilities/cython_solve.cu b/cpp/src/pdlp/utilities/cython_solve.cu index ec3cc2862f..ed77c4f722 100644 --- a/cpp/src/pdlp/utilities/cython_solve.cu +++ b/cpp/src/pdlp/utilities/cython_solve.cu @@ -6,18 +6,18 @@ /* clang-format on */ #include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include #include #include #include @@ -42,21 +42,22 @@ namespace cython { * @param solver_settings PDLP solver settings object * @return lp_solution_interface_t pointer (raw pointer, caller owns) */ -cuopt::linear_programming::lp_solution_interface_t* call_solve_lp( - cuopt::linear_programming::optimization_problem_interface_t* problem_interface, - cuopt::linear_programming::pdlp_solver_settings_t& solver_settings, +cuopt::mathematical_optimization::lp_solution_interface_t* call_solve_lp( + cuopt::mathematical_optimization::optimization_problem_interface_t* + problem_interface, + cuopt::mathematical_optimization::pdlp_solver_settings_t& solver_settings, bool is_batch_mode) { raft::common::nvtx::range fun_scope("Call Solve LP"); - cuopt_expects( - problem_interface->get_problem_category() == cuopt::linear_programming::problem_category_t::LP, - error_type_t::ValidationError, - "LP solve cannot be called on a MIP problem!"); + cuopt_expects(problem_interface->get_problem_category() == + cuopt::mathematical_optimization::problem_category_t::LP, + error_type_t::ValidationError, + "LP solve cannot be called on a MIP problem!"); const bool problem_checking = true; const bool use_pdlp_solver_mode = true; // Solve returns unique_ptr - auto solution_interface = cuopt::linear_programming::solve_lp( + auto solution_interface = cuopt::mathematical_optimization::solve_lp( problem_interface, solver_settings, problem_checking, use_pdlp_solver_mode, is_batch_mode); // Return raw pointer (Python wrapper will own and manage lifecycle) @@ -70,58 +71,59 @@ cuopt::linear_programming::lp_solution_interface_t* call_solve_lp( * @param solver_settings MIP solver settings object * @return mip_solution_interface_t pointer (raw pointer, caller owns) */ -cuopt::linear_programming::mip_solution_interface_t* call_solve_mip( - cuopt::linear_programming::optimization_problem_interface_t* problem_interface, - cuopt::linear_programming::mip_solver_settings_t& solver_settings) +cuopt::mathematical_optimization::mip_solution_interface_t* call_solve_mip( + cuopt::mathematical_optimization::optimization_problem_interface_t* + problem_interface, + cuopt::mathematical_optimization::mip_solver_settings_t& solver_settings) { raft::common::nvtx::range fun_scope("Call Solve MIP"); cuopt_expects((problem_interface->get_problem_category() == - cuopt::linear_programming::problem_category_t::MIP) or + cuopt::mathematical_optimization::problem_category_t::MIP) or (problem_interface->get_problem_category() == - cuopt::linear_programming::problem_category_t::IP), + cuopt::mathematical_optimization::problem_category_t::IP), error_type_t::ValidationError, "MIP solve cannot be called on an LP problem!"); // Solve returns unique_ptr auto solution_interface = - cuopt::linear_programming::solve_mip(problem_interface, solver_settings); + cuopt::mathematical_optimization::solve_mip(problem_interface, solver_settings); // Return raw pointer (Python wrapper will own and manage lifecycle) return solution_interface.release(); } std::unique_ptr call_solve( - cuopt::linear_programming::io::data_model_view_t* data_model, - cuopt::linear_programming::solver_settings_t* solver_settings, + cuopt::mathematical_optimization::io::data_model_view_t* data_model, + cuopt::mathematical_optimization::solver_settings_t* solver_settings, unsigned int flags, bool is_batch_mode) { raft::common::nvtx::range fun_scope("Call Solve"); // Determine memory backend based on execution mode - auto memory_backend = cuopt::linear_programming::get_memory_backend_type(); + auto memory_backend = cuopt::mathematical_optimization::get_memory_backend_type(); solver_ret_t response; // Create problem instance and CUDA resources based on memory backend - if (memory_backend == cuopt::linear_programming::memory_backend_t::GPU) { + if (memory_backend == cuopt::mathematical_optimization::memory_backend_t::GPU) { // GPU memory backend: Create CUDA resources and GPU problem rmm::cuda_stream stream(static_cast(flags)); const raft::handle_t handle_{stream}; - auto problem = cuopt::linear_programming::optimization_problem_t(&handle_); - cuopt::linear_programming::populate_from_data_model_view( + auto problem = cuopt::mathematical_optimization::optimization_problem_t(&handle_); + cuopt::mathematical_optimization::populate_from_data_model_view( &problem, data_model, solver_settings, &handle_); // Call appropriate solve function and convert to ret struct - if (problem.get_problem_category() == linear_programming::problem_category_t::LP) { + if (problem.get_problem_category() == mathematical_optimization::problem_category_t::LP) { // Solve and get solution interface pointer auto lp_solution_ptr = - std::unique_ptr>( + std::unique_ptr>( call_solve_lp(&problem, solver_settings->get_pdlp_settings(), is_batch_mode)); response.lp_ret = lp_solution_ptr->to_python_lp_ret(); - response.problem_type = linear_programming::problem_category_t::LP; + response.problem_type = mathematical_optimization::problem_category_t::LP; // The solve's local stream is destroyed when this function returns, so reassociate // all returned device_buffers with a long-lived stream for safe deallocation later. @@ -143,11 +145,11 @@ std::unique_ptr call_solve( } else { // MIP solve auto mip_solution_ptr = - std::unique_ptr>( + std::unique_ptr>( call_solve_mip(&problem, solver_settings->get_mip_settings())); response.mip_ret = mip_solution_ptr->to_python_mip_ret(); - response.problem_type = linear_programming::problem_category_t::MIP; + response.problem_type = mathematical_optimization::problem_category_t::MIP; // Same stream reassociation as the LP path above. auto& gpu_sol = std::get(response.mip_ret.solution_); @@ -175,26 +177,26 @@ std::unique_ptr call_solve( } else { // CPU memory backend: pure data container, no CUDA resources needed - auto cpu_problem = cuopt::linear_programming::cpu_optimization_problem_t(); - cuopt::linear_programming::populate_from_data_model_view( + auto cpu_problem = cuopt::mathematical_optimization::cpu_optimization_problem_t(); + cuopt::mathematical_optimization::populate_from_data_model_view( &cpu_problem, data_model, solver_settings, nullptr); // Call appropriate solve function and convert to ret struct - if (cpu_problem.get_problem_category() == linear_programming::problem_category_t::LP) { + if (cpu_problem.get_problem_category() == mathematical_optimization::problem_category_t::LP) { auto lp_solution_ptr = - std::unique_ptr>( + std::unique_ptr>( call_solve_lp(&cpu_problem, solver_settings->get_pdlp_settings(), is_batch_mode)); response.lp_ret = lp_solution_ptr->to_python_lp_ret(); - response.problem_type = linear_programming::problem_category_t::LP; + response.problem_type = mathematical_optimization::problem_category_t::LP; } else { auto mip_solution_ptr = - std::unique_ptr>( + std::unique_ptr>( call_solve_mip(&cpu_problem, solver_settings->get_mip_settings())); response.mip_ret = mip_solution_ptr->to_python_mip_ret(); - response.problem_type = linear_programming::problem_category_t::MIP; + response.problem_type = mathematical_optimization::problem_category_t::MIP; } } @@ -202,7 +204,8 @@ std::unique_ptr call_solve( } static int compute_max_thread( - const std::vector*>& data_models) + const std::vector*>& + data_models) { constexpr std::size_t max_total = 4; @@ -238,8 +241,8 @@ static int compute_max_thread( } std::pair>, double> solve_batch_remote( - std::vector*> data_models, - cuopt::linear_programming::solver_settings_t* solver_settings) + std::vector*> data_models, + cuopt::mathematical_optimization::solver_settings_t* solver_settings) { cuopt_expects( false, @@ -250,12 +253,12 @@ std::pair>, double> solve_batch_remote } std::pair>, double> call_batch_solve( - std::vector*> data_models, - cuopt::linear_programming::solver_settings_t* solver_settings) + std::vector*> data_models, + cuopt::mathematical_optimization::solver_settings_t* solver_settings) { raft::common::nvtx::range fun_scope("Call batch solve"); - if (cuopt::linear_programming::is_remote_execution_enabled()) { + if (cuopt::mathematical_optimization::is_remote_execution_enabled()) { return solve_batch_remote(data_models, solver_settings); } diff --git a/cpp/src/pdlp/utilities/ping_pong_graph.cu b/cpp/src/pdlp/utilities/ping_pong_graph.cu index 7e93692b39..eb1f31116e 100644 --- a/cpp/src/pdlp/utilities/ping_pong_graph.cu +++ b/cpp/src/pdlp/utilities/ping_pong_graph.cu @@ -7,7 +7,7 @@ #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::pdlp { template ping_pong_graph_t::ping_pong_graph_t(rmm::cuda_stream_view stream_view, @@ -18,4 +18,4 @@ ping_pong_graph_t::ping_pong_graph_t(rmm::cuda_stream_view stream_view, template class ping_pong_graph_t; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::pdlp diff --git a/cpp/src/pdlp/utilities/ping_pong_graph.cuh b/cpp/src/pdlp/utilities/ping_pong_graph.cuh index dbc8fe5828..4f895fffd1 100644 --- a/cpp/src/pdlp/utilities/ping_pong_graph.cuh +++ b/cpp/src/pdlp/utilities/ping_pong_graph.cuh @@ -14,7 +14,7 @@ #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::pdlp { // Two-slot CUDA-graph cache for PDLP. PDLP swaps pointers (rather than // copying vectors) at the end of adaptive pdhg step, so the captured graph @@ -68,4 +68,4 @@ class ping_pong_graph_t { bool is_legacy_batch_mode_{false}; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::pdlp diff --git a/cpp/src/pdlp/utilities/problem_checking.cu b/cpp/src/pdlp/utilities/problem_checking.cu index 35483c9c8e..817436cf83 100644 --- a/cpp/src/pdlp/utilities/problem_checking.cu +++ b/cpp/src/pdlp/utilities/problem_checking.cu @@ -8,7 +8,7 @@ #include "problem_checking.cuh" #include -#include +#include #include #include @@ -18,7 +18,7 @@ #include #include -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { template void problem_checking_t::check_csr_representation( @@ -289,7 +289,7 @@ void problem_checking_t::check_problem_representation( template void problem_checking_t::check_scaled_problem( - detail::problem_t const& scaled_problem, detail::problem_t const& op_problem) + mip::problem_t const& scaled_problem, mip::problem_t const& op_problem) { using f_t2 = typename type_2::type; // original problem to host @@ -328,7 +328,7 @@ void problem_checking_t::check_scaled_problem( template void problem_checking_t::check_unscaled_solution( - detail::problem_t& op_problem, rmm::device_uvector const& assignment) + mip::problem_t& op_problem, rmm::device_uvector const& assignment) { using f_t2 = typename type_2::type; auto& d_variable_bounds = op_problem.variable_bounds; @@ -386,4 +386,4 @@ INSTANTIATE(double) #undef INSTANTIATE -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/pdlp/utilities/problem_checking.cuh b/cpp/src/pdlp/utilities/problem_checking.cuh index 72f4b876b9..217080356c 100644 --- a/cpp/src/pdlp/utilities/problem_checking.cuh +++ b/cpp/src/pdlp/utilities/problem_checking.cuh @@ -1,26 +1,26 @@ /* clang-format off */ /* - * SPDX-FileCopyrightText: Copyright (c) 2024-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-FileCopyrightText: Copyright (c) 2024-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. * SPDX-License-Identifier: Apache-2.0 */ /* clang-format on */ #pragma once -#include -#include -#include +#include +#include +#include namespace rmm { template class device_uvector; } // namespace rmm -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { -namespace detail { +namespace mip { template class problem_t; -} // namespace detail +} // namespace mip template class problem_checking_t { @@ -30,9 +30,9 @@ class problem_checking_t { static void check_problem_representation(const optimization_problem_t& op_problem); static bool has_crossing_bounds(const optimization_problem_t& op_problem); - static void check_scaled_problem(detail::problem_t const& scaled_problem, - detail::problem_t const& op_problem); - static void check_unscaled_solution(detail::problem_t& op_problem, + static void check_scaled_problem(mip::problem_t const& scaled_problem, + mip::problem_t const& op_problem); + static void check_unscaled_solution(mip::problem_t& op_problem, rmm::device_uvector const& assignment); static void check_initial_primal_representation( const optimization_problem_t& op_problem, @@ -48,4 +48,4 @@ class problem_checking_t { const mip_solver_settings_t& settings); }; -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/pdlp/utils.cuh b/cpp/src/pdlp/utils.cuh index 3f589da470..adc1432b39 100644 --- a/cpp/src/pdlp/utils.cuh +++ b/cpp/src/pdlp/utils.cuh @@ -30,7 +30,7 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::pdlp { template DI f_t deterministic_block_reduce(raft::device_span shared, f_t val) @@ -265,7 +265,7 @@ struct rhs_sum_of_squares_t { }; template -void inline combine_constraint_bounds(const problem_t& op_problem, +void inline combine_constraint_bounds(const mip::problem_t& op_problem, rmm::device_uvector& combined_bounds) { cuopt_assert( @@ -671,4 +671,4 @@ void inline my_inf_norm(const rmm::device_uvector& input_vector, my_inf_norm(input_vector, result.data(), handle_ptr); } -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::mathematical_optimization::pdlp diff --git a/cpp/src/utilities/device_utils.cuh b/cpp/src/utilities/device_utils.cuh index 073b3e35a5..259150d4c6 100644 --- a/cpp/src/utilities/device_utils.cuh +++ b/cpp/src/utilities/device_utils.cuh @@ -1,6 +1,6 @@ /* clang-format off */ /* - * SPDX-FileCopyrightText: Copyright (c) 2024-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-FileCopyrightText: Copyright (c) 2024-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. * SPDX-License-Identifier: Apache-2.0 */ /* clang-format on */ @@ -12,7 +12,7 @@ #include -namespace cuopt::linear_programming::detail { +namespace cuopt { #define FIRST_THREAD (threadIdx.x == 0 && blockIdx.x == 0) #define TH_ID_X threadIdx.x + blockIdx.x* blockDim.x @@ -32,4 +32,4 @@ inline std::pair get_launch_dims_max_occupancy(void* kernel_address, return {dim_grid, dim_block}; } -} // namespace cuopt::linear_programming::detail +} // namespace cuopt diff --git a/cpp/src/utilities/double_buffer.hpp b/cpp/src/utilities/double_buffer.hpp index c940b91f52..504393c54c 100644 --- a/cpp/src/utilities/double_buffer.hpp +++ b/cpp/src/utilities/double_buffer.hpp @@ -1,6 +1,6 @@ /* clang-format off */ /* - * SPDX-FileCopyrightText: Copyright (c) 2024-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-FileCopyrightText: Copyright (c) 2024-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. * SPDX-License-Identifier: Apache-2.0 */ /* clang-format on */ @@ -9,7 +9,7 @@ #include -namespace cuopt::linear_programming::detail { +namespace cuopt { template struct double_buffer_t { @@ -40,4 +40,4 @@ struct double_buffer_t { rmm::device_uvector bufs[2]; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt diff --git a/cpp/src/utilities/driver_helpers.cuh b/cpp/src/utilities/driver_helpers.cuh index 8fbc10e16d..760392c40a 100644 --- a/cpp/src/utilities/driver_helpers.cuh +++ b/cpp/src/utilities/driver_helpers.cuh @@ -11,8 +11,6 @@ namespace cuopt { -namespace detail { - inline auto get_driver_entry_point(const char* name) { void* func = nullptr; @@ -30,5 +28,4 @@ inline auto get_driver_entry_point(const char* name) return func; } -} // namespace detail } // namespace cuopt diff --git a/cpp/src/utilities/hashing.hpp b/cpp/src/utilities/hashing.hpp index 9e8dc09e12..ba914ff164 100644 --- a/cpp/src/utilities/hashing.hpp +++ b/cpp/src/utilities/hashing.hpp @@ -9,7 +9,7 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt { template inline uint32_t compute_hash(const std::vector& h_contents) @@ -43,4 +43,4 @@ __host__ __device__ return hash; } -} // namespace cuopt::linear_programming::detail +} // namespace cuopt diff --git a/cpp/tests/dual_simplex/unit_tests/right_looking_ldlt.cpp b/cpp/tests/dual_simplex/unit_tests/right_looking_ldlt.cpp index 7c91a1f72f..0c80dbe472 100644 --- a/cpp/tests/dual_simplex/unit_tests/right_looking_ldlt.cpp +++ b/cpp/tests/dual_simplex/unit_tests/right_looking_ldlt.cpp @@ -16,7 +16,7 @@ #include #include -namespace cuopt::linear_programming::dual_simplex::test { +namespace cuopt::mathematical_optimization::simplex::test { // Helper: build a CSC lower-triangle matrix from dense symmetric input (column-major, full matrix). // Only stores entries (i, j) with i >= j. @@ -602,4 +602,4 @@ TEST(right_looking_ldlt, large_arrowhead_markowitz) EXPECT_NE(perm[0], 0) << "Markowitz should not pick the dense node (index 0) first"; } -} // namespace cuopt::linear_programming::dual_simplex::test +} // namespace cuopt::mathematical_optimization::simplex::test diff --git a/cpp/tests/dual_simplex/unit_tests/solve.cpp b/cpp/tests/dual_simplex/unit_tests/solve.cpp index 9bf8360ed1..33d5392a9b 100644 --- a/cpp/tests/dual_simplex/unit_tests/solve.cpp +++ b/cpp/tests/dual_simplex/unit_tests/solve.cpp @@ -16,17 +16,17 @@ #include #include -#include +#include #include -namespace cuopt::linear_programming::dual_simplex::test { +namespace cuopt::mathematical_optimization::simplex::test { TEST(dual_simplex, chess_set) { cuopt::init_logger_t log("", true); - namespace dual_simplex = cuopt::linear_programming::dual_simplex; + namespace simplex = cuopt::mathematical_optimization::simplex; raft::handle_t handle{}; - dual_simplex::user_problem_t user_problem(&handle); + simplex::user_problem_t user_problem(&handle); // maximize 5*xs + 20*xl // subject to 1*xs + 3*xl <= 200 // 3*xs + 2*xl <= 160 @@ -65,8 +65,8 @@ TEST(dual_simplex, chess_set) user_problem.lower[0] = 0; user_problem.lower[1] = 0.0; user_problem.upper.resize(n); - user_problem.upper[0] = dual_simplex::inf; - user_problem.upper[1] = dual_simplex::inf; + user_problem.upper[0] = simplex::inf; + user_problem.upper[1] = simplex::inf; user_problem.num_range_rows = 0; user_problem.problem_name = "chess set"; user_problem.row_names.resize(m); @@ -77,22 +77,22 @@ TEST(dual_simplex, chess_set) user_problem.col_names[1] = "xl"; user_problem.obj_constant = 0.0; user_problem.var_types.resize(n); - user_problem.var_types[0] = dual_simplex::variable_type_t::CONTINUOUS; - user_problem.var_types[1] = dual_simplex::variable_type_t::CONTINUOUS; + user_problem.var_types[0] = simplex::variable_type_t::CONTINUOUS; + user_problem.var_types[1] = simplex::variable_type_t::CONTINUOUS; - dual_simplex::simplex_solver_settings_t settings; - dual_simplex::lp_solution_t solution(user_problem.num_rows, user_problem.num_cols); - EXPECT_EQ((dual_simplex::solve_linear_program(user_problem, settings, solution)), - dual_simplex::lp_status_t::OPTIMAL); + simplex::simplex_solver_settings_t settings; + simplex::lp_solution_t solution(user_problem.num_rows, user_problem.num_cols); + EXPECT_EQ((simplex::solve_linear_program(user_problem, settings, solution)), + simplex::lp_status_t::OPTIMAL); const double objective = -solution.objective; EXPECT_NEAR(objective, 1333.33, 1e-2); EXPECT_NEAR(solution.x[0], 0.0, 1e-6); EXPECT_NEAR(solution.x[1], 66.6667, 1e-3); - user_problem.var_types[0] = dual_simplex::variable_type_t::INTEGER; - user_problem.var_types[1] = dual_simplex::variable_type_t::INTEGER; + user_problem.var_types[0] = simplex::variable_type_t::INTEGER; + user_problem.var_types[1] = simplex::variable_type_t::INTEGER; - EXPECT_EQ((dual_simplex::solve(user_problem, settings, solution.x)), 0); + EXPECT_EQ((simplex::solve(user_problem, settings, solution.x)), 0); } TEST(dual_simplex, burglar) @@ -109,7 +109,7 @@ TEST(dual_simplex, burglar) // take[i] binary for all i raft::handle_t handle{}; - cuopt::linear_programming::dual_simplex::user_problem_t user_problem(&handle); + cuopt::mathematical_optimization::simplex::user_problem_t user_problem(&handle); constexpr int m = 1; constexpr int n = num_items; constexpr int nz = num_items; @@ -152,12 +152,13 @@ TEST(dual_simplex, burglar) user_problem.obj_constant = 0.0; user_problem.var_types.resize(n); for (int j = 0; j < num_items; ++j) { - user_problem.var_types[j] = cuopt::linear_programming::dual_simplex::variable_type_t::INTEGER; + user_problem.var_types[j] = cuopt::mathematical_optimization::simplex::variable_type_t::INTEGER; } - cuopt::linear_programming::dual_simplex::simplex_solver_settings_t settings; + cuopt::mathematical_optimization::simplex::simplex_solver_settings_t settings; std::vector solution(num_items); - EXPECT_EQ((cuopt::linear_programming::dual_simplex::solve(user_problem, settings, solution)), 0); + EXPECT_EQ((cuopt::mathematical_optimization::simplex::solve(user_problem, settings, solution)), + 0); double objective = 0.0; for (int j = 0; j < num_items; ++j) { objective += value[j] * solution[j]; @@ -185,7 +186,7 @@ TEST(dual_simplex, empty_columns) // take[i] binary for all i raft::handle_t handle{}; - cuopt::linear_programming::dual_simplex::user_problem_t user_problem(&handle); + cuopt::mathematical_optimization::simplex::user_problem_t user_problem(&handle); constexpr int m = 1; constexpr int n = num_items; constexpr int nz = num_items - 1; @@ -233,16 +234,16 @@ TEST(dual_simplex, empty_columns) user_problem.var_types.resize(n); for (int j = 0; j < num_items; ++j) { user_problem.var_types[j] = - cuopt::linear_programming::dual_simplex::variable_type_t::CONTINUOUS; + cuopt::mathematical_optimization::simplex::variable_type_t::CONTINUOUS; } - cuopt::linear_programming::dual_simplex::simplex_solver_settings_t settings; + cuopt::mathematical_optimization::simplex::simplex_solver_settings_t settings; - cuopt::linear_programming::dual_simplex::lp_solution_t solution( + cuopt::mathematical_optimization::simplex::lp_solution_t solution( user_problem.num_rows, user_problem.num_cols); - EXPECT_EQ((cuopt::linear_programming::dual_simplex::solve_linear_program( + EXPECT_EQ((cuopt::mathematical_optimization::simplex::solve_linear_program( user_problem, settings, solution)), - cuopt::linear_programming::dual_simplex::lp_status_t::OPTIMAL); + cuopt::mathematical_optimization::simplex::lp_status_t::OPTIMAL); double objective = 0.0; for (int j = 0; j < num_items; ++j) { objective += value[j] * solution.x[j]; @@ -268,7 +269,7 @@ TEST(dual_simplex, dual_variable_greater_than) // x0, x1 >= 0 raft::handle_t handle{}; - cuopt::linear_programming::dual_simplex::user_problem_t user_problem(&handle); + cuopt::mathematical_optimization::simplex::user_problem_t user_problem(&handle); constexpr int m = 2; constexpr int n = 2; constexpr int nz = 4; @@ -312,16 +313,16 @@ TEST(dual_simplex, dual_variable_greater_than) user_problem.lower[1] = 0.0; user_problem.upper.resize(n); - user_problem.upper[0] = dual_simplex::inf; - user_problem.upper[1] = dual_simplex::inf; + user_problem.upper[0] = simplex::inf; + user_problem.upper[1] = simplex::inf; user_problem.num_range_rows = 0; user_problem.problem_name = "dual_variable_greater_than"; - dual_simplex::simplex_solver_settings_t settings; - dual_simplex::lp_solution_t solution(user_problem.num_rows, user_problem.num_cols); - EXPECT_EQ((dual_simplex::solve_linear_program(user_problem, settings, solution)), - dual_simplex::lp_status_t::OPTIMAL); + simplex::simplex_solver_settings_t settings; + simplex::lp_solution_t solution(user_problem.num_rows, user_problem.num_cols); + EXPECT_EQ((simplex::solve_linear_program(user_problem, settings, solution)), + simplex::lp_status_t::OPTIMAL); EXPECT_NEAR(solution.objective, 3.0, 1e-6); EXPECT_NEAR(solution.x[0], 0.0, 1e-6); EXPECT_NEAR(solution.x[1], 1.5, 1e-6); @@ -331,4 +332,4 @@ TEST(dual_simplex, dual_variable_greater_than) EXPECT_NEAR(solution.z[1], 0.0, 1e-6); } -} // namespace cuopt::linear_programming::dual_simplex::test +} // namespace cuopt::mathematical_optimization::simplex::test diff --git a/cpp/tests/dual_simplex/unit_tests/solve_barrier.cu b/cpp/tests/dual_simplex/unit_tests/solve_barrier.cu index 0141a4eae6..87ce592b82 100644 --- a/cpp/tests/dual_simplex/unit_tests/solve_barrier.cu +++ b/cpp/tests/dual_simplex/unit_tests/solve_barrier.cu @@ -12,9 +12,9 @@ #include -#include -#include -#include +#include +#include +#include #include #include #include @@ -24,10 +24,10 @@ #include #include -#include +#include #include -namespace cuopt::linear_programming::dual_simplex::test { +namespace cuopt::mathematical_optimization::simplex::test { // This serves as both a warm up but also a mandatory initial call to setup cuSparse and cuBLAS static void init_handler(const raft::handle_t* handle_ptr) @@ -42,10 +42,10 @@ static void init_handler(const raft::handle_t* handle_ptr) TEST(barrier, chess_set) { cuopt::init_logger_t log("", true); - namespace dual_simplex = cuopt::linear_programming::dual_simplex; + namespace simplex = cuopt::mathematical_optimization::simplex; raft::handle_t handle{}; init_handler(&handle); - dual_simplex::user_problem_t user_problem(&handle); + simplex::user_problem_t user_problem(&handle); // maximize 5*xs + 20*xl // subject to 1*xs + 3*xl <= 200 // 3*xs + 2*xl <= 160 @@ -84,8 +84,8 @@ TEST(barrier, chess_set) user_problem.lower[0] = 0; user_problem.lower[1] = 0.0; user_problem.upper.resize(n); - user_problem.upper[0] = dual_simplex::inf; - user_problem.upper[1] = dual_simplex::inf; + user_problem.upper[0] = simplex::inf; + user_problem.upper[1] = simplex::inf; user_problem.num_range_rows = 0; user_problem.problem_name = "chess set"; user_problem.row_names.resize(m); @@ -96,13 +96,13 @@ TEST(barrier, chess_set) user_problem.col_names[1] = "xl"; user_problem.obj_constant = 0.0; user_problem.var_types.resize(n); - user_problem.var_types[0] = dual_simplex::variable_type_t::CONTINUOUS; - user_problem.var_types[1] = dual_simplex::variable_type_t::CONTINUOUS; + user_problem.var_types[0] = simplex::variable_type_t::CONTINUOUS; + user_problem.var_types[1] = simplex::variable_type_t::CONTINUOUS; - dual_simplex::simplex_solver_settings_t settings; - dual_simplex::lp_solution_t solution(user_problem.num_rows, user_problem.num_cols); - EXPECT_EQ((dual_simplex::solve_linear_program_with_barrier(user_problem, settings, solution)), - dual_simplex::lp_status_t::OPTIMAL); + simplex::simplex_solver_settings_t settings; + simplex::lp_solution_t solution(user_problem.num_rows, user_problem.num_cols); + EXPECT_EQ((simplex::solve_linear_program_with_barrier(user_problem, settings, solution)), + simplex::lp_status_t::OPTIMAL); const double objective = -solution.objective; EXPECT_NEAR(objective, 1333.33, 1e-2); EXPECT_NEAR(solution.x[0], 0.0, 1e-6); @@ -119,7 +119,7 @@ TEST(barrier, dual_variable_greater_than) raft::handle_t handle{}; init_handler(&handle); - cuopt::linear_programming::dual_simplex::user_problem_t user_problem(&handle); + cuopt::mathematical_optimization::simplex::user_problem_t user_problem(&handle); constexpr int m = 2; constexpr int n = 2; constexpr int nz = 4; @@ -163,16 +163,16 @@ TEST(barrier, dual_variable_greater_than) user_problem.lower[1] = 0.0; user_problem.upper.resize(n); - user_problem.upper[0] = dual_simplex::inf; - user_problem.upper[1] = dual_simplex::inf; + user_problem.upper[0] = simplex::inf; + user_problem.upper[1] = simplex::inf; user_problem.num_range_rows = 0; user_problem.problem_name = "dual_variable_greater_than"; - dual_simplex::simplex_solver_settings_t settings; - dual_simplex::lp_solution_t solution(user_problem.num_rows, user_problem.num_cols); - EXPECT_EQ((dual_simplex::solve_linear_program_with_barrier(user_problem, settings, solution)), - dual_simplex::lp_status_t::OPTIMAL); + simplex::simplex_solver_settings_t settings; + simplex::lp_solution_t solution(user_problem.num_rows, user_problem.num_cols); + EXPECT_EQ((simplex::solve_linear_program_with_barrier(user_problem, settings, solution)), + simplex::lp_status_t::OPTIMAL); EXPECT_NEAR(solution.objective, 3.0, 1e-5); EXPECT_NEAR(solution.x[0], 0.0, 1e-5); EXPECT_NEAR(solution.x[1], 1.5, 1e-5); @@ -197,11 +197,11 @@ TEST(barrier, min_x_squared_free_variable_dual_correction) auto path = cuopt::test::get_rapids_dataset_root_dir() + "/quadratic_programming/min_x_squared.mps"; - auto mps_data = cuopt::linear_programming::io::read_mps(path); + auto mps_data = cuopt::mathematical_optimization::io::read_mps(path); - auto settings = cuopt::linear_programming::pdlp_solver_settings_t{}; + auto settings = cuopt::mathematical_optimization::pdlp_solver_settings_t{}; - auto solution = cuopt::linear_programming::solve_lp(&handle, mps_data, settings); + auto solution = cuopt::mathematical_optimization::solve_lp(&handle, mps_data, settings); EXPECT_EQ((int)solution.get_termination_status(), CUOPT_TERMINATION_STATUS_OPTIMAL); @@ -217,4 +217,4 @@ TEST(barrier, min_x_squared_free_variable_dual_correction) EXPECT_NEAR(h_z[0], 0.0, tol); } -} // namespace cuopt::linear_programming::dual_simplex::test +} // namespace cuopt::mathematical_optimization::simplex::test diff --git a/cpp/tests/linear_programming/c_api_tests/c_api_test.c b/cpp/tests/linear_programming/c_api_tests/c_api_test.c index d2f73f4073..3945445928 100644 --- a/cpp/tests/linear_programming/c_api_tests/c_api_test.c +++ b/cpp/tests/linear_programming/c_api_tests/c_api_test.c @@ -7,7 +7,7 @@ #include "c_api_tests.h" -#include +#include #include #include diff --git a/cpp/tests/linear_programming/c_api_tests/c_api_tests.cpp b/cpp/tests/linear_programming/c_api_tests/c_api_tests.cpp index 9a92f7a310..08eda8f13c 100644 --- a/cpp/tests/linear_programming/c_api_tests/c_api_tests.cpp +++ b/cpp/tests/linear_programming/c_api_tests/c_api_tests.cpp @@ -13,13 +13,13 @@ #include #include -#include +#include #include #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::mathematical_optimization::pdlp { bool is_cusparse_runtime_mixed_precision_supported(); } @@ -285,7 +285,7 @@ TEST(c_api, test_maximize_problem_dual_variables) static bool test_mps_roundtrip(const std::string& mps_file_path) { - using cuopt::linear_programming::problem_and_stream_view_t; + using cuopt::mathematical_optimization::problem_and_stream_view_t; cuOptOptimizationProblem original_handle = nullptr; cuOptOptimizationProblem reread_handle = nullptr; @@ -406,12 +406,12 @@ TEST(c_api, pdlp_precision_single) TEST(c_api, pdlp_precision_mixed) { - using namespace cuopt::linear_programming::detail; + using namespace cuopt::mathematical_optimization::pdlp; const std::string& rapidsDatasetRootDir = cuopt::test::get_rapids_dataset_root_dir(); std::string filename = rapidsDatasetRootDir + "/linear_programming/afiro_original.mps"; cuopt_int_t termination_status = -1; cuopt_float_t objective; - if (!is_cusparse_runtime_mixed_precision_supported()) { + if (!cuopt::mathematical_optimization::pdlp::is_cusparse_runtime_mixed_precision_supported()) { auto status = test_pdlp_precision_mixed(filename.c_str(), &termination_status, &objective); bool solve_returned_error = (status != CUOPT_SUCCESS); bool solve_returned_non_optimal = diff --git a/cpp/tests/linear_programming/c_api_tests/c_api_tests.h b/cpp/tests/linear_programming/c_api_tests/c_api_tests.h index b80c0ec931..207a8cd224 100644 --- a/cpp/tests/linear_programming/c_api_tests/c_api_tests.h +++ b/cpp/tests/linear_programming/c_api_tests/c_api_tests.h @@ -5,7 +5,7 @@ */ /* clang-format on */ -#include +#include #ifdef __cplusplus extern "C" { diff --git a/cpp/tests/linear_programming/grpc/grpc_client_test.cpp b/cpp/tests/linear_programming/grpc/grpc_client_test.cpp index 28bd6a27e9..406e93df90 100644 --- a/cpp/tests/linear_programming/grpc/grpc_client_test.cpp +++ b/cpp/tests/linear_programming/grpc/grpc_client_test.cpp @@ -18,12 +18,12 @@ #include -#include -#include -#include -#include -#include -#include +#include +#include +#include +#include +#include +#include #include "grpc_client.hpp" #include "grpc_problem_mapper.hpp" #include "grpc_service_mapper.hpp" @@ -38,7 +38,7 @@ #include -using namespace cuopt::linear_programming; +using namespace cuopt::mathematical_optimization; using namespace ::testing; /** diff --git a/cpp/tests/linear_programming/grpc/grpc_client_test_helper.hpp b/cpp/tests/linear_programming/grpc/grpc_client_test_helper.hpp index de6d391dce..26c6688a93 100644 --- a/cpp/tests/linear_programming/grpc/grpc_client_test_helper.hpp +++ b/cpp/tests/linear_programming/grpc/grpc_client_test_helper.hpp @@ -20,7 +20,7 @@ #include "grpc_client.hpp" -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { /** * @brief Inject a mock stub into a grpc_client_t instance for testing @@ -62,4 +62,4 @@ inline void grpc_test_inject_mock_stub_typed(grpc_client_t& client, std::shared_ grpc_test_inject_mock_stub(client, std::static_pointer_cast(stub)); } -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/tests/linear_programming/grpc/grpc_integration_test.cpp b/cpp/tests/linear_programming/grpc/grpc_integration_test.cpp index 15cc82d28f..5b1e890db8 100644 --- a/cpp/tests/linear_programming/grpc/grpc_integration_test.cpp +++ b/cpp/tests/linear_programming/grpc/grpc_integration_test.cpp @@ -35,13 +35,13 @@ #include #include -#include -#include -#include -#include -#include -#include -#include +#include +#include +#include +#include +#include +#include +#include #include #include "grpc_client.hpp" @@ -66,8 +66,8 @@ #include #include -using namespace cuopt::linear_programming; -using cuopt::linear_programming::testing::GrpcTestLogCapture; +using namespace cuopt::mathematical_optimization; +using cuopt::mathematical_optimization::testing::GrpcTestLogCapture; namespace { @@ -384,7 +384,7 @@ class GrpcIntegrationTestBase : public ::testing::Test { // optional .gz/.bz2). See io::read() in parser.hpp. cpu_optimization_problem_t load_problem_from_file(const std::string& path) { - auto mps_data = cuopt::linear_programming::io::read(path); + auto mps_data = cuopt::mathematical_optimization::io::read(path); cpu_optimization_problem_t problem; populate_from_mps_data_model(&problem, mps_data); return problem; diff --git a/cpp/tests/linear_programming/grpc/grpc_pipe_serialization_test.cpp b/cpp/tests/linear_programming/grpc/grpc_pipe_serialization_test.cpp index 292f425de6..988057db01 100644 --- a/cpp/tests/linear_programming/grpc/grpc_pipe_serialization_test.cpp +++ b/cpp/tests/linear_programming/grpc/grpc_pipe_serialization_test.cpp @@ -31,7 +31,7 @@ #include "grpc_pipe_serialization.hpp" using namespace cuopt::remote; -using cuopt::linear_programming::container_array_key_t; +using cuopt::mathematical_optimization::container_array_key_t; // --------------------------------------------------------------------------- // RAII wrapper for a pipe(2) pair. diff --git a/cpp/tests/linear_programming/grpc/grpc_test_log_capture.hpp b/cpp/tests/linear_programming/grpc/grpc_test_log_capture.hpp index 37b1f698cf..1bbe33e8a3 100644 --- a/cpp/tests/linear_programming/grpc/grpc_test_log_capture.hpp +++ b/cpp/tests/linear_programming/grpc/grpc_test_log_capture.hpp @@ -47,7 +47,7 @@ #include #include -namespace cuopt::linear_programming::testing { +namespace cuopt::mathematical_optimization::testing { /** * @brief Log entry with metadata @@ -378,4 +378,4 @@ class GrpcTestLogCapture { std::atomic test_start_marked_{false}; }; -} // namespace cuopt::linear_programming::testing +} // namespace cuopt::mathematical_optimization::testing diff --git a/cpp/tests/linear_programming/parser_test.cpp b/cpp/tests/linear_programming/parser_test.cpp index af1368865d..9260c4d4fe 100644 --- a/cpp/tests/linear_programming/parser_test.cpp +++ b/cpp/tests/linear_programming/parser_test.cpp @@ -8,8 +8,8 @@ #include #include -#include -#include +#include +#include #include #include @@ -29,7 +29,7 @@ #include #include -namespace cuopt::linear_programming::io { +namespace cuopt::mathematical_optimization::io { constexpr double tolerance = 1e-6; @@ -2897,4 +2897,4 @@ TEST(mps_roundtrip, qcqp_p0033_qc1) auto reloaded_2 = read_mps(temp_file_2.string(), false); compare_data_models(reloaded, reloaded_2); } -} // namespace cuopt::linear_programming::io +} // namespace cuopt::mathematical_optimization::io diff --git a/cpp/tests/linear_programming/pdlp_test.cu b/cpp/tests/linear_programming/pdlp_test.cu index e4c8bc6767..33ac914c35 100644 --- a/cpp/tests/linear_programming/pdlp_test.cu +++ b/cpp/tests/linear_programming/pdlp_test.cu @@ -22,12 +22,12 @@ #include #include -#include -#include -#include -#include -#include -#include +#include +#include +#include +#include +#include +#include #include #include @@ -56,7 +56,7 @@ #include #include -namespace cuopt::linear_programming::test { +namespace cuopt::mathematical_optimization::test { constexpr double afiro_primal_objective = -464.0; @@ -79,11 +79,11 @@ TEST(pdlp_class, run_double) const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/afiro_original.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path, true); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path, true); auto solver_settings = pdlp_solver_settings_t{}; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; optimization_problem_solution_t solution = solve_lp(&handle_, op_problem, solver_settings); @@ -94,16 +94,16 @@ TEST(pdlp_class, run_double) TEST(pdlp_class, precision_mixed) { - using namespace cuopt::linear_programming::detail; + using namespace cuopt::mathematical_optimization::pdlp; if (!is_cusparse_runtime_mixed_precision_supported()) { const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/afiro_original.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path, true); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path, true); auto settings = pdlp_solver_settings_t{}; - settings.method = cuopt::linear_programming::method_t::PDLP; - settings.pdlp_precision = cuopt::linear_programming::pdlp_precision_t::MixedPrecision; + settings.method = cuopt::mathematical_optimization::method_t::PDLP; + settings.pdlp_precision = cuopt::mathematical_optimization::pdlp_precision_t::MixedPrecision; optimization_problem_solution_t solution = solve_lp(&handle_, op_problem, settings); @@ -114,12 +114,13 @@ TEST(pdlp_class, precision_mixed) const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/afiro_original.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path, true); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path, true); - auto settings_mixed = pdlp_solver_settings_t{}; - settings_mixed.method = cuopt::linear_programming::method_t::PDLP; - settings_mixed.pdlp_precision = cuopt::linear_programming::pdlp_precision_t::MixedPrecision; + auto settings_mixed = pdlp_solver_settings_t{}; + settings_mixed.method = cuopt::mathematical_optimization::method_t::PDLP; + settings_mixed.pdlp_precision = + cuopt::mathematical_optimization::pdlp_precision_t::MixedPrecision; optimization_problem_solution_t solution_mixed = solve_lp(&handle_, op_problem, settings_mixed); @@ -128,9 +129,10 @@ TEST(pdlp_class, precision_mixed) afiro_primal_objective, solution_mixed.get_additional_termination_information().primal_objective)); - auto settings_full = pdlp_solver_settings_t{}; - settings_full.method = cuopt::linear_programming::method_t::PDLP; - settings_full.pdlp_precision = cuopt::linear_programming::pdlp_precision_t::DefaultPrecision; + auto settings_full = pdlp_solver_settings_t{}; + settings_full.method = cuopt::mathematical_optimization::method_t::PDLP; + settings_full.pdlp_precision = + cuopt::mathematical_optimization::pdlp_precision_t::DefaultPrecision; optimization_problem_solution_t solution_full = solve_lp(&handle_, op_problem, settings_full); @@ -149,12 +151,12 @@ TEST(pdlp_class, concurrent_pdlp_exception_joins_worker_threads) const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/afiro_original.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path, true); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path, true); auto settings = pdlp_solver_settings_t{}; - settings.method = cuopt::linear_programming::method_t::Concurrent; - settings.presolver = cuopt::linear_programming::presolver_t::None; + settings.method = cuopt::mathematical_optimization::method_t::Concurrent; + settings.presolver = cuopt::mathematical_optimization::presolver_t::None; settings.log_to_console = false; // In concurrent mode, dual simplex and barrier workers are started before PDLP validates that // all_primal_feasible is batch-only. This exercises the exception path with live worker threads. @@ -173,11 +175,11 @@ TEST(pdlp_class, run_double_very_low_accuracy) const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/afiro_original.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path, true); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path, true); - cuopt::linear_programming::pdlp_solver_settings_t settings = - cuopt::linear_programming::pdlp_solver_settings_t{}; + cuopt::mathematical_optimization::pdlp_solver_settings_t settings = + cuopt::mathematical_optimization::pdlp_solver_settings_t{}; // With all 0 afiro with return an error // Setting absolute tolerance to the minimal value of 1e-12 will make it work settings.tolerances.absolute_dual_tolerance = settings.minimal_absolute_tolerance; @@ -186,7 +188,7 @@ TEST(pdlp_class, run_double_very_low_accuracy) settings.tolerances.relative_primal_tolerance = 0.0; settings.tolerances.absolute_gap_tolerance = settings.minimal_absolute_tolerance; settings.tolerances.relative_gap_tolerance = 0.0; - settings.method = cuopt::linear_programming::method_t::PDLP; + settings.method = cuopt::mathematical_optimization::method_t::PDLP; optimization_problem_solution_t solution = solve_lp(&handle_, op_problem, settings); EXPECT_EQ((int)solution.get_termination_status(), CUOPT_TERMINATION_STATUS_OPTIMAL); @@ -199,15 +201,15 @@ TEST(pdlp_class, run_double_initial_solution) const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/afiro_original.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path, true); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path, true); std::vector inital_primal_sol(op_problem.get_n_variables()); std::fill(inital_primal_sol.begin(), inital_primal_sol.end(), 1.0); op_problem.set_initial_primal_solution(inital_primal_sol); auto solver_settings = pdlp_solver_settings_t{}; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; optimization_problem_solution_t solution = solve_lp(&handle_, op_problem, solver_settings); @@ -221,16 +223,16 @@ TEST(pdlp_class, run_iteration_limit) const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/afiro_original.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path, true); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path, true); - cuopt::linear_programming::pdlp_solver_settings_t settings = - cuopt::linear_programming::pdlp_solver_settings_t{}; + cuopt::mathematical_optimization::pdlp_solver_settings_t settings = + cuopt::mathematical_optimization::pdlp_solver_settings_t{}; settings.iteration_limit = 10; // To make sure it doesn't return before the iteration limit settings.set_optimality_tolerance(0); - settings.method = cuopt::linear_programming::method_t::PDLP; + settings.method = cuopt::mathematical_optimization::method_t::PDLP; optimization_problem_solution_t solution = solve_lp(&handle_, op_problem, settings); EXPECT_EQ((int)solution.get_termination_status(), CUOPT_TERMINATION_STATUS_ITERATION_LIMIT); @@ -246,8 +248,8 @@ TEST(pdlp_class, batch_iteration_limit_updates_additional_termination_stats) const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/afiro_original.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path, true); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path, true); auto settings = pdlp_solver_settings_t{}; settings.iteration_limit = 10; @@ -279,8 +281,8 @@ TEST(pdlp_class, batch_settings_overrides_preserve_user_limits_and_tolerances) const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/afiro_original.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path, true); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path, true); constexpr int batch_size = 2; constexpr double tighter_tolerance = 1e-6; @@ -363,17 +365,17 @@ TEST(pdlp_class, run_time_limit) { const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/savsched1/savsched1.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path); - cuopt::linear_programming::pdlp_solver_settings_t settings = - cuopt::linear_programming::pdlp_solver_settings_t{}; + cuopt::mathematical_optimization::pdlp_solver_settings_t settings = + cuopt::mathematical_optimization::pdlp_solver_settings_t{}; constexpr double time_limit_seconds = 2; settings.time_limit = time_limit_seconds; // To make sure it doesn't return before the time limit settings.set_optimality_tolerance(0); - settings.method = cuopt::linear_programming::method_t::PDLP; + settings.method = cuopt::mathematical_optimization::method_t::PDLP; optimization_problem_solution_t solution = solve_lp(&handle_, op_problem, settings); @@ -408,17 +410,17 @@ TEST(pdlp_class, run_sub_mittleman) const auto expected_objective_value = entry.second; auto path = make_path_absolute("linear_programming/" + name + "/" + name + ".mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path); // Testing for each solver_mode is ok as it's parsing that is the bottleneck here, not // solving auto solver_mode_list = { - cuopt::linear_programming::pdlp_solver_mode_t::Stable3, - cuopt::linear_programming::pdlp_solver_mode_t::Stable2, - cuopt::linear_programming::pdlp_solver_mode_t::Stable1, - cuopt::linear_programming::pdlp_solver_mode_t::Methodical1, - cuopt::linear_programming::pdlp_solver_mode_t::Fast1, + cuopt::mathematical_optimization::pdlp_solver_mode_t::Stable3, + cuopt::mathematical_optimization::pdlp_solver_mode_t::Stable2, + cuopt::mathematical_optimization::pdlp_solver_mode_t::Stable1, + cuopt::mathematical_optimization::pdlp_solver_mode_t::Methodical1, + cuopt::mathematical_optimization::pdlp_solver_mode_t::Fast1, }; for (auto solver_mode : solver_mode_list) { auto settings = pdlp_solver_settings_t{}; @@ -427,7 +429,7 @@ TEST(pdlp_class, run_sub_mittleman) for (auto [presolver, epsilon] : {std::pair{presolver_t::Papilo, 1e-1}, std::pair{presolver_t::None, 1e-4}}) { settings.presolver = presolver; - settings.method = cuopt::linear_programming::method_t::PDLP; + settings.method = cuopt::mathematical_optimization::method_t::PDLP; const raft::handle_t handle_{}; optimization_problem_solution_t solution = solve_lp(&handle_, op_problem, settings); @@ -466,20 +468,22 @@ TEST(pdlp_class, initial_solution_test) const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/afiro_original.mps"); - cuopt::linear_programming::io::mps_data_model_t mps_data_model = - cuopt::linear_programming::io::read_mps(path); + cuopt::mathematical_optimization::io::mps_data_model_t mps_data_model = + cuopt::mathematical_optimization::io::read_mps(path); - auto op_problem = cuopt::linear_programming::mps_data_model_to_optimization_problem( - &handle_, mps_data_model); - cuopt::linear_programming::detail::problem_t problem(op_problem); + auto op_problem = + cuopt::mathematical_optimization::mps_data_model_to_optimization_problem( + &handle_, mps_data_model); + cuopt::mathematical_optimization::mip::problem_t problem(op_problem); auto solver_settings = pdlp_solver_settings_t{}; // We are just testing initial scaling on initial solution scheme so we don't care about solver solver_settings.iteration_limit = 0; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; // Empty call solve to set the parameters and init the handler since calling pdlp object directly // doesn't - solver_settings.pdlp_solver_mode = cuopt::linear_programming::pdlp_solver_mode_t::Methodical1; + solver_settings.pdlp_solver_mode = + cuopt::mathematical_optimization::pdlp_solver_mode_t::Methodical1; set_pdlp_solver_mode(solver_settings); EXPECT_EQ(solver_settings.hyper_params.initial_step_size_scaling, 1); EXPECT_EQ(solver_settings.hyper_params.default_l_inf_ruiz_iterations, 5); @@ -491,7 +495,8 @@ TEST(pdlp_class, initial_solution_test) EXPECT_FALSE(solver_settings.hyper_params.update_primal_weight_on_initial_solution); { - cuopt::linear_programming::detail::pdlp_solver_t solver(problem, solver_settings); + cuopt::mathematical_optimization::pdlp::pdlp_solver_t solver(problem, + solver_settings); auto pdlp_timer = timer_t(solver_settings.time_limit); solver.run_solver(pdlp_timer); RAFT_CUDA_TRY(cudaStreamSynchronize(handle_.get_stream())); @@ -502,7 +507,8 @@ TEST(pdlp_class, initial_solution_test) // First add an initial primal then dual, then both, which shouldn't influence the values as the // scale on initial option is not toggled { - cuopt::linear_programming::detail::pdlp_solver_t solver(problem, solver_settings); + cuopt::mathematical_optimization::pdlp::pdlp_solver_t solver(problem, + solver_settings); auto pdlp_timer = timer_t(solver_settings.time_limit); std::vector initial_primal(op_problem.get_n_variables(), 1); auto d_initial_primal = device_copy(initial_primal, handle_.get_stream()); @@ -513,7 +519,8 @@ TEST(pdlp_class, initial_solution_test) EXPECT_NEAR(initial_primal_weight_afiro, solver.get_primal_weight_h(0), factor_tolerance); } { - cuopt::linear_programming::detail::pdlp_solver_t solver(problem, solver_settings); + cuopt::mathematical_optimization::pdlp::pdlp_solver_t solver(problem, + solver_settings); auto pdlp_timer = timer_t(solver_settings.time_limit); std::vector initial_dual(op_problem.get_n_constraints(), 1); auto d_initial_dual = device_copy(initial_dual, handle_.get_stream()); @@ -524,7 +531,8 @@ TEST(pdlp_class, initial_solution_test) EXPECT_NEAR(initial_primal_weight_afiro, solver.get_primal_weight_h(0), factor_tolerance); } { - cuopt::linear_programming::detail::pdlp_solver_t solver(problem, solver_settings); + cuopt::mathematical_optimization::pdlp::pdlp_solver_t solver(problem, + solver_settings); auto pdlp_timer = timer_t(solver_settings.time_limit); std::vector initial_primal(op_problem.get_n_variables(), 1); auto d_initial_primal = device_copy(initial_primal, handle_.get_stream()); @@ -540,7 +548,8 @@ TEST(pdlp_class, initial_solution_test) // Toggle the scale on initial solution while not providing should yield the same { - cuopt::linear_programming::detail::pdlp_solver_t solver(problem, solver_settings); + cuopt::mathematical_optimization::pdlp::pdlp_solver_t solver(problem, + solver_settings); auto pdlp_timer = timer_t(solver_settings.time_limit); solver_settings.hyper_params.update_step_size_on_initial_solution = true; solver.run_solver(pdlp_timer); @@ -550,7 +559,8 @@ TEST(pdlp_class, initial_solution_test) solver_settings.hyper_params.update_step_size_on_initial_solution = false; } { - cuopt::linear_programming::detail::pdlp_solver_t solver(problem, solver_settings); + cuopt::mathematical_optimization::pdlp::pdlp_solver_t solver(problem, + solver_settings); auto pdlp_timer = timer_t(solver_settings.time_limit); solver_settings.hyper_params.update_primal_weight_on_initial_solution = true; solver.run_solver(pdlp_timer); @@ -560,7 +570,8 @@ TEST(pdlp_class, initial_solution_test) solver_settings.hyper_params.update_primal_weight_on_initial_solution = false; } { - cuopt::linear_programming::detail::pdlp_solver_t solver(problem, solver_settings); + cuopt::mathematical_optimization::pdlp::pdlp_solver_t solver(problem, + solver_settings); auto pdlp_timer = timer_t(solver_settings.time_limit); solver_settings.hyper_params.update_primal_weight_on_initial_solution = true; solver_settings.hyper_params.update_step_size_on_initial_solution = true; @@ -576,7 +587,8 @@ TEST(pdlp_class, initial_solution_test) // should not break but not modify the step size { solver_settings.hyper_params.update_step_size_on_initial_solution = true; - cuopt::linear_programming::detail::pdlp_solver_t solver(problem, solver_settings); + cuopt::mathematical_optimization::pdlp::pdlp_solver_t solver(problem, + solver_settings); auto pdlp_timer = timer_t(solver_settings.time_limit); std::vector initial_primal(op_problem.get_n_variables(), 1); auto d_initial_primal = device_copy(initial_primal, handle_.get_stream()); @@ -589,7 +601,8 @@ TEST(pdlp_class, initial_solution_test) } { solver_settings.hyper_params.update_step_size_on_initial_solution = true; - cuopt::linear_programming::detail::pdlp_solver_t solver(problem, solver_settings); + cuopt::mathematical_optimization::pdlp::pdlp_solver_t solver(problem, + solver_settings); auto pdlp_timer = timer_t(solver_settings.time_limit); std::vector initial_dual(op_problem.get_n_constraints(), 1); auto d_initial_dual = device_copy(initial_dual, handle_.get_stream()); @@ -605,7 +618,8 @@ TEST(pdlp_class, initial_solution_test) // dual should *not* break but the primal weight should not change { solver_settings.hyper_params.update_primal_weight_on_initial_solution = true; - cuopt::linear_programming::detail::pdlp_solver_t solver(problem, solver_settings); + cuopt::mathematical_optimization::pdlp::pdlp_solver_t solver(problem, + solver_settings); auto pdlp_timer = timer_t(solver_settings.time_limit); std::vector initial_primal(op_problem.get_n_variables(), 1); auto d_initial_primal = device_copy(initial_primal, handle_.get_stream()); @@ -617,7 +631,8 @@ TEST(pdlp_class, initial_solution_test) } { solver_settings.hyper_params.update_primal_weight_on_initial_solution = true; - cuopt::linear_programming::detail::pdlp_solver_t solver(problem, solver_settings); + cuopt::mathematical_optimization::pdlp::pdlp_solver_t solver(problem, + solver_settings); auto pdlp_timer = timer_t(solver_settings.time_limit); std::vector initial_dual(op_problem.get_n_constraints(), 1); auto d_initial_dual = device_copy(initial_dual, handle_.get_stream()); @@ -632,7 +647,8 @@ TEST(pdlp_class, initial_solution_test) // break but not change primal weight and step size { solver_settings.hyper_params.update_step_size_on_initial_solution = true; - cuopt::linear_programming::detail::pdlp_solver_t solver(problem, solver_settings); + cuopt::mathematical_optimization::pdlp::pdlp_solver_t solver(problem, + solver_settings); auto pdlp_timer = timer_t(solver_settings.time_limit); std::vector initial_primal(op_problem.get_n_variables(), 0); auto d_initial_primal = device_copy(initial_primal, handle_.get_stream()); @@ -650,7 +666,8 @@ TEST(pdlp_class, initial_solution_test) // *not* an error but should not change primal weight and step size { solver_settings.hyper_params.update_primal_weight_on_initial_solution = true; - cuopt::linear_programming::detail::pdlp_solver_t solver(problem, solver_settings); + cuopt::mathematical_optimization::pdlp::pdlp_solver_t solver(problem, + solver_settings); auto pdlp_timer = timer_t(solver_settings.time_limit); std::vector initial_primal(op_problem.get_n_variables(), 0); auto d_initial_primal = device_copy(initial_primal, handle_.get_stream()); @@ -662,7 +679,8 @@ TEST(pdlp_class, initial_solution_test) } { solver_settings.hyper_params.update_primal_weight_on_initial_solution = true; - cuopt::linear_programming::detail::pdlp_solver_t solver(problem, solver_settings); + cuopt::mathematical_optimization::pdlp::pdlp_solver_t solver(problem, + solver_settings); auto pdlp_timer = timer_t(solver_settings.time_limit); std::vector initial_dual(op_problem.get_n_constraints(), 0); auto d_initial_dual = device_copy(initial_dual, handle_.get_stream()); @@ -674,7 +692,8 @@ TEST(pdlp_class, initial_solution_test) } { solver_settings.hyper_params.update_primal_weight_on_initial_solution = true; - cuopt::linear_programming::detail::pdlp_solver_t solver(problem, solver_settings); + cuopt::mathematical_optimization::pdlp::pdlp_solver_t solver(problem, + solver_settings); auto pdlp_timer = timer_t(solver_settings.time_limit); std::vector initial_primal(op_problem.get_n_variables(), 0); auto d_initial_primal = device_copy(initial_primal, handle_.get_stream()); @@ -692,7 +711,8 @@ TEST(pdlp_class, initial_solution_test) // weight and step size { solver_settings.hyper_params.update_primal_weight_on_initial_solution = true; - cuopt::linear_programming::detail::pdlp_solver_t solver(problem, solver_settings); + cuopt::mathematical_optimization::pdlp::pdlp_solver_t solver(problem, + solver_settings); auto pdlp_timer = timer_t(solver_settings.time_limit); std::vector initial_primal(op_problem.get_n_variables(), 1); auto d_initial_primal = device_copy(initial_primal, handle_.get_stream()); @@ -707,7 +727,8 @@ TEST(pdlp_class, initial_solution_test) } { solver_settings.hyper_params.update_step_size_on_initial_solution = true; - cuopt::linear_programming::detail::pdlp_solver_t solver(problem, solver_settings); + cuopt::mathematical_optimization::pdlp::pdlp_solver_t solver(problem, + solver_settings); auto pdlp_timer = timer_t(solver_settings.time_limit); std::vector initial_primal(op_problem.get_n_variables(), 1); auto d_initial_primal = device_copy(initial_primal, handle_.get_stream()); @@ -723,7 +744,8 @@ TEST(pdlp_class, initial_solution_test) { solver_settings.hyper_params.update_primal_weight_on_initial_solution = true; solver_settings.hyper_params.update_step_size_on_initial_solution = true; - cuopt::linear_programming::detail::pdlp_solver_t solver(problem, solver_settings); + cuopt::mathematical_optimization::pdlp::pdlp_solver_t solver(problem, + solver_settings); auto pdlp_timer = timer_t(solver_settings.time_limit); std::vector initial_primal(op_problem.get_n_variables(), 1); auto d_initial_primal = device_copy(initial_primal, handle_.get_stream()); @@ -744,26 +766,29 @@ TEST(pdlp_class, initial_primal_weight_step_size_test) const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/afiro_original.mps"); - cuopt::linear_programming::io::mps_data_model_t mps_data_model = - cuopt::linear_programming::io::read_mps(path); + cuopt::mathematical_optimization::io::mps_data_model_t mps_data_model = + cuopt::mathematical_optimization::io::read_mps(path); - auto op_problem = cuopt::linear_programming::mps_data_model_to_optimization_problem( - &handle_, mps_data_model); - cuopt::linear_programming::detail::problem_t problem(op_problem); + auto op_problem = + cuopt::mathematical_optimization::mps_data_model_to_optimization_problem( + &handle_, mps_data_model); + cuopt::mathematical_optimization::mip::problem_t problem(op_problem); auto solver_settings = pdlp_solver_settings_t{}; // We are just testing initial scaling on initial solution scheme so we don't care about solver solver_settings.iteration_limit = 0; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; // Select the default/legacy solver with no action upon the initial scaling on initial solution - solver_settings.pdlp_solver_mode = cuopt::linear_programming::pdlp_solver_mode_t::Methodical1; + solver_settings.pdlp_solver_mode = + cuopt::mathematical_optimization::pdlp_solver_mode_t::Methodical1; set_pdlp_solver_mode(solver_settings); EXPECT_FALSE(solver_settings.hyper_params.update_step_size_on_initial_solution); EXPECT_FALSE(solver_settings.hyper_params.update_primal_weight_on_initial_solution); // Check setting an initial primal weight and step size { - cuopt::linear_programming::detail::pdlp_solver_t solver(problem, solver_settings); + cuopt::mathematical_optimization::pdlp::pdlp_solver_t solver(problem, + solver_settings); auto pdlp_timer = timer_t(solver_settings.time_limit); constexpr double test_initial_step_size = 1.0; constexpr double test_initial_primal_weight = 2.0; @@ -781,7 +806,8 @@ TEST(pdlp_class, initial_primal_weight_step_size_test) // Launching without an inital step size / primal weight and query the value solver_settings.hyper_params.update_primal_weight_on_initial_solution = true; solver_settings.hyper_params.update_step_size_on_initial_solution = true; - cuopt::linear_programming::detail::pdlp_solver_t solver(problem, solver_settings); + cuopt::mathematical_optimization::pdlp::pdlp_solver_t solver(problem, + solver_settings); auto pdlp_timer = timer_t(solver_settings.time_limit); std::vector initial_primal(op_problem.get_n_variables(), 1); auto d_initial_primal = device_copy(initial_primal, handle_.get_stream()); @@ -794,7 +820,8 @@ TEST(pdlp_class, initial_primal_weight_step_size_test) const double previous_primal_weight = solver.get_primal_weight_h(0); // Start again but with an initial and check the impact - cuopt::linear_programming::detail::pdlp_solver_t solver2(problem, solver_settings); + cuopt::mathematical_optimization::pdlp::pdlp_solver_t solver2(problem, + solver_settings); pdlp_timer = timer_t(solver_settings.time_limit); constexpr double test_initial_step_size = 1.0; constexpr double test_initial_primal_weight = 2.0; @@ -810,7 +837,8 @@ TEST(pdlp_class, initial_primal_weight_step_size_test) EXPECT_NOT_NEAR(previous_primal_weight, sovler2_primal_weight, factor_tolerance); // Again but with an initial k which should change the step size only, not the primal weight - cuopt::linear_programming::detail::pdlp_solver_t solver3(problem, solver_settings); + cuopt::mathematical_optimization::pdlp::pdlp_solver_t solver3(problem, + solver_settings); pdlp_timer = timer_t(solver_settings.time_limit); solver3.set_initial_primal_weight(test_initial_primal_weight); solver3.set_initial_step_size(test_initial_step_size); @@ -853,20 +881,21 @@ End raft::copy( d_initial_primal.data(), h_initial_primal.data(), h_initial_primal.size(), handle.get_stream()); - auto problem = cuopt::linear_programming::detail::problem_t(op_problem); + auto problem = cuopt::mathematical_optimization::mip::problem_t(op_problem); pdlp_solver_settings_t solver_settings; solver_settings.tolerances.relative_primal_tolerance = 0; // Shouldn't matter solver_settings.tolerances.absolute_primal_tolerance = 0.1; solver_settings.tolerances.relative_dual_tolerance = 0; // Shoudln't matter solver_settings.tolerances.absolute_dual_tolerance = 0.1; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; - solver_settings.pdlp_solver_mode = cuopt::linear_programming::pdlp_solver_mode_t::Stable2; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; + solver_settings.pdlp_solver_mode = cuopt::mathematical_optimization::pdlp_solver_mode_t::Stable2; set_pdlp_solver_mode(solver_settings); // First solve without the per constraint and it should break { - cuopt::linear_programming::detail::pdlp_solver_t solver(problem, solver_settings); + cuopt::mathematical_optimization::pdlp::pdlp_solver_t solver(problem, + solver_settings); raft::copy(solver.pdhg_solver_.get_primal_solution().data(), d_initial_primal.data(), @@ -890,7 +919,8 @@ End } { solver_settings.per_constraint_residual = true; - cuopt::linear_programming::detail::pdlp_solver_t solver(problem, solver_settings); + cuopt::mathematical_optimization::pdlp::pdlp_solver_t solver(problem, + solver_settings); raft::copy(solver.pdhg_solver_.get_primal_solution().data(), d_initial_primal.data(), @@ -925,12 +955,12 @@ TEST(pdlp_class, best_primal_so_far_iteration) auto solver_settings = pdlp_solver_settings_t{}; solver_settings.iteration_limit = 3000; solver_settings.per_constraint_residual = true; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; - solver_settings.pdlp_solver_mode = cuopt::linear_programming::pdlp_solver_mode_t::Stable2; - cuopt::linear_programming::io::mps_data_model_t op_problem1 = - cuopt::linear_programming::io::read_mps(path); - cuopt::linear_programming::io::mps_data_model_t op_problem2 = - cuopt::linear_programming::io::read_mps(path); + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; + solver_settings.pdlp_solver_mode = cuopt::mathematical_optimization::pdlp_solver_mode_t::Stable2; + cuopt::mathematical_optimization::io::mps_data_model_t op_problem1 = + cuopt::mathematical_optimization::io::read_mps(path); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem2 = + cuopt::mathematical_optimization::io::read_mps(path); optimization_problem_solution_t solution1 = solve_lp(&handle1, op_problem1, solver_settings); @@ -954,13 +984,13 @@ TEST(pdlp_class, best_primal_so_far_time) auto solver_settings = pdlp_solver_settings_t{}; solver_settings.time_limit = 2; solver_settings.per_constraint_residual = true; - solver_settings.pdlp_solver_mode = cuopt::linear_programming::pdlp_solver_mode_t::Stable1; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; + solver_settings.pdlp_solver_mode = cuopt::mathematical_optimization::pdlp_solver_mode_t::Stable1; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; - cuopt::linear_programming::io::mps_data_model_t op_problem1 = - cuopt::linear_programming::io::read_mps(path); - cuopt::linear_programming::io::mps_data_model_t op_problem2 = - cuopt::linear_programming::io::read_mps(path); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem1 = + cuopt::mathematical_optimization::io::read_mps(path); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem2 = + cuopt::mathematical_optimization::io::read_mps(path); optimization_problem_solution_t solution1 = solve_lp(&handle1, op_problem1, solver_settings); @@ -985,12 +1015,12 @@ TEST(pdlp_class, first_primal_feasible) solver_settings.iteration_limit = 1000; solver_settings.per_constraint_residual = true; solver_settings.set_optimality_tolerance(1e-2); - solver_settings.method = cuopt::linear_programming::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; - cuopt::linear_programming::io::mps_data_model_t op_problem1 = - cuopt::linear_programming::io::read_mps(path); - cuopt::linear_programming::io::mps_data_model_t op_problem2 = - cuopt::linear_programming::io::read_mps(path); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem1 = + cuopt::mathematical_optimization::io::read_mps(path); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem2 = + cuopt::mathematical_optimization::io::read_mps(path); optimization_problem_solution_t solution1 = solve_lp(&handle1, op_problem1, solver_settings); @@ -1015,10 +1045,10 @@ TEST(pdlp_class, per_constraint_residual_stable3) solver_settings.pdlp_solver_mode = pdlp_solver_mode_t::Stable3; solver_settings.per_constraint_residual = true; solver_settings.presolver = presolver_t::None; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path); auto sol = solve_lp(&handle, op_problem, solver_settings); RAFT_CUDA_TRY(cudaDeviceSynchronize()); @@ -1039,10 +1069,10 @@ TEST(pdlp_class, batch_per_constraint_residual_stable3) solver_settings.pdlp_solver_mode = pdlp_solver_mode_t::Stable3; solver_settings.per_constraint_residual = true; solver_settings.presolver = presolver_t::None; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path); constexpr int batch_size = 2; @@ -1086,10 +1116,10 @@ TEST(pdlp_class, batch_per_constraint_residual_different_rhs_stable3) solver_settings.pdlp_solver_mode = pdlp_solver_mode_t::Stable3; solver_settings.per_constraint_residual = true; solver_settings.presolver = presolver_t::None; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path); // Build two climbers that share A and variable bounds but differ on the constraint // lower/upper bounds (RHS): climber 0 keeps the original, climber 1 finite bounds get set to 100 @@ -1134,8 +1164,8 @@ TEST(pdlp_class, batch_per_constraint_residual_different_rhs_stable3) // Reload the original (single-climber) problem and build per-climber views so the // per-row sanity check evaluates each solution against its own constraint bounds. - auto climber0_problem = cuopt::linear_programming::io::read_mps(path); - auto climber1_problem = cuopt::linear_programming::io::read_mps(path); + auto climber0_problem = cuopt::mathematical_optimization::io::read_mps(path); + auto climber1_problem = cuopt::mathematical_optimization::io::read_mps(path); climber1_problem.set_constraint_lower_bounds({climber1_lb.data(), climber1_lb.size()}); climber1_problem.set_constraint_upper_bounds({climber1_ub.data(), climber1_ub.size()}); @@ -1168,11 +1198,11 @@ TEST(pdlp_class, first_primal_feasible_stable3) solver_settings.iteration_limit = 1000; solver_settings.set_optimality_tolerance(kOptimalityTolerance); solver_settings.pdlp_solver_mode = pdlp_solver_mode_t::Stable3; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; solver_settings.presolver = presolver_t::None; - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path); // Wihout first primal feasible we hit iteration limit auto sol_base = solve_lp(&handle, op_problem, solver_settings); @@ -1200,11 +1230,11 @@ TEST(pdlp_class, first_primal_feasible_batch_stable3) const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/ns1687037/ns1687037.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path); auto solver_settings = pdlp_solver_settings_t{}; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; solver_settings.pdlp_solver_mode = pdlp_solver_mode_t::Stable3; solver_settings.iteration_limit = 1000; solver_settings.first_primal_feasible = true; @@ -1247,11 +1277,11 @@ TEST(pdlp_class, first_primal_feasible_batch_different_rhs_stable3) const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/ns1687037/ns1687037.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path); auto solver_settings = pdlp_solver_settings_t{}; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; solver_settings.pdlp_solver_mode = pdlp_solver_mode_t::Stable3; solver_settings.iteration_limit = 1000; solver_settings.first_primal_feasible = true; @@ -1311,11 +1341,11 @@ TEST(pdlp_class, all_primal_feasible_batch_different_rhs_stable3) const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/ns1687037/ns1687037.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path); auto solver_settings = pdlp_solver_settings_t{}; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; solver_settings.pdlp_solver_mode = pdlp_solver_mode_t::Stable3; solver_settings.iteration_limit = 1000; solver_settings.all_primal_feasible = true; @@ -1383,10 +1413,10 @@ TEST(pdlp_class, first_primal_feasible_and_per_constraint_residual_stable3) constexpr double kOptimalityTolerance = 1e-2; solver_settings.set_optimality_tolerance(kOptimalityTolerance); solver_settings.presolver = presolver_t::None; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path); auto sol = solve_lp(&handle, op_problem, solver_settings); RAFT_CUDA_TRY(cudaDeviceSynchronize()); @@ -1408,11 +1438,11 @@ TEST(pdlp_class, first_primal_feasible_and_per_constraint_residual_batch_stable3 const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/ns1687037/ns1687037.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path); auto solver_settings = pdlp_solver_settings_t{}; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; solver_settings.pdlp_solver_mode = pdlp_solver_mode_t::Stable3; solver_settings.iteration_limit = 1000; solver_settings.first_primal_feasible = true; @@ -1455,11 +1485,11 @@ TEST(pdlp_class, first_primal_feasible_and_per_constraint_residual_batch_differe const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/ns1687037/ns1687037.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path); auto solver_settings = pdlp_solver_settings_t{}; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; solver_settings.pdlp_solver_mode = pdlp_solver_mode_t::Stable3; solver_settings.iteration_limit = 1000; solver_settings.first_primal_feasible = true; @@ -1522,11 +1552,11 @@ TEST(pdlp_class, all_primal_feasible_and_per_constraint_residual_batch_different const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/ns1687037/ns1687037.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path); auto solver_settings = pdlp_solver_settings_t{}; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; solver_settings.pdlp_solver_mode = pdlp_solver_mode_t::Stable3; solver_settings.iteration_limit = 1000; solver_settings.all_primal_feasible = true; @@ -1589,11 +1619,11 @@ TEST(pdlp_class, all_primal_feasible_and_per_constraint_residual_batch_many_diff const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/ns1687037/ns1687037.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path); auto solver_settings = pdlp_solver_settings_t{}; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; solver_settings.pdlp_solver_mode = pdlp_solver_mode_t::Stable3; solver_settings.iteration_limit = 1000; solver_settings.all_primal_feasible = true; @@ -1620,7 +1650,7 @@ TEST(pdlp_class, all_primal_feasible_and_per_constraint_residual_batch_many_diff std::vector ref_statuses(batch_size); std::vector> ref_primal_solutions(batch_size); std::vector ref_iteration_counts(batch_size); - std::vector> ref_problems; + std::vector> ref_problems; ref_problems.reserve(batch_size); auto ref_solver_settings = solver_settings; @@ -1700,11 +1730,11 @@ TEST(pdlp_class, all_primal_feasible_and_per_constraint_residual_batch_many_diff const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/ns1687037/ns1687037.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path); auto solver_settings = pdlp_solver_settings_t{}; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; solver_settings.pdlp_solver_mode = pdlp_solver_mode_t::Stable3; solver_settings.iteration_limit = 1000; solver_settings.all_primal_feasible = true; @@ -1731,7 +1761,7 @@ TEST(pdlp_class, all_primal_feasible_and_per_constraint_residual_batch_many_diff std::vector ref_statuses(batch_size); std::vector> ref_primal_solutions(batch_size); std::vector ref_iteration_counts(batch_size); - std::vector> ref_problems; + std::vector> ref_problems; ref_problems.reserve(batch_size); auto ref_solver_settings = solver_settings; @@ -1810,11 +1840,11 @@ TEST(pdlp_class, batch_primal_feasible_non_batch_rejected) { const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/ns1687037/ns1687037.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path); auto solver_settings = pdlp_solver_settings_t{}; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; solver_settings.pdlp_solver_mode = pdlp_solver_mode_t::Stable3; solver_settings.presolver = presolver_t::None; solver_settings.all_primal_feasible = true; @@ -1827,11 +1857,11 @@ TEST(pdlp_class, first_primal_feasible_and_batch_primal_feasible_rejected) { const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/ns1687037/ns1687037.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path); auto solver_settings = pdlp_solver_settings_t{}; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; solver_settings.pdlp_solver_mode = pdlp_solver_mode_t::Stable3; solver_settings.presolver = presolver_t::None; solver_settings.first_primal_feasible = true; @@ -1858,17 +1888,18 @@ TEST(pdlp_class, warm_start) auto path = make_path_absolute("linear_programming/" + instance_name + "/" + instance_name + ".mps"); - auto solver_settings = pdlp_solver_settings_t{}; - solver_settings.pdlp_solver_mode = cuopt::linear_programming::pdlp_solver_mode_t::Stable2; + auto solver_settings = pdlp_solver_settings_t{}; + solver_settings.pdlp_solver_mode = + cuopt::mathematical_optimization::pdlp_solver_mode_t::Stable2; solver_settings.set_optimality_tolerance(1e-2); solver_settings.detect_infeasibility = false; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; solver_settings.presolver = presolver_t::None; - cuopt::linear_programming::io::mps_data_model_t mps_data_model = - cuopt::linear_programming::io::read_mps(path); + cuopt::mathematical_optimization::io::mps_data_model_t mps_data_model = + cuopt::mathematical_optimization::io::read_mps(path); auto op_problem1 = - cuopt::linear_programming::mps_data_model_to_optimization_problem( + cuopt::mathematical_optimization::mps_data_model_to_optimization_problem( &handle, mps_data_model); // Solving from scratch until 1e-2 @@ -1877,14 +1908,14 @@ TEST(pdlp_class, warm_start) // Solving until 1e-1 to use the result as a warm start solver_settings.set_optimality_tolerance(1e-1); auto op_problem2 = - cuopt::linear_programming::mps_data_model_to_optimization_problem( + cuopt::mathematical_optimization::mps_data_model_to_optimization_problem( &handle, mps_data_model); optimization_problem_solution_t solution2 = solve_lp(op_problem2, solver_settings); // Solving until 1e-2 using the previous state as a warm start solver_settings.set_optimality_tolerance(1e-2); auto op_problem3 = - cuopt::linear_programming::mps_data_model_to_optimization_problem( + cuopt::mathematical_optimization::mps_data_model_to_optimization_problem( &handle, mps_data_model); solver_settings.set_pdlp_warm_start_data(solution2.get_pdlp_warm_start_data()); optimization_problem_solution_t solution3 = solve_lp(op_problem3, solver_settings); @@ -1901,16 +1932,17 @@ TEST(pdlp_class, warm_start_stable3_not_supported) auto path = make_path_absolute("linear_programming/afiro_original.mps"); auto solver_settings = pdlp_solver_settings_t{}; - solver_settings.pdlp_solver_mode = cuopt::linear_programming::pdlp_solver_mode_t::Stable3; + solver_settings.pdlp_solver_mode = cuopt::mathematical_optimization::pdlp_solver_mode_t::Stable3; solver_settings.set_optimality_tolerance(1e-2); solver_settings.detect_infeasibility = false; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; solver_settings.presolver = presolver_t::None; - cuopt::linear_programming::io::mps_data_model_t mps_data_model = - cuopt::linear_programming::io::read_mps(path); - auto op_problem = cuopt::linear_programming::mps_data_model_to_optimization_problem( - &handle, mps_data_model); + cuopt::mathematical_optimization::io::mps_data_model_t mps_data_model = + cuopt::mathematical_optimization::io::read_mps(path); + auto op_problem = + cuopt::mathematical_optimization::mps_data_model_to_optimization_problem( + &handle, mps_data_model); optimization_problem_solution_t solution = solve_lp(op_problem, solver_settings); EXPECT_EQ(solution.get_termination_status(), pdlp_termination_status_t::Optimal); solver_settings.set_pdlp_warm_start_data(solution.get_pdlp_warm_start_data()); @@ -1923,11 +1955,11 @@ TEST(pdlp_class, dual_postsolve_size) const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/afiro_original.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path, true); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path, true); auto solver_settings = pdlp_solver_settings_t{}; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; solver_settings.presolver = presolver_t::Papilo; { @@ -1949,16 +1981,16 @@ TEST(pdlp_class, dual_postsolve_size) TEST(dual_simplex, afiro) { - cuopt::linear_programming::pdlp_solver_settings_t settings = - cuopt::linear_programming::pdlp_solver_settings_t{}; - settings.method = cuopt::linear_programming::method_t::DualSimplex; + cuopt::mathematical_optimization::pdlp_solver_settings_t settings = + cuopt::mathematical_optimization::pdlp_solver_settings_t{}; + settings.method = cuopt::mathematical_optimization::method_t::DualSimplex; settings.presolver = presolver_t::None; const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/afiro_original.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path, true); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path, true); optimization_problem_solution_t solution = solve_lp(&handle_, op_problem, settings); EXPECT_EQ(solution.get_termination_status(), pdlp_termination_status_t::Optimal); @@ -1972,11 +2004,11 @@ TEST(pdlp_class, run_empty_matrix_pdlp) const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/empty_matrix.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path); auto solver_settings = pdlp_solver_settings_t{}; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; solver_settings.presolver = presolver_t::None; optimization_problem_solution_t solution = @@ -1990,11 +2022,11 @@ TEST(pdlp_class, run_empty_matrix_dual_simplex) const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/empty_matrix.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path); auto solver_settings = pdlp_solver_settings_t{}; - solver_settings.method = cuopt::linear_programming::method_t::Concurrent; + solver_settings.method = cuopt::mathematical_optimization::method_t::Concurrent; solver_settings.presolver = presolver_t::None; optimization_problem_solution_t solution = @@ -2008,12 +2040,12 @@ TEST(pdlp_class, test_max) const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/good-max.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path); auto solver_settings = pdlp_solver_settings_t{}; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; - solver_settings.pdlp_solver_mode = cuopt::linear_programming::pdlp_solver_mode_t::Stable2; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; + solver_settings.pdlp_solver_mode = cuopt::mathematical_optimization::pdlp_solver_mode_t::Stable2; solver_settings.presolver = presolver_t::None; optimization_problem_solution_t solution = @@ -2028,11 +2060,11 @@ TEST(pdlp_class, test_max_with_offset) const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/max_offset.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path); auto solver_settings = pdlp_solver_settings_t{}; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; solver_settings.presolver = presolver_t::None; optimization_problem_solution_t solution = @@ -2047,8 +2079,8 @@ TEST(pdlp_class, test_lp_no_constraints) const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/lp-model-no-constraints.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path); auto solver_settings = pdlp_solver_settings_t{}; solver_settings.presolver = presolver_t::None; @@ -2074,11 +2106,11 @@ TEST(pdlp_class, simple_batch_afiro) { const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/afiro_original.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path, true); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path, true); auto solver_settings = pdlp_solver_settings_t{}; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; solver_settings.presolver = presolver_t::None; constexpr int batch_size = 5; @@ -2156,11 +2188,11 @@ TEST(pdlp_class, simple_batch_different_bounds) const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/afiro_original.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path, true); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path, true); auto solver_settings = pdlp_solver_settings_t{}; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; solver_settings.presolver = presolver_t::None; const std::vector& variable_lower_bounds = op_problem.get_variable_lower_bounds(); @@ -2212,11 +2244,11 @@ TEST(pdlp_class, more_complex_batch_different_bounds) const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/afiro_original.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path, true); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path, true); auto solver_settings = pdlp_solver_settings_t{}; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; solver_settings.presolver = presolver_t::None; constexpr int batch_size = 5; @@ -2305,11 +2337,11 @@ TEST(pdlp_class, simple_batch_different_objectives) const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/afiro_original.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path, true); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path, true); auto solver_settings = pdlp_solver_settings_t{}; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; solver_settings.presolver = presolver_t::None; const int n_vars = op_problem.get_n_variables(); @@ -2373,11 +2405,11 @@ TEST(pdlp_class, simple_batch_different_offsets) const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/afiro_original.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path, true); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path, true); auto solver_settings = pdlp_solver_settings_t{}; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; solver_settings.presolver = presolver_t::None; // Solve sequentially with different offsets @@ -2413,11 +2445,11 @@ TEST(pdlp_class, simple_batch_different_objectives_and_offsets) const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/afiro_original.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path, true); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path, true); auto solver_settings = pdlp_solver_settings_t{}; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; solver_settings.presolver = presolver_t::None; const int n_vars = op_problem.get_n_variables(); @@ -2471,11 +2503,11 @@ TEST(pdlp_class, simple_batch_different_constraint_bounds) const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/afiro_original.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path, true); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path, true); auto solver_settings = pdlp_solver_settings_t{}; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; solver_settings.presolver = presolver_t::None; const int n_constrs = op_problem.get_n_constraints(); @@ -2539,11 +2571,11 @@ TEST(pdlp_class, simple_batch_everything_different) const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/afiro_original.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path, true); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path, true); auto solver_settings = pdlp_solver_settings_t{}; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; solver_settings.presolver = presolver_t::None; const int n_vars = op_problem.get_n_variables(); @@ -2600,7 +2632,7 @@ TEST(pdlp_class, simple_batch_everything_different) // Sequential reference: solve each climber independently and capture its objective. std::vector ref_objectives(batch_size); - std::vector> ref_problems; + std::vector> ref_problems; ref_problems.reserve(batch_size); for (size_t c = 0; c < batch_size; ++c) { auto ref_op = op_problem; @@ -2659,8 +2691,8 @@ TEST(pdlp_class, run_batch_pdlp_fixed_rejects_partial_per_climber_expansion) { const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/afiro_original.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path, true); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path, true); constexpr int batch_size = 3; const auto n_vars = static_cast(op_problem.get_n_variables()); @@ -2669,7 +2701,7 @@ TEST(pdlp_class, run_batch_pdlp_fixed_rejects_partial_per_climber_expansion) auto make_settings = []() { pdlp_solver_settings_t s{}; - s.method = cuopt::linear_programming::method_t::PDLP; + s.method = cuopt::mathematical_optimization::method_t::PDLP; s.presolver = presolver_t::None; s.fixed_batch_size = batch_size; s.generate_batch_primal_dual_solution = true; @@ -2687,53 +2719,63 @@ TEST(pdlp_class, run_batch_pdlp_fixed_rejects_partial_per_climber_expansion) // Case 1: objective_coefficients has an in-between size (batch_size * n_vars - 1). { - auto gpu_op = cuopt::linear_programming::mps_data_model_to_optimization_problem( - &handle_, op_problem); + auto gpu_op = + cuopt::mathematical_optimization::mps_data_model_to_optimization_problem( + &handle_, op_problem); std::vector bad_obj(batch_size * n_vars - 1, 0.0); assign_device_uvector_from_host(gpu_op.get_objective_coefficients(), bad_obj, stream); auto settings = make_settings(); - expect_validation_error([&]() { cuopt::linear_programming::run_batch_pdlp(gpu_op, settings); }); + expect_validation_error( + [&]() { cuopt::mathematical_optimization::run_batch_pdlp(gpu_op, settings); }); } // Case 2: constraint_lower_bounds has an in-between size (batch_size * n_cons - 1). { - auto gpu_op = cuopt::linear_programming::mps_data_model_to_optimization_problem( - &handle_, op_problem); + auto gpu_op = + cuopt::mathematical_optimization::mps_data_model_to_optimization_problem( + &handle_, op_problem); std::vector bad_clb(batch_size * n_cons - 1, 0.0); assign_device_uvector_from_host(gpu_op.get_constraint_lower_bounds(), bad_clb, stream); auto settings = make_settings(); - expect_validation_error([&]() { cuopt::linear_programming::run_batch_pdlp(gpu_op, settings); }); + expect_validation_error( + [&]() { cuopt::mathematical_optimization::run_batch_pdlp(gpu_op, settings); }); } // Case 3: constraint_upper_bounds has an in-between size (batch_size * n_cons - 1). { - auto gpu_op = cuopt::linear_programming::mps_data_model_to_optimization_problem( - &handle_, op_problem); + auto gpu_op = + cuopt::mathematical_optimization::mps_data_model_to_optimization_problem( + &handle_, op_problem); std::vector bad_cub(batch_size * n_cons - 1, 0.0); assign_device_uvector_from_host(gpu_op.get_constraint_upper_bounds(), bad_cub, stream); auto settings = make_settings(); - expect_validation_error([&]() { cuopt::linear_programming::run_batch_pdlp(gpu_op, settings); }); + expect_validation_error( + [&]() { cuopt::mathematical_optimization::run_batch_pdlp(gpu_op, settings); }); } // Case 4: lower bounds expanded per-climber but upper bounds left shared (or vice versa). // pdhg.cu's swap path keys off the lower-bound size and assumes the upper follows. { - auto gpu_op = cuopt::linear_programming::mps_data_model_to_optimization_problem( - &handle_, op_problem); + auto gpu_op = + cuopt::mathematical_optimization::mps_data_model_to_optimization_problem( + &handle_, op_problem); std::vector per_climber_clb(batch_size * n_cons, 0.0); assign_device_uvector_from_host(gpu_op.get_constraint_lower_bounds(), per_climber_clb, stream); auto settings = make_settings(); - expect_validation_error([&]() { cuopt::linear_programming::run_batch_pdlp(gpu_op, settings); }); + expect_validation_error( + [&]() { cuopt::mathematical_optimization::run_batch_pdlp(gpu_op, settings); }); } // Case 5: batch_objective_offsets has an unexpected size (not 0 and not fixed_batch_size). { - auto gpu_op = cuopt::linear_programming::mps_data_model_to_optimization_problem( - &handle_, op_problem); + auto gpu_op = + cuopt::mathematical_optimization::mps_data_model_to_optimization_problem( + &handle_, op_problem); std::vector bad_offsets(batch_size + 1, 0.0); gpu_op.set_batch_objective_offsets(bad_offsets); auto settings = make_settings(); - expect_validation_error([&]() { cuopt::linear_programming::run_batch_pdlp(gpu_op, settings); }); + expect_validation_error( + [&]() { cuopt::mathematical_optimization::run_batch_pdlp(gpu_op, settings); }); } } @@ -2741,14 +2783,15 @@ TEST(pdlp_class, run_batch_pdlp_rejects_invalid_new_bounds) { const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/afiro_original.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path, true); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path, true); auto expect_validation_error = [&](pdlp_solver_settings_t settings) { - auto gpu_op = cuopt::linear_programming::mps_data_model_to_optimization_problem( - &handle_, op_problem); + auto gpu_op = + cuopt::mathematical_optimization::mps_data_model_to_optimization_problem( + &handle_, op_problem); try { - cuopt::linear_programming::run_batch_pdlp(gpu_op, settings); + cuopt::mathematical_optimization::run_batch_pdlp(gpu_op, settings); FAIL() << "expected cuopt::logic_error with ValidationError"; } catch (const cuopt::logic_error& e) { EXPECT_EQ(e.get_error_type(), cuopt::error_type_t::ValidationError); @@ -2757,7 +2800,7 @@ TEST(pdlp_class, run_batch_pdlp_rejects_invalid_new_bounds) auto make_settings = []() { pdlp_solver_settings_t settings{}; - settings.method = cuopt::linear_programming::method_t::PDLP; + settings.method = cuopt::mathematical_optimization::method_t::PDLP; settings.presolver = presolver_t::None; settings.generate_batch_primal_dual_solution = true; return settings; @@ -2849,16 +2892,17 @@ TEST(pdlp_class, run_batch_pdlp_rejects_save_best_primal_so_far) { const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/afiro_original.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path, true); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path, true); // Splitting path: trigger batch mode via a non-empty new_bounds list (size > 1). { - auto gpu_op = cuopt::linear_programming::mps_data_model_to_optimization_problem( - &handle_, op_problem); + auto gpu_op = + cuopt::mathematical_optimization::mps_data_model_to_optimization_problem( + &handle_, op_problem); pdlp_solver_settings_t settings{}; - settings.method = cuopt::linear_programming::method_t::PDLP; + settings.method = cuopt::mathematical_optimization::method_t::PDLP; settings.presolver = presolver_t::None; settings.generate_batch_primal_dual_solution = true; settings.save_best_primal_so_far = true; @@ -2872,23 +2916,24 @@ TEST(pdlp_class, run_batch_pdlp_rejects_save_best_primal_so_far) op_problem.get_variable_lower_bounds()[var_id] + 2.0, op_problem.get_variable_upper_bounds()[var_id]}); - auto sol = cuopt::linear_programming::run_batch_pdlp(gpu_op, settings); + auto sol = cuopt::mathematical_optimization::run_batch_pdlp(gpu_op, settings); EXPECT_EQ(sol.get_error_status().get_error_type(), cuopt::error_type_t::ValidationError); } // Fixed-batch path: trigger batch mode via fixed_batch_size with shared (size == n) buffers. { - auto gpu_op = cuopt::linear_programming::mps_data_model_to_optimization_problem( - &handle_, op_problem); + auto gpu_op = + cuopt::mathematical_optimization::mps_data_model_to_optimization_problem( + &handle_, op_problem); pdlp_solver_settings_t settings{}; - settings.method = cuopt::linear_programming::method_t::PDLP; + settings.method = cuopt::mathematical_optimization::method_t::PDLP; settings.presolver = presolver_t::None; settings.fixed_batch_size = 2; settings.generate_batch_primal_dual_solution = true; settings.save_best_primal_so_far = true; - auto sol = cuopt::linear_programming::run_batch_pdlp(gpu_op, settings); + auto sol = cuopt::mathematical_optimization::run_batch_pdlp(gpu_op, settings); EXPECT_EQ(sol.get_error_status().get_error_type(), cuopt::error_type_t::ValidationError); } } @@ -2898,12 +2943,12 @@ TEST(pdlp_class, DISABLED_cupdlpx_infeasible_detection_afiro_new_bounds) const raft::handle_t handle_{}; auto solver_settings = pdlp_solver_settings_t{}; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; solver_settings.detect_infeasibility = true; auto path = make_path_absolute("linear_programming/afiro_original.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path, true); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path, true); for (size_t i = 1; i < 8; ++i) { op_problem.get_variable_lower_bounds()[i] = 7.0; @@ -2925,14 +2970,14 @@ TEST(pdlp_class, DISABLED_cupdlpx_batch_infeasible_detection) const raft::handle_t handle_{}; auto solver_settings = pdlp_solver_settings_t{}; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; solver_settings.detect_infeasibility = true; constexpr int batch_size = 5; auto path = make_path_absolute("linear_programming/good-mps-fixed-ranges.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path, true); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path, true); const std::vector& variable_lower_bounds = op_problem.get_variable_lower_bounds(); const std::vector& variable_upper_bounds = op_problem.get_variable_upper_bounds(); @@ -2967,12 +3012,12 @@ TEST(pdlp_class, DISABLED_cupdlpx_infeasible_detection_batch_afiro_new_bounds) const raft::handle_t handle_{}; auto solver_settings = pdlp_solver_settings_t{}; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; solver_settings.detect_infeasibility = true; auto path = make_path_absolute("linear_programming/afiro_original.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path, true); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path, true); // Use a ref problem that is infeasible auto op_problem_ref = op_problem; @@ -3015,11 +3060,11 @@ TEST(pdlp_class, new_bounds) const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/afiro_original.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path, true); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path, true); auto solver_settings = pdlp_solver_settings_t{}; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; solver_settings.presolver = presolver_t::None; // Manually changing the bounds and doing it through the solver settings should give the same @@ -3060,11 +3105,11 @@ TEST(pdlp_class, big_batch_afiro) const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/afiro_original.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path, true); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path, true); auto solver_settings = pdlp_solver_settings_t{}; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; solver_settings.presolver = presolver_t::None; constexpr int batch_size = 1000; @@ -3148,11 +3193,11 @@ TEST(pdlp_class, DISABLED_simple_batch_optimal_and_infeasible) const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/afiro_original.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path, true); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path, true); auto solver_settings = pdlp_solver_settings_t{}; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; solver_settings.detect_infeasibility = true; solver_settings.presolver = presolver_t::None; @@ -3180,11 +3225,11 @@ TEST(pdlp_class, DISABLED_larger_batch_optimal_and_infeasible) const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/afiro_original.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path, true); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path, true); auto solver_settings = pdlp_solver_settings_t{}; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; solver_settings.detect_infeasibility = true; const std::vector& variable_lower_bounds = op_problem.get_variable_lower_bounds(); @@ -3226,16 +3271,16 @@ TEST(pdlp_class, strong_branching_test) const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/afiro_original.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path, true); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path, true); const std::vector fractional = {1, 2, 4}; const std::vector root_soln_x = {0.891, 0.109, 0.636429}; auto solver_settings = pdlp_solver_settings_t{}; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; solver_settings.pdlp_solver_mode = pdlp_solver_mode_t::Stable3; - solver_settings.presolver = cuopt::linear_programming::presolver_t::None; + solver_settings.presolver = cuopt::mathematical_optimization::presolver_t::None; solver_settings.generate_batch_primal_dual_solution = true; const int n_fractional = fractional.size(); @@ -3243,7 +3288,7 @@ TEST(pdlp_class, strong_branching_test) std::vector ref_objectives(batch_size); std::vector ref_statuses(batch_size); - std::vector> ref_problems; + std::vector> ref_problems; // Logic from batch_pdlp_solve in solve.cu: // Down branches first, then Up branches @@ -3333,16 +3378,16 @@ TEST(pdlp_class, strong_branching_user_api) const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/afiro_original.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path, true); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path, true); const std::vector fractional = {1, 2, 4}; const std::vector root_soln_x = {0.891, 0.109, 0.636429}; auto solver_settings = pdlp_solver_settings_t{}; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; solver_settings.pdlp_solver_mode = pdlp_solver_mode_t::Stable3; - solver_settings.presolver = cuopt::linear_programming::presolver_t::None; + solver_settings.presolver = cuopt::mathematical_optimization::presolver_t::None; solver_settings.generate_batch_primal_dual_solution = true; const int n_fractional = fractional.size(); @@ -3350,7 +3395,7 @@ TEST(pdlp_class, strong_branching_user_api) std::vector ref_objectives(batch_size); std::vector ref_statuses(batch_size); - std::vector> ref_problems; + std::vector> ref_problems; // Down branches first, then Up branches. @@ -3391,9 +3436,10 @@ TEST(pdlp_class, strong_branching_user_api) } // Solve batch via the run_batch_pdlp strong-branching path (auto batch sizing). - auto gpu_op = cuopt::linear_programming::mps_data_model_to_optimization_problem( - &handle_, op_problem); - auto batch_sol = cuopt::linear_programming::run_batch_pdlp(gpu_op, solver_settings); + auto gpu_op = + cuopt::mathematical_optimization::mps_data_model_to_optimization_problem( + &handle_, op_problem); + auto batch_sol = cuopt::mathematical_optimization::run_batch_pdlp(gpu_op, solver_settings); EXPECT_EQ((int)batch_sol.get_terminations_status().size(), batch_size); const size_t primal_size = op_problem.get_n_variables(); @@ -3421,13 +3467,13 @@ TEST(pdlp_class, strong_branching_multi_bounds_per_climber) const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/afiro_original.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path, true); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path, true); auto solver_settings = pdlp_solver_settings_t{}; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; solver_settings.pdlp_solver_mode = pdlp_solver_mode_t::Stable3; - solver_settings.presolver = cuopt::linear_programming::presolver_t::None; + solver_settings.presolver = cuopt::mathematical_optimization::presolver_t::None; solver_settings.generate_batch_primal_dual_solution = true; auto root_solution = solve_lp(&handle_, op_problem, solver_settings); @@ -3454,7 +3500,7 @@ TEST(pdlp_class, strong_branching_multi_bounds_per_climber) std::vector> bound_specs; std::vector ref_objectives(batch_size); std::vector ref_statuses(batch_size); - std::vector> ref_problems; + std::vector> ref_problems; ref_problems.reserve(batch_size); for (int c = 0; c < batch_size; ++c) { @@ -3500,14 +3546,14 @@ TEST(pdlp_class, run_batch_pdlp_many_different_bounds) const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/afiro_original.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path, true); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path, true); const auto& variable_lower_bounds = op_problem.get_variable_lower_bounds(); const auto& variable_upper_bounds = op_problem.get_variable_upper_bounds(); auto regular_pdlp_settings = pdlp_solver_settings_t{}; - regular_pdlp_settings.method = cuopt::linear_programming::method_t::PDLP; + regular_pdlp_settings.method = cuopt::mathematical_optimization::method_t::PDLP; regular_pdlp_settings.pdlp_solver_mode = pdlp_solver_mode_t::Stable3; regular_pdlp_settings.presolver = presolver_t::None; regular_pdlp_settings.set_optimality_tolerance(result_tolerance); @@ -3553,7 +3599,7 @@ TEST(pdlp_class, run_batch_pdlp_many_different_bounds) std::vector ref_objectives(batch_size); std::vector ref_statuses(batch_size); - std::vector> ref_problems; + std::vector> ref_problems; std::vector> bound_specs; for (int i = 0; i < batch_size; ++i) { @@ -3614,8 +3660,8 @@ TEST(pdlp_class, run_batch_pdlp_many_different_bounds_good_mps_some_var_bounds) const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/good-mps-some-var-bounds.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path, true); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path, true); const auto& variable_lower_bounds = op_problem.get_variable_lower_bounds(); const auto& variable_upper_bounds = op_problem.get_variable_upper_bounds(); @@ -3641,13 +3687,13 @@ TEST(pdlp_class, run_batch_pdlp_many_different_bounds_good_mps_some_var_bounds) const int batch_size = custom_bounds_by_climber.size(); auto regular_pdlp_settings = pdlp_solver_settings_t{}; - regular_pdlp_settings.method = cuopt::linear_programming::method_t::PDLP; + regular_pdlp_settings.method = cuopt::mathematical_optimization::method_t::PDLP; regular_pdlp_settings.presolver = presolver_t::None; regular_pdlp_settings.set_optimality_tolerance(exact_tolerance); std::vector ref_objectives(batch_size); std::vector ref_statuses(batch_size); - std::vector> ref_problems; + std::vector> ref_problems; std::vector> ref_primal_solutions(batch_size); for (int i = 0; i < batch_size; ++i) { @@ -3712,8 +3758,8 @@ TEST(pdlp_class, run_batch_fixed_api_many_different_bounds_good_mps_some_var_bou const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/good-mps-some-var-bounds.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path, true); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path, true); const auto& variable_lower_bounds = op_problem.get_variable_lower_bounds(); const auto& variable_upper_bounds = op_problem.get_variable_upper_bounds(); @@ -3731,13 +3777,13 @@ TEST(pdlp_class, run_batch_fixed_api_many_different_bounds_good_mps_some_var_bou const int batch_size = custom_bounds_by_climber.size(); auto regular_pdlp_settings = pdlp_solver_settings_t{}; - regular_pdlp_settings.method = cuopt::linear_programming::method_t::PDLP; + regular_pdlp_settings.method = cuopt::mathematical_optimization::method_t::PDLP; regular_pdlp_settings.presolver = presolver_t::None; regular_pdlp_settings.set_optimality_tolerance(exact_tolerance); std::vector ref_objectives(batch_size); std::vector ref_statuses(batch_size); - std::vector> ref_problems; + std::vector> ref_problems; std::vector> ref_primal_solutions(batch_size); for (int i = 0; i < batch_size; ++i) { @@ -3766,9 +3812,10 @@ TEST(pdlp_class, run_batch_fixed_api_many_different_bounds_good_mps_some_var_bou } } - auto gpu_op = cuopt::linear_programming::mps_data_model_to_optimization_problem( - &handle_, op_problem); - auto batch_solution = cuopt::linear_programming::run_batch_pdlp(gpu_op, batch_settings); + auto gpu_op = + cuopt::mathematical_optimization::mps_data_model_to_optimization_problem( + &handle_, op_problem); + auto batch_solution = cuopt::mathematical_optimization::run_batch_pdlp(gpu_op, batch_settings); ASSERT_EQ((int)batch_solution.get_terminations_status().size(), batch_size); const size_t primal_size = op_problem.get_n_variables(); @@ -3804,8 +3851,8 @@ TEST(pdlp_class, many_different_bounds) const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/good-mps-some-var-bounds.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path, true); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path, true); const auto& variable_lower_bounds = op_problem.get_variable_lower_bounds(); const auto& variable_upper_bounds = op_problem.get_variable_upper_bounds(); @@ -3828,14 +3875,14 @@ TEST(pdlp_class, many_different_bounds) const int batch_size = custom_bounds.size(); std::vector ref_objectives(batch_size); std::vector ref_statuses(batch_size); - std::vector> ref_problems; + std::vector> ref_problems; std::vector> ref_primal_solutions(batch_size); // Solve each variant using PDLP for (int i = 0; i < batch_size; ++i) { const auto& bounds = custom_bounds[i]; auto solver_settings = pdlp_solver_settings_t{}; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; solver_settings.presolver = presolver_t::None; auto ref_prob = op_problem; ref_prob.get_variable_lower_bounds()[std::get<0>(bounds)] = std::get<1>(bounds); @@ -3849,7 +3896,7 @@ TEST(pdlp_class, many_different_bounds) } auto solver_settings = pdlp_solver_settings_t{}; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; solver_settings.presolver = presolver_t::None; for (int i = 0; i < batch_size; ++i) { solver_settings.new_bounds.push_back({i, @@ -3897,8 +3944,8 @@ TEST(pdlp_class, some_climber_hit_iteration_limit) const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/good-mps-some-var-bounds.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path, true); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path, true); const auto& variable_lower_bounds = op_problem.get_variable_lower_bounds(); const auto& variable_upper_bounds = op_problem.get_variable_upper_bounds(); @@ -3910,14 +3957,14 @@ TEST(pdlp_class, some_climber_hit_iteration_limit) const int batch_size = custom_bounds.size(); std::vector ref_objectives(batch_size); std::vector ref_statuses(batch_size); - std::vector> ref_problems; + std::vector> ref_problems; std::vector> ref_primal_solutions(batch_size); // Solve each variant using PDLP for (int i = 0; i < batch_size; ++i) { const auto& bounds = custom_bounds[i]; auto solver_settings = pdlp_solver_settings_t{}; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; solver_settings.iteration_limit = 500; solver_settings.presolver = presolver_t::None; auto ref_prob = op_problem; @@ -3932,7 +3979,7 @@ TEST(pdlp_class, some_climber_hit_iteration_limit) } auto solver_settings = pdlp_solver_settings_t{}; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; solver_settings.presolver = presolver_t::None; solver_settings.iteration_limit = 500; for (int i = 0; i < batch_size; ++i) { @@ -3979,12 +4026,13 @@ TEST(pdlp_class, precision_single) const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/afiro_original.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path, true); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path, true); - auto solver_settings = pdlp_solver_settings_t{}; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; - solver_settings.pdlp_precision = cuopt::linear_programming::pdlp_precision_t::SinglePrecision; + auto solver_settings = pdlp_solver_settings_t{}; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; + solver_settings.pdlp_precision = + cuopt::mathematical_optimization::pdlp_precision_t::SinglePrecision; optimization_problem_solution_t solution = solve_lp(&handle_, op_problem, solver_settings); @@ -3999,13 +4047,14 @@ TEST(pdlp_class, precision_single_crossover) const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/afiro_original.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path, true); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path, true); - auto solver_settings = pdlp_solver_settings_t{}; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; - solver_settings.pdlp_precision = cuopt::linear_programming::pdlp_precision_t::SinglePrecision; - solver_settings.crossover = true; + auto solver_settings = pdlp_solver_settings_t{}; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; + solver_settings.pdlp_precision = + cuopt::mathematical_optimization::pdlp_precision_t::SinglePrecision; + solver_settings.crossover = true; optimization_problem_solution_t solution = solve_lp(&handle_, op_problem, solver_settings); @@ -4020,12 +4069,13 @@ TEST(pdlp_class, precision_single_concurrent) const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/afiro_original.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path, true); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path, true); - auto solver_settings = pdlp_solver_settings_t{}; - solver_settings.method = cuopt::linear_programming::method_t::Concurrent; - solver_settings.pdlp_precision = cuopt::linear_programming::pdlp_precision_t::SinglePrecision; + auto solver_settings = pdlp_solver_settings_t{}; + solver_settings.method = cuopt::mathematical_optimization::method_t::Concurrent; + solver_settings.pdlp_precision = + cuopt::mathematical_optimization::pdlp_precision_t::SinglePrecision; optimization_problem_solution_t solution = solve_lp(&handle_, op_problem, solver_settings); @@ -4040,13 +4090,14 @@ TEST(pdlp_class, precision_single_papilo_presolve) const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/afiro_original.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path, true); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path, true); - auto solver_settings = pdlp_solver_settings_t{}; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; - solver_settings.pdlp_precision = cuopt::linear_programming::pdlp_precision_t::SinglePrecision; - solver_settings.presolver = cuopt::linear_programming::presolver_t::Papilo; + auto solver_settings = pdlp_solver_settings_t{}; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; + solver_settings.pdlp_precision = + cuopt::mathematical_optimization::pdlp_precision_t::SinglePrecision; + solver_settings.presolver = cuopt::mathematical_optimization::presolver_t::Papilo; optimization_problem_solution_t solution = solve_lp(&handle_, op_problem, solver_settings); @@ -4060,13 +4111,14 @@ TEST(pdlp_class, precision_single_pslp_presolve) const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/afiro_original.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path, true); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path, true); - auto solver_settings = pdlp_solver_settings_t{}; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; - solver_settings.pdlp_precision = cuopt::linear_programming::pdlp_precision_t::SinglePrecision; - solver_settings.presolver = cuopt::linear_programming::presolver_t::PSLP; + auto solver_settings = pdlp_solver_settings_t{}; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; + solver_settings.pdlp_precision = + cuopt::mathematical_optimization::pdlp_precision_t::SinglePrecision; + solver_settings.presolver = cuopt::mathematical_optimization::presolver_t::PSLP; optimization_problem_solution_t solution = solve_lp(&handle_, op_problem, solver_settings); @@ -4081,7 +4133,7 @@ TEST(pdlp_class, precision_single_pslp_presolve) TEST(pdlp_class, shared_sb_context_unit) { - using namespace cuopt::linear_programming::dual_simplex; + using namespace cuopt::mathematical_optimization::mip; constexpr int N = 10; shared_strong_branching_context_t ctx(N); @@ -4128,12 +4180,12 @@ TEST(pdlp_class, shared_sb_context_unit) TEST(pdlp_class, shared_sb_view_batch_pre_solved) { - using namespace cuopt::linear_programming::dual_simplex; + using namespace cuopt::mathematical_optimization::mip; const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/afiro_original.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path, true); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path, true); const std::vector fractional = {1, 2, 4}; const std::vector root_soln_x = {0.891, 0.109, 0.636429}; @@ -4141,9 +4193,9 @@ TEST(pdlp_class, shared_sb_view_batch_pre_solved) const int batch_size = n_fractional * 2; // 6 auto solver_settings = pdlp_solver_settings_t{}; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; solver_settings.pdlp_solver_mode = pdlp_solver_mode_t::Stable3; - solver_settings.presolver = cuopt::linear_programming::presolver_t::None; + solver_settings.presolver = cuopt::mathematical_optimization::presolver_t::None; // Build new_bounds: down branches [0..2], up branches [3..5] for (int i = 0; i < n_fractional; ++i) @@ -4188,12 +4240,12 @@ TEST(pdlp_class, shared_sb_view_batch_pre_solved) TEST(pdlp_class, shared_sb_view_concurrent_mark) { - using namespace cuopt::linear_programming::dual_simplex; + using namespace cuopt::mathematical_optimization::mip; const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/afiro_original.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path, true); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path, true); const std::vector fractional = {1, 2, 4}; const std::vector root_soln_x = {0.891, 0.109, 0.636429}; @@ -4201,9 +4253,9 @@ TEST(pdlp_class, shared_sb_view_concurrent_mark) const int batch_size = n_fractional * 2; auto solver_settings = pdlp_solver_settings_t{}; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; solver_settings.pdlp_solver_mode = pdlp_solver_mode_t::Stable3; - solver_settings.presolver = cuopt::linear_programming::presolver_t::None; + solver_settings.presolver = cuopt::mathematical_optimization::presolver_t::None; solver_settings.iteration_limit = 1000000; for (int i = 0; i < n_fractional; ++i) @@ -4246,7 +4298,7 @@ TEST(pdlp_class, shared_sb_view_concurrent_mark) EXPECT_TRUE(status == pdlp_termination_status_t::Optimal || status == pdlp_termination_status_t::ConcurrentLimit) << "Entry " << i << " has unexpected status " - << cuopt::linear_programming::optimization_problem_solution_t:: + << cuopt::mathematical_optimization::optimization_problem_solution_t:: get_termination_status_string(status); } @@ -4260,12 +4312,12 @@ TEST(pdlp_class, shared_sb_view_concurrent_mark) TEST(pdlp_class, shared_sb_view_all_infeasible) { - using namespace cuopt::linear_programming::dual_simplex; + using namespace cuopt::mathematical_optimization::mip; const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/afiro_original.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path, true); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path, true); const std::vector fractional = {1, 2, 4}; const std::vector root_soln_x = {0.891, 0.109, 0.636429}; @@ -4273,9 +4325,9 @@ TEST(pdlp_class, shared_sb_view_all_infeasible) const int batch_size = n_fractional; auto solver_settings = pdlp_solver_settings_t{}; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; solver_settings.pdlp_solver_mode = pdlp_solver_mode_t::Stable3; - solver_settings.presolver = cuopt::linear_programming::presolver_t::None; + solver_settings.presolver = cuopt::mathematical_optimization::presolver_t::None; solver_settings.iteration_limit = 1000000; for (int i = 0; i < n_fractional; ++i) @@ -4311,7 +4363,7 @@ TEST(pdlp_class, shared_sb_view_all_infeasible) // Each entry should be either Optimal (PDLP solved it first) or ConcurrentLimit (DS marked it) EXPECT_TRUE(status == pdlp_termination_status_t::ConcurrentLimit) << "Entry " << i << " has unexpected status " - << cuopt::linear_programming::optimization_problem_solution_t:: + << cuopt::mathematical_optimization::optimization_problem_solution_t:: get_termination_status_string(status); } @@ -4331,11 +4383,11 @@ TEST(pdlp_class, big_batch_fixed_path) const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/afiro_original.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path, true); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path, true); auto solver_settings = pdlp_solver_settings_t{}; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; solver_settings.presolver = presolver_t::None; const int n_vars = op_problem.get_n_variables(); @@ -4349,10 +4401,11 @@ TEST(pdlp_class, big_batch_fixed_path) const double original_offset = op_problem.get_objective_offset(); // Query optimal batch size on the unexpanded problem, then expand to that size. - auto gpu_op = cuopt::linear_programming::mps_data_model_to_optimization_problem( - &handle_, op_problem); + auto gpu_op = + cuopt::mathematical_optimization::mps_data_model_to_optimization_problem( + &handle_, op_problem); const size_t batch_size = - cuopt::linear_programming::compute_optimal_batch_size(gpu_op, true, true, true); + cuopt::mathematical_optimization::compute_optimal_batch_size(gpu_op, true, true, true); ASSERT_GT(batch_size, 0u); // Build expanded arrays: replicate identical per-climber fields × batch_size @@ -4384,7 +4437,7 @@ TEST(pdlp_class, big_batch_fixed_path) solver_settings.generate_batch_primal_dual_solution = true; solver_settings.fixed_batch_size = static_cast(batch_size); - auto solution = cuopt::linear_programming::run_batch_pdlp(gpu_op, solver_settings); + auto solution = cuopt::mathematical_optimization::run_batch_pdlp(gpu_op, solver_settings); // All should be optimal for (size_t i = 0; i < batch_size; ++i) { @@ -4449,8 +4502,8 @@ TEST(pdlp_class, batch_bound_objective_rescaling_factors_match_input_expansion) const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/afiro_original.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path, true); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path, true); constexpr int batch_size = 3; const int n_vars = op_problem.get_n_variables(); @@ -4462,20 +4515,21 @@ TEST(pdlp_class, batch_bound_objective_rescaling_factors_match_input_expansion) auto compute_rescaling = [&](std::vector const& objectives, std::vector const& constraint_lower, std::vector const& constraint_upper) { - auto gpu_op = cuopt::linear_programming::mps_data_model_to_optimization_problem( - &handle_, op_problem); + auto gpu_op = + cuopt::mathematical_optimization::mps_data_model_to_optimization_problem( + &handle_, op_problem); auto stream = handle_.get_stream(); assign_device_uvector_from_host(gpu_op.get_objective_coefficients(), objectives, stream); assign_device_uvector_from_host(gpu_op.get_constraint_lower_bounds(), constraint_lower, stream); assign_device_uvector_from_host(gpu_op.get_constraint_upper_bounds(), constraint_upper, stream); - pdlp_hyper_params::pdlp_hyper_params_t hyper_params{}; + pdlp::pdlp_hyper_params_t hyper_params{}; hyper_params.do_ruiz_scaling = false; hyper_params.do_pock_chambolle_scaling = false; hyper_params.bound_objective_rescaling = true; - cuopt::linear_programming::detail::problem_t problem(gpu_op); - cuopt::linear_programming::detail::pdlp_initial_scaling_strategy_t scaling( + cuopt::mathematical_optimization::mip::problem_t problem(gpu_op); + cuopt::mathematical_optimization::pdlp::pdlp_initial_scaling_strategy_t scaling( &handle_, problem, hyper_params.default_l_inf_ruiz_iterations, @@ -4593,11 +4647,11 @@ TEST(pdlp_class, batch_with_optimal_size_query) const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/afiro_original.mps"); - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path, true); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path, true); auto solver_settings = pdlp_solver_settings_t{}; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; solver_settings.presolver = presolver_t::None; const int n_vars = op_problem.get_n_variables(); @@ -4610,10 +4664,11 @@ TEST(pdlp_class, batch_with_optimal_size_query) const auto& variable_ub = op_problem.get_variable_upper_bounds(); // Step 1: query optimal batch size on the unexpanded problem. - auto gpu_op = cuopt::linear_programming::mps_data_model_to_optimization_problem( - &handle_, op_problem); + auto gpu_op = + cuopt::mathematical_optimization::mps_data_model_to_optimization_problem( + &handle_, op_problem); const size_t batch_size = - cuopt::linear_programming::compute_optimal_batch_size(gpu_op, true, true, true); + cuopt::mathematical_optimization::compute_optimal_batch_size(gpu_op, true, true, true); ASSERT_GT(batch_size, 0u); // Step 2: build per-climber expanded arrays sized to batch_size. @@ -4662,7 +4717,7 @@ TEST(pdlp_class, batch_with_optimal_size_query) // Sequential reference: solve one instance of each unique variation independently. const size_t n_variations = variations.size(); std::vector ref_objectives(n_variations); - std::vector> ref_problems; + std::vector> ref_problems; ref_problems.reserve(n_variations); for (size_t v = 0; v < n_variations; ++v) { auto ref_op = op_problem; @@ -4691,7 +4746,7 @@ TEST(pdlp_class, batch_with_optimal_size_query) solver_settings.generate_batch_primal_dual_solution = true; solver_settings.fixed_batch_size = static_cast(batch_size); - auto batch_sol = cuopt::linear_programming::run_batch_pdlp(gpu_op, solver_settings); + auto batch_sol = cuopt::mathematical_optimization::run_batch_pdlp(gpu_op, solver_settings); // Compare each climber to the reference for its variation. for (size_t c = 0; c < batch_size; ++c) { @@ -4709,6 +4764,6 @@ TEST(pdlp_class, batch_with_optimal_size_query) } } -} // namespace cuopt::linear_programming::test +} // namespace cuopt::mathematical_optimization::test CUOPT_TEST_PROGRAM_MAIN() diff --git a/cpp/tests/linear_programming/unit_tests/optimization_problem_test.cu b/cpp/tests/linear_programming/unit_tests/optimization_problem_test.cu index 005e2e7da7..7232bd3bc6 100644 --- a/cpp/tests/linear_programming/unit_tests/optimization_problem_test.cu +++ b/cpp/tests/linear_programming/unit_tests/optimization_problem_test.cu @@ -7,7 +7,7 @@ #include -#include +#include #include #include #include @@ -22,16 +22,16 @@ #include #include -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { -cuopt::linear_programming::io::mps_data_model_t read_from_mps( +cuopt::mathematical_optimization::io::mps_data_model_t read_from_mps( const std::string& file, bool fixed_mps_format = true) { std::string rel_file{}; // assume relative paths are relative to RAPIDS_DATASET_ROOT_DIR const std::string& rapidsDatasetRootDir = cuopt::test::get_rapids_dataset_root_dir(); rel_file = rapidsDatasetRootDir + "/" + file; - return cuopt::linear_programming::io::read_mps(rel_file, fixed_mps_format); + return cuopt::mathematical_optimization::io::read_mps(rel_file, fixed_mps_format); } TEST(optimization_problem_t, good_mps_file_1) @@ -590,4 +590,4 @@ TEST(optimization_problem_t, good_mps_mip_file_no_marker) EXPECT_EQ(10., h_upper_bounds[1]); } -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/tests/linear_programming/unit_tests/presolve_test.cu b/cpp/tests/linear_programming/unit_tests/presolve_test.cu index 449f20edae..a39c6642b2 100644 --- a/cpp/tests/linear_programming/unit_tests/presolve_test.cu +++ b/cpp/tests/linear_programming/unit_tests/presolve_test.cu @@ -7,10 +7,10 @@ #include "../utilities/pdlp_test_utilities.cuh" -#include -#include -#include -#include +#include +#include +#include +#include #include #include #include @@ -28,7 +28,7 @@ #include #include -namespace cuopt::linear_programming::test { +namespace cuopt::mathematical_optimization::test { // Helper function to compute constraint residuals for the original problem static void compute_constraint_residuals(const std::vector& coefficients, @@ -108,7 +108,7 @@ TEST(pslp_presolve, postsolve_accuracy_afiro) constexpr double expected_obj = -464.75314; // Known optimal objective for afiro auto path = make_path_absolute("linear_programming/afiro_original.mps"); - auto mps_data_model = cuopt::linear_programming::io::read_mps(path, true); + auto mps_data_model = cuopt::mathematical_optimization::io::read_mps(path, true); // Store original problem data for later verification const auto& orig_coefficients = mps_data_model.get_constraint_matrix_values(); @@ -124,8 +124,8 @@ TEST(pslp_presolve, postsolve_accuracy_afiro) const int orig_n_constraints = mps_data_model.get_n_constraints(); // Solve with PSLP presolve enabled - auto solver_settings = pdlp_solver_settings_t{}; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; + auto solver_settings = pdlp_solver_settings_t{}; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; solver_settings.tolerances.relative_primal_tolerance = 1e-6; solver_settings.tolerances.relative_dual_tolerance = 1e-6; solver_settings.tolerances.absolute_primal_tolerance = 1e-6; @@ -168,14 +168,14 @@ TEST(pslp_presolve, postsolve_dual_accuracy_afiro) const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/afiro_original.mps"); - auto mps_data_model = cuopt::linear_programming::io::read_mps(path, true); + auto mps_data_model = cuopt::mathematical_optimization::io::read_mps(path, true); const int orig_n_vars = mps_data_model.get_n_variables(); const int orig_n_constraints = mps_data_model.get_n_constraints(); // Solve with PSLP presolve and dual postsolve enabled auto solver_settings = pdlp_solver_settings_t{}; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; solver_settings.presolver = presolver_t::PSLP; optimization_problem_solution_t solution = @@ -204,7 +204,7 @@ TEST(pslp_presolve, postsolve_accuracy_larger_problem) constexpr double tolerance = 1e-4; auto path = make_path_absolute("linear_programming/ex10/ex10.mps"); - auto mps_data_model = cuopt::linear_programming::io::read_mps(path, false); + auto mps_data_model = cuopt::mathematical_optimization::io::read_mps(path, false); // Store original problem dimensions const auto& orig_coefficients = mps_data_model.get_constraint_matrix_values(); @@ -218,9 +218,9 @@ TEST(pslp_presolve, postsolve_accuracy_larger_problem) const int orig_n_constraints = mps_data_model.get_n_constraints(); // Solve with PSLP presolve - auto solver_settings = pdlp_solver_settings_t{}; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; - solver_settings.presolver = presolver_t::PSLP; + auto solver_settings = pdlp_solver_settings_t{}; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; + solver_settings.presolver = presolver_t::PSLP; solver_settings.tolerances.relative_primal_tolerance = 1e-6; solver_settings.tolerances.relative_dual_tolerance = 1e-6; solver_settings.tolerances.absolute_primal_tolerance = 1e-6; @@ -254,11 +254,11 @@ TEST(pslp_presolve, compare_with_no_presolve) constexpr double obj_tolerance = 1e-3; auto path = make_path_absolute("linear_programming/afiro_original.mps"); - auto mps_data_model = cuopt::linear_programming::io::read_mps(path, true); + auto mps_data_model = cuopt::mathematical_optimization::io::read_mps(path, true); // Solve without presolve auto settings_no_presolve = pdlp_solver_settings_t{}; - settings_no_presolve.method = cuopt::linear_programming::method_t::PDLP; + settings_no_presolve.method = cuopt::mathematical_optimization::method_t::PDLP; settings_no_presolve.presolver = presolver_t::None; settings_no_presolve.tolerances.relative_primal_tolerance = 1e-6; settings_no_presolve.tolerances.relative_dual_tolerance = 1e-6; @@ -271,9 +271,9 @@ TEST(pslp_presolve, compare_with_no_presolve) solve_lp(&handle_, mps_data_model, settings_no_presolve); // Solve with PSLP presolve - auto settings_pslp = pdlp_solver_settings_t{}; - settings_pslp.method = cuopt::linear_programming::method_t::PDLP; - settings_pslp.presolver = presolver_t::PSLP; + auto settings_pslp = pdlp_solver_settings_t{}; + settings_pslp.method = cuopt::mathematical_optimization::method_t::PDLP; + settings_pslp.presolver = presolver_t::PSLP; settings_pslp.tolerances.relative_primal_tolerance = 1e-6; settings_pslp.tolerances.relative_dual_tolerance = 1e-6; settings_pslp.tolerances.absolute_primal_tolerance = 1e-6; @@ -324,13 +324,13 @@ TEST(pslp_presolve, postsolve_reduced_costs) const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/afiro_original.mps"); - auto mps_data_model = cuopt::linear_programming::io::read_mps(path, true); + auto mps_data_model = cuopt::mathematical_optimization::io::read_mps(path, true); const int orig_n_vars = mps_data_model.get_n_variables(); // Solve with PSLP and dual postsolve auto solver_settings = pdlp_solver_settings_t{}; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; solver_settings.presolver = presolver_t::PSLP; optimization_problem_solution_t solution = @@ -359,13 +359,13 @@ TEST(pslp_presolve, postsolve_multiple_problems) for (const auto& [name, expected_obj] : instances) { auto path = make_path_absolute("linear_programming/" + name + ".mps"); auto mps_data_model = - cuopt::linear_programming::io::read_mps(path, name == "afiro_original"); + cuopt::mathematical_optimization::io::read_mps(path, name == "afiro_original"); const int orig_n_vars = mps_data_model.get_n_variables(); const int orig_n_constraints = mps_data_model.get_n_constraints(); auto solver_settings = pdlp_solver_settings_t{}; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; solver_settings.presolver = presolver_t::PSLP; optimization_problem_solution_t solution = @@ -384,6 +384,6 @@ TEST(pslp_presolve, postsolve_multiple_problems) } } -} // namespace cuopt::linear_programming::test +} // namespace cuopt::mathematical_optimization::test CUOPT_TEST_PROGRAM_MAIN() diff --git a/cpp/tests/linear_programming/unit_tests/solution_interface_test.cu b/cpp/tests/linear_programming/unit_tests/solution_interface_test.cu index f7f164900a..3e7a34044b 100644 --- a/cpp/tests/linear_programming/unit_tests/solution_interface_test.cu +++ b/cpp/tests/linear_programming/unit_tests/solution_interface_test.cu @@ -15,14 +15,14 @@ * the MPS-parser-to-problem pipeline and legitimately needs a real file. */ -#include -#include -#include -#include -#include -#include -#include -#include +#include +#include +#include +#include +#include +#include +#include +#include #include #include @@ -31,7 +31,7 @@ #include #include -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { // ============================================================================= // Helpers: build tiny problems and solutions with known data @@ -368,7 +368,7 @@ TEST_F(SolutionInterfaceTest, cpu_problem_to_optimization_problem) // This test legitimately uses the MPS parser since it tests that pipeline TEST_F(SolutionInterfaceTest, mps_data_model_to_optimization_problem) { - auto mps_data = cuopt::linear_programming::io::read_mps(lp_file_); + auto mps_data = cuopt::mathematical_optimization::io::read_mps(lp_file_); raft::handle_t handle; auto problem = mps_data_model_to_optimization_problem(&handle, mps_data); @@ -523,4 +523,4 @@ TEST_F(SolutionInterfaceTest, cpu_problem_copy_to_host_methods) } } -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/tests/linear_programming/unit_tests/solver_settings_test.cu b/cpp/tests/linear_programming/unit_tests/solver_settings_test.cu index 9f73c50359..44c79b30bf 100644 --- a/cpp/tests/linear_programming/unit_tests/solver_settings_test.cu +++ b/cpp/tests/linear_programming/unit_tests/solver_settings_test.cu @@ -5,7 +5,7 @@ */ /* clang-format on */ -#include +#include #include #include @@ -19,12 +19,12 @@ #include #include -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { TEST(SolverSettingsTest, TestSetGet) { - cuopt::linear_programming::pdlp_solver_settings_t solver_settings = - cuopt::linear_programming::pdlp_solver_settings_t{}; + cuopt::mathematical_optimization::pdlp_solver_settings_t solver_settings = + cuopt::mathematical_optimization::pdlp_solver_settings_t{}; const double tolerance_value = 1e-5; @@ -54,8 +54,8 @@ TEST(SolverSettingsTest, TestSetGet) EXPECT_TRUE(solver_settings.detect_infeasibility); // To avoid the "," inside the macros which are interpreted as extra parameters - auto Stable3 = cuopt::linear_programming::pdlp_solver_mode_t::Stable3; - auto Fast1 = cuopt::linear_programming::pdlp_solver_mode_t::Fast1; + auto Stable3 = cuopt::mathematical_optimization::pdlp_solver_mode_t::Stable3; + auto Fast1 = cuopt::mathematical_optimization::pdlp_solver_mode_t::Fast1; EXPECT_EQ(solver_settings.pdlp_solver_mode, Stable3); solver_settings.pdlp_solver_mode = Fast1; EXPECT_EQ(solver_settings.pdlp_solver_mode, Fast1); @@ -75,8 +75,8 @@ TEST(SolverSettingsTest, warm_start_smaller_vector) { const raft::handle_t handle_{}; - cuopt::linear_programming::pdlp_solver_settings_t solver_settings = - cuopt::linear_programming::pdlp_solver_settings_t{}; + cuopt::mathematical_optimization::pdlp_solver_settings_t solver_settings = + cuopt::mathematical_optimization::pdlp_solver_settings_t{}; std::vector primal = {0.0, 1.0, 2.0, 3.0}; std::vector dual = {0.0, 1.0, 2.0, 3.0}; @@ -175,8 +175,8 @@ TEST(SolverSettingsTest, warm_start_bigger_vector) { const raft::handle_t handle_{}; - cuopt::linear_programming::pdlp_solver_settings_t solver_settings = - cuopt::linear_programming::pdlp_solver_settings_t{}; + cuopt::mathematical_optimization::pdlp_solver_settings_t solver_settings = + cuopt::mathematical_optimization::pdlp_solver_settings_t{}; std::vector primal = {0.0, 1.0, 2.0, 3.0}; std::vector dual = {0.0, 1.0, 2.0}; @@ -272,4 +272,4 @@ TEST(SolverSettingsTest, warm_start_bigger_vector) EXPECT_EQ(h_last_restart_duality_gap_dual_solution, dual_expected); } -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/tests/linear_programming/utilities/pdlp_test_utilities.cuh b/cpp/tests/linear_programming/utilities/pdlp_test_utilities.cuh index 3ce043de8a..7e3f83dae9 100644 --- a/cpp/tests/linear_programming/utilities/pdlp_test_utilities.cuh +++ b/cpp/tests/linear_programming/utilities/pdlp_test_utilities.cuh @@ -6,10 +6,10 @@ /* clang-format on */ #pragma once -#include -#include -#include -#include +#include +#include +#include +#include #include #include @@ -22,7 +22,7 @@ #include -namespace cuopt::linear_programming::test { +namespace cuopt::mathematical_optimization::test { constexpr double tolerance = 1e-6f; static std::string make_path_absolute(const std::string& file) @@ -37,16 +37,16 @@ static std::string make_path_absolute(const std::string& file) // Wrapper for the batch PDLP flow: convert and potentially expand the problem and call // run_batch_pdlp. template -static cuopt::linear_programming::optimization_problem_solution_t solve_lp_batch( +static cuopt::mathematical_optimization::optimization_problem_solution_t solve_lp_batch( raft::handle_t const* handle_ptr, - const cuopt::linear_programming::io::mps_data_model_t& mps_data_model, - const cuopt::linear_programming::pdlp_solver_settings_t& settings) + const cuopt::mathematical_optimization::io::mps_data_model_t& mps_data_model, + const cuopt::mathematical_optimization::pdlp_solver_settings_t& settings) { - auto gpu_op = cuopt::linear_programming::mps_data_model_to_optimization_problem( + auto gpu_op = cuopt::mathematical_optimization::mps_data_model_to_optimization_problem( handle_ptr, mps_data_model); auto batch_settings = settings; batch_settings.generate_batch_primal_dual_solution = true; - return cuopt::linear_programming::run_batch_pdlp(gpu_op, batch_settings); + return cuopt::mathematical_optimization::run_batch_pdlp(gpu_op, batch_settings); } // Overwrites the device_uvector with the host-side contents, resizing as needed. @@ -70,10 +70,11 @@ static void assign_device_uvector_from_host(rmm::device_uvector& target, // - per_climber_constraint_lower_bounds / upper_bounds: size (batch_size * n_constraints). // - per_climber_objective_offsets: size (batch_size). template -static cuopt::linear_programming::optimization_problem_solution_t solve_lp_batch_fixed( +static cuopt::mathematical_optimization::optimization_problem_solution_t +solve_lp_batch_fixed( raft::handle_t const* handle_ptr, - const cuopt::linear_programming::io::mps_data_model_t& mps_data_model, - cuopt::linear_programming::pdlp_solver_settings_t settings, + const cuopt::mathematical_optimization::io::mps_data_model_t& mps_data_model, + cuopt::mathematical_optimization::pdlp_solver_settings_t settings, i_t batch_size, const std::vector& per_climber_objective_coefficients = {}, const std::vector& per_climber_constraint_lower_bounds = {}, @@ -81,7 +82,7 @@ static cuopt::linear_programming::optimization_problem_solution_t solv const std::vector& per_climber_objective_offsets = {}, bool use_direct_api = false) { - auto gpu_op = cuopt::linear_programming::mps_data_model_to_optimization_problem( + auto gpu_op = cuopt::mathematical_optimization::mps_data_model_to_optimization_problem( handle_ptr, mps_data_model); auto stream = handle_ptr->get_stream(); @@ -106,13 +107,15 @@ static cuopt::linear_programming::optimization_problem_solution_t solv settings.generate_batch_primal_dual_solution = true; settings.fixed_batch_size = batch_size; - if (use_direct_api) { return cuopt::linear_programming::solve_lp(gpu_op, settings, false); } - return cuopt::linear_programming::run_batch_pdlp(gpu_op, settings); + if (use_direct_api) { + return cuopt::mathematical_optimization::solve_lp(gpu_op, settings, false); + } + return cuopt::mathematical_optimization::run_batch_pdlp(gpu_op, settings); } // Compute on the CPU x * c to check that the returned objective value is correct static void test_objective_sanity( - const cuopt::linear_programming::io::mps_data_model_t& op_problem, + const cuopt::mathematical_optimization::io::mps_data_model_t& op_problem, const rmm::device_uvector& primal_solution, double objective_value, double epsilon = tolerance) @@ -137,7 +140,7 @@ static void test_objective_sanity( // Compute on the CPU x * c to check that the returned objective value is correct static void test_objective_sanity( - const cuopt::linear_programming::io::mps_data_model_t& op_problem, + const cuopt::mathematical_optimization::io::mps_data_model_t& op_problem, const std::vector& primal_solution, double objective_value, double epsilon = tolerance) @@ -164,7 +167,7 @@ static void test_objective_sanity( // Check that it respect the absolute/relative tolerance // Check that the primal variables respected the variable bounds static void test_constraint_sanity( - const cuopt::linear_programming::io::mps_data_model_t& op_problem, + const cuopt::mathematical_optimization::io::mps_data_model_t& op_problem, const optimization_problem_solution_t::additional_termination_information_t& termination_information, const rmm::device_uvector& primal_solution, @@ -191,7 +194,7 @@ static void test_constraint_sanity( } } - auto functor = cuopt::linear_programming::detail::violation{}; + auto functor = cuopt::mathematical_optimization::pdlp::violation{}; // Compute violation to lower/upper bound @@ -217,7 +220,7 @@ static void test_constraint_sanity( constraint_lower_bounds.cend(), constraint_upper_bounds.cbegin(), combined_bounds.begin(), - cuopt::linear_programming::detail::combine_finite_abs_bounds{}); + cuopt::mathematical_optimization::pdlp::combine_finite_abs_bounds{}); double l2_norm_primal_right_hand_side = std::accumulate( combined_bounds.cbegin(), combined_bounds.cend(), 0.0, [](double acc, double val) { @@ -247,4 +250,4 @@ static void test_constraint_sanity( } } -} // namespace cuopt::linear_programming::test +} // namespace cuopt::mathematical_optimization::test diff --git a/cpp/tests/mip/bounds_standardization_test.cu b/cpp/tests/mip/bounds_standardization_test.cu index 059b038f0c..5219366ce6 100644 --- a/cpp/tests/mip/bounds_standardization_test.cu +++ b/cpp/tests/mip/bounds_standardization_test.cu @@ -8,9 +8,9 @@ #include "../linear_programming/utilities/pdlp_test_utilities.cuh" #include "mip_utils.cuh" -#include -#include -#include +#include +#include +#include #include #include #include @@ -29,7 +29,7 @@ #include #include -namespace cuopt::linear_programming::test { +namespace cuopt::mathematical_optimization::test { void init_handler(const raft::handle_t* handle_ptr) { @@ -45,27 +45,27 @@ void test_bounds_standardization_test(std::string test_instance) const raft::handle_t handle_{}; std::cout << "Running: " << test_instance << std::endl; auto path = make_path_absolute(test_instance); - cuopt::linear_programming::io::mps_data_model_t problem = - cuopt::linear_programming::io::read_mps(path, false); + cuopt::mathematical_optimization::io::mps_data_model_t problem = + cuopt::mathematical_optimization::io::read_mps(path, false); handle_.sync_stream(); auto op_problem = mps_data_model_to_optimization_problem(&handle_, problem); problem_checking_t::check_problem_representation(op_problem); init_handler(op_problem.get_handle_ptr()); // run the problem constructor of MIP, so that we do bounds standardization - detail::problem_t standardized_problem(op_problem); - detail::problem_t original_problem(op_problem); + mip::problem_t standardized_problem(op_problem); + mip::problem_t original_problem(op_problem); standardized_problem.preprocess_problem(); - detail::trivial_presolve(standardized_problem); - detail::solution_t solution_1(standardized_problem); + mip::trivial_presolve(standardized_problem); + mip::solution_t solution_1(standardized_problem); mip_solver_settings_t default_settings{}; - detail::relaxed_lp_settings_t lp_settings; + mip::relaxed_lp_settings_t lp_settings; lp_settings.time_limit = 120.; lp_settings.tolerance = default_settings.tolerances.absolute_tolerance; lp_settings.per_constraint_residual = false; // run the problem through pdlp - auto result_1 = detail::get_relaxed_lp_solution(standardized_problem, solution_1, lp_settings); + auto result_1 = mip::get_relaxed_lp_solution(standardized_problem, solution_1, lp_settings); solution_1.compute_feasibility(); bool sol_1_feasible = (int)result_1.get_termination_status() == CUOPT_TERMINATION_STATUS_OPTIMAL; // the problem might not be feasible in terms of per constraint residual @@ -87,7 +87,7 @@ void test_bounds_standardization_test(std::string test_instance) // not applied op_problem.set_problem_category(problem_category_t::LP); auto settings = pdlp_solver_settings_t{}; - settings.pdlp_solver_mode = cuopt::linear_programming::pdlp_solver_mode_t::Stable1; + settings.pdlp_solver_mode = cuopt::mathematical_optimization::pdlp_solver_mode_t::Stable1; settings.set_optimality_tolerance(1e-4); settings.tolerances.relative_primal_tolerance = 1e-6; settings.tolerances.relative_dual_tolerance = 1e-6; @@ -104,4 +104,4 @@ TEST(mip_solve, bounds_standardization_test) } } -} // namespace cuopt::linear_programming::test +} // namespace cuopt::mathematical_optimization::test diff --git a/cpp/tests/mip/cuts_test.cu b/cpp/tests/mip/cuts_test.cu index 1fb0c65a1d..642f69a04e 100644 --- a/cpp/tests/mip/cuts_test.cu +++ b/cpp/tests/mip/cuts_test.cu @@ -8,10 +8,10 @@ #include "../linear_programming/utilities/pdlp_test_utilities.cuh" #include "mip_utils.cuh" -#include -#include -#include -#include +#include +#include +#include +#include #include #include #include @@ -39,7 +39,7 @@ #include #include -namespace cuopt::linear_programming::test { +namespace cuopt::mathematical_optimization::test { namespace { @@ -137,27 +137,27 @@ End )LP"); } -detail::clique_table_t build_clique_table_for_model_with_min_size( +mip::clique_table_t build_clique_table_for_model_with_min_size( const raft::handle_t& handle, const io::mps_data_model_t& model, int min_clique_size) { auto op_problem = mps_data_model_to_optimization_problem(&handle, model); - detail::problem_t mip_problem(op_problem); - dual_simplex::user_problem_t host_problem(op_problem.get_handle_ptr()); + mip::problem_t mip_problem(op_problem); + simplex::user_problem_t host_problem(op_problem.get_handle_ptr()); mip_problem.get_host_user_problem(host_problem); - detail::clique_config_t clique_config; + mip::clique_config_t clique_config; clique_config.min_clique_size = min_clique_size; - detail::clique_table_t clique_table(2 * host_problem.num_cols, - clique_config.min_clique_size, - clique_config.max_clique_size_for_extension); + mip::clique_table_t clique_table(2 * host_problem.num_cols, + clique_config.min_clique_size, + clique_config.max_clique_size_for_extension); mip_solver_settings_t settings; cuopt::timer_t timer(std::numeric_limits::infinity()); - detail::build_clique_table(host_problem, clique_table, settings.tolerances, true, true, timer); + mip::build_clique_table(host_problem, clique_table, settings.tolerances, true, true, timer); return clique_table; } -detail::clique_table_t build_clique_table_for_model( +mip::clique_table_t build_clique_table_for_model( const raft::handle_t& handle, const io::mps_data_model_t& model) { return build_clique_table_for_model_with_min_size(handle, model, 1); @@ -169,30 +169,30 @@ io::mps_data_model_t& get_neos8_model_cached() static std::unique_ptr> model_ptr; std::call_once(init_flag, []() { const auto neos8_path = make_path_absolute("mip/neos8.mps"); - auto neos8_model = cuopt::linear_programming::io::read_mps(neos8_path, false); + auto neos8_model = + cuopt::mathematical_optimization::io::read_mps(neos8_path, false); model_ptr = std::make_unique>(std::move(neos8_model)); }); cuopt_assert(model_ptr != nullptr, "Failed to initialize cached neos8 model"); return *model_ptr; } -detail::clique_table_t& get_neos8_clique_table_cached() +mip::clique_table_t& get_neos8_clique_table_cached() { static std::once_flag init_flag; - static std::unique_ptr> clique_table_ptr; + static std::unique_ptr> clique_table_ptr; std::call_once(init_flag, []() { const raft::handle_t handle{}; auto& neos8_model = get_neos8_model_cached(); auto clique_table = build_clique_table_for_model(handle, neos8_model); - clique_table_ptr = - std::make_unique>(std::move(clique_table)); + clique_table_ptr = std::make_unique>(std::move(clique_table)); }); cuopt_assert(clique_table_ptr != nullptr, "Failed to initialize cached neos8 clique table"); return *clique_table_ptr; } std::vector> build_original_adjacency_matrix( - detail::clique_table_t& clique_table, int num_vars) + mip::clique_table_t& clique_table, int num_vars) { std::vector> adj(num_vars, std::vector(num_vars, 0)); for (int i = 0; i < num_vars; ++i) { @@ -279,7 +279,7 @@ std::vector> maximal_cliques_from_production_algorithm( { const auto adj_list = adjacency_matrix_to_list(adj); std::vector weights(adj_list.size(), 1.0); - auto cliques = dual_simplex::find_maximal_cliques_for_test( + auto cliques = mip::find_maximal_cliques_for_test( adj_list, weights, 0.0, 100000, std::numeric_limits::infinity()); return canonicalize_cliques(std::move(cliques)); } @@ -465,7 +465,7 @@ bool is_binary_var_for_clique_literals(const io::mps_data_model_t& std::vector> build_fractional_literal_cliques_for_assignment( const io::mps_data_model_t& problem, - detail::clique_table_t& clique_table, + mip::clique_table_t& clique_table, const std::vector& assignment, double integer_tol, double bound_tol, @@ -512,7 +512,7 @@ std::vector> build_fractional_literal_cliques_for_assignment( } } - auto cliques_local = dual_simplex::find_maximal_cliques_for_test( + auto cliques_local = mip::find_maximal_cliques_for_test( adj_local, weights, 1.0 + kCliqueTestTol, max_calls, std::numeric_limits::infinity()); std::vector> cliques_global; cliques_global.reserve(cliques_local.size()); @@ -848,49 +848,49 @@ TEST(cuts, test_cuts_2) TEST(cuts, test_duplicate_cuts_detection) { - dual_simplex::simplex_solver_settings_t settings; - dual_simplex::cut_pool_t cut_pool(4, settings); - dual_simplex::inequality_t cut1; + simplex::simplex_solver_settings_t settings; + mip::cut_pool_t cut_pool(4, settings); + mip::inequality_t cut1; cut1.push_back(0, 1.0); cut1.push_back(1, 2.0); cut1.rhs = 1.0; - cut_pool.add_cut(dual_simplex::cut_type_t::MIXED_INTEGER_GOMORY, cut1); - dual_simplex::inequality_t cut2; + cut_pool.add_cut(mip::cut_type_t::MIXED_INTEGER_GOMORY, cut1); + mip::inequality_t cut2; cut2.push_back(0, 2.0); cut2.push_back(1, 4.0); cut2.rhs = 2.0; - cut_pool.add_cut(dual_simplex::cut_type_t::MIXED_INTEGER_GOMORY, cut2); - dual_simplex::inequality_t cut3; + cut_pool.add_cut(mip::cut_type_t::MIXED_INTEGER_GOMORY, cut2); + mip::inequality_t cut3; cut3.push_back(0, 0.1); cut3.push_back(2, 0.2); cut3.rhs = 1.0; - cut_pool.add_cut(dual_simplex::cut_type_t::MIXED_INTEGER_GOMORY, cut3); - dual_simplex::inequality_t cut4; + cut_pool.add_cut(mip::cut_type_t::MIXED_INTEGER_GOMORY, cut3); + mip::inequality_t cut4; cut4.push_back(0, 0.2); cut4.push_back(2, 0.4); cut4.rhs = 1.0; - cut_pool.add_cut(dual_simplex::cut_type_t::MIXED_INTEGER_GOMORY, cut4); - dual_simplex::inequality_t cut5; + cut_pool.add_cut(mip::cut_type_t::MIXED_INTEGER_GOMORY, cut4); + mip::inequality_t cut5; cut5.push_back(1, 10.0); cut5.push_back(3, 20.0); cut5.rhs = 0.1; - cut_pool.add_cut(dual_simplex::cut_type_t::MIXED_INTEGER_GOMORY, cut5); - dual_simplex::inequality_t cut6; + cut_pool.add_cut(mip::cut_type_t::MIXED_INTEGER_GOMORY, cut5); + mip::inequality_t cut6; cut6.push_back(1, 20.0); cut6.push_back(3, 40.0); cut6.rhs = 0.2; - cut_pool.add_cut(dual_simplex::cut_type_t::MIXED_INTEGER_GOMORY, cut6); - dual_simplex::inequality_t cut7; + cut_pool.add_cut(mip::cut_type_t::MIXED_INTEGER_GOMORY, cut6); + mip::inequality_t cut7; cut7.push_back(0, 1.0); cut7.push_back(1, 1.0); cut7.push_back(2, 1.0); cut7.push_back(3, 1.0); cut7.rhs = 1.0; - cut_pool.add_cut(dual_simplex::cut_type_t::MIXED_INTEGER_GOMORY, cut7); - dual_simplex::inequality_t cut8; + cut_pool.add_cut(mip::cut_type_t::MIXED_INTEGER_GOMORY, cut7); + mip::inequality_t cut8; cut8.push_back(1, 3.0); cut8.rhs = 7.0; - cut_pool.add_cut(dual_simplex::cut_type_t::MIXED_INTEGER_GOMORY, cut8); + cut_pool.add_cut(mip::cut_type_t::MIXED_INTEGER_GOMORY, cut8); cut_pool.check_for_duplicate_cuts(); } @@ -1347,11 +1347,11 @@ End struct flow_cover_test_problem_t { raft::handle_t handle; - dual_simplex::simplex_solver_settings_t settings; - dual_simplex::lp_problem_t lp; - dual_simplex::csr_matrix_t Arow; + simplex::simplex_solver_settings_t settings; + simplex::lp_problem_t lp; + simplex::csr_matrix_t Arow; std::vector new_slacks; - std::vector var_types; + std::vector var_types; flow_cover_test_problem_t() : handle(), settings(), lp(&handle, 1, 1, 1), Arow(0, 0, 0) {} }; @@ -1361,17 +1361,16 @@ flow_cover_test_problem_t build_flow_cover_test_problem( { flow_cover_test_problem_t test_problem; auto op_problem = mps_data_model_to_optimization_problem(&test_problem.handle, model); - detail::problem_t mip_problem(op_problem); - dual_simplex::user_problem_t host_problem(op_problem.get_handle_ptr()); + mip::problem_t mip_problem(op_problem); + simplex::user_problem_t host_problem(op_problem.get_handle_ptr()); mip_problem.get_host_user_problem(host_problem); - dual_simplex::dualize_info_t dualize_info; - dual_simplex::convert_user_problem( + simplex::dualize_info_t dualize_info; + simplex::convert_user_problem( host_problem, test_problem.settings, test_problem.lp, test_problem.new_slacks, dualize_info); test_problem.var_types = host_problem.var_types; if (test_problem.lp.num_cols > static_cast(test_problem.var_types.size())) { - test_problem.var_types.resize(test_problem.lp.num_cols, - dual_simplex::variable_type_t::CONTINUOUS); + test_problem.var_types.resize(test_problem.lp.num_cols, simplex::variable_type_t::CONTINUOUS); } test_problem.lp.A.to_compressed_row(test_problem.Arow); return test_problem; @@ -1395,15 +1394,15 @@ bool single_node_flow_y_feasible(const std::vector& y) return activity <= 4.0 + 1e-8; } -void expect_single_node_flow_cut_valid_at_point(const dual_simplex::inequality_t& cut, +void expect_single_node_flow_cut_valid_at_point(const mip::inequality_t& cut, const std::vector& point, const std::string& label) { EXPECT_GE(cut.vector.dot(point), cut.rhs - 1e-7) << label; } -void expect_single_node_flow_cut_valid_at_extreme_points( - const dual_simplex::inequality_t& cut, int num_cols) +void expect_single_node_flow_cut_valid_at_extreme_points(const mip::inequality_t& cut, + int num_cols) { const std::vector capacities = {3.0, 6.0, 3.0}; const std::vector flow_signs = {1.0, 1.0, -1.0}; @@ -1477,18 +1476,18 @@ TEST(cuts, flow_cover_generates_valid_single_node_flow_cut) auto test_problem = build_flow_cover_test_problem(create_small_single_node_flow_problem()); const std::vector xstar = single_node_flow_fractional_solution(test_problem.lp.num_cols); - dual_simplex::flow_cover_generation_t generator( + mip::flow_cover_generation_t generator( test_problem.lp, test_problem.settings, test_problem.Arow, test_problem.new_slacks); - dual_simplex::variable_bounds_t variable_bounds(test_problem.lp, - test_problem.settings, - test_problem.var_types, - test_problem.Arow, - test_problem.new_slacks); + mip::variable_bounds_t variable_bounds(test_problem.lp, + test_problem.settings, + test_problem.var_types, + test_problem.Arow, + test_problem.new_slacks); ASSERT_GT(generator.num_constraints(), 0); int generated_cuts = 0; for (const auto& flow_cover_row : generator.get_constraints()) { - dual_simplex::inequality_t cut(test_problem.lp.num_cols); + mip::inequality_t cut(test_problem.lp.num_cols); const int status = generator.generate_cut(test_problem.lp, test_problem.settings, test_problem.Arow, @@ -1508,4 +1507,4 @@ TEST(cuts, flow_cover_generates_valid_single_node_flow_cut) EXPECT_GT(generated_cuts, 0); } -} // namespace cuopt::linear_programming::test +} // namespace cuopt::mathematical_optimization::test diff --git a/cpp/tests/mip/determinism_test.cu b/cpp/tests/mip/determinism_test.cu index 0accf2ba67..8f63152d09 100644 --- a/cpp/tests/mip/determinism_test.cu +++ b/cpp/tests/mip/determinism_test.cu @@ -8,10 +8,10 @@ #include "../linear_programming/utilities/pdlp_test_utilities.cuh" #include "mip_utils.cuh" -#include -#include -#include -#include +#include +#include +#include +#include #include #include #include @@ -27,7 +27,7 @@ #include #include -namespace cuopt::linear_programming::test { +namespace cuopt::mathematical_optimization::test { namespace { @@ -246,4 +246,4 @@ INSTANTIATE_TEST_SUITE_P( return name + "_threads" + std::to_string(threads); }); -} // namespace cuopt::linear_programming::test +} // namespace cuopt::mathematical_optimization::test diff --git a/cpp/tests/mip/doc_example_test.cu b/cpp/tests/mip/doc_example_test.cu index 04c383b455..57d7b7f88d 100644 --- a/cpp/tests/mip/doc_example_test.cu +++ b/cpp/tests/mip/doc_example_test.cu @@ -8,8 +8,8 @@ #include "../linear_programming/utilities/pdlp_test_utilities.cuh" #include "mip_utils.cuh" -#include -#include +#include +#include #include #include @@ -19,7 +19,7 @@ #include -namespace cuopt::linear_programming::test { +namespace cuopt::mathematical_optimization::test { io::mps_data_model_t create_doc_example_problem() { @@ -87,14 +87,14 @@ TEST(docs, user_problem_file) settings.time_limit = test_time_limit; settings.user_problem_file = user_problem_path; - settings.presolver = cuopt::linear_programming::presolver_t::None; + settings.presolver = cuopt::mathematical_optimization::presolver_t::None; EXPECT_EQ(solve_mip(&handle_, problem, settings).get_termination_status(), mip_termination_status_t::Optimal); EXPECT_TRUE(std::filesystem::exists(user_problem_path)); - cuopt::linear_programming::io::mps_data_model_t problem2 = - cuopt::linear_programming::io::read_mps(user_problem_path, false); + cuopt::mathematical_optimization::io::mps_data_model_t problem2 = + cuopt::mathematical_optimization::io::read_mps(user_problem_path, false); EXPECT_EQ(problem2.get_n_variables(), problem.get_n_variables()); EXPECT_EQ(problem2.get_n_constraints(), problem.get_n_constraints()); @@ -124,4 +124,4 @@ TEST(docs, user_problem_file) } } -} // namespace cuopt::linear_programming::test +} // namespace cuopt::mathematical_optimization::test diff --git a/cpp/tests/mip/elim_var_remap_test.cu b/cpp/tests/mip/elim_var_remap_test.cu index 776ebbd310..eb6f2ae750 100644 --- a/cpp/tests/mip/elim_var_remap_test.cu +++ b/cpp/tests/mip/elim_var_remap_test.cu @@ -8,7 +8,7 @@ #include "../linear_programming/utilities/pdlp_test_utilities.cuh" #include "mip_utils.cuh" -#include +#include #include #include #include @@ -32,7 +32,7 @@ #include #include -namespace cuopt::linear_programming::test { +namespace cuopt::mathematical_optimization::test { void init_handler(const raft::handle_t* handle_ptr) { @@ -60,15 +60,15 @@ void test_elim_var_remap(std::string test_instance) const raft::handle_t handle_{}; std::cout << "Running: " << test_instance << std::endl; auto path = make_path_absolute(test_instance); - cuopt::linear_programming::io::mps_data_model_t mps_problem = - cuopt::linear_programming::io::read_mps(path, false); + cuopt::mathematical_optimization::io::mps_data_model_t mps_problem = + cuopt::mathematical_optimization::io::read_mps(path, false); handle_.sync_stream(); auto op_problem = mps_data_model_to_optimization_problem(&handle_, mps_problem); problem_checking_t::check_problem_representation(op_problem); init_handler(op_problem.get_handle_ptr()); // run the problem constructor of MIP, so that we do bounds standardization - detail::problem_t problem(op_problem); + mip::problem_t problem(op_problem); problem.preprocess_problem(); trivial_presolve(problem); @@ -95,12 +95,12 @@ void test_elim_var_remap(std::string test_instance) 0); } - detail::problem_t sub_problem(problem); + mip::problem_t sub_problem(problem); trivial_presolve(sub_problem); // check if number of variables is updated correctly due to trivial presolve EXPECT_EQ(sub_problem.n_variables, problem.n_variables - fixed_vars.size()); - detail::solution_t sol(sub_problem); + mip::solution_t sol(sub_problem); // Copy all unfixed variable assignments auto iter = thrust::remove_copy_if(handle_.get_thrust_policy(), @@ -128,28 +128,28 @@ void test_elim_var_solution(std::string test_instance) const raft::handle_t handle_{}; std::cout << "Running: " << test_instance << std::endl; auto path = make_path_absolute(test_instance); - cuopt::linear_programming::io::mps_data_model_t mps_problem = - cuopt::linear_programming::io::read_mps(path, false); + cuopt::mathematical_optimization::io::mps_data_model_t mps_problem = + cuopt::mathematical_optimization::io::read_mps(path, false); handle_.sync_stream(); auto op_problem = mps_data_model_to_optimization_problem(&handle_, mps_problem); problem_checking_t::check_problem_representation(op_problem); init_handler(op_problem.get_handle_ptr()); // run the problem constructor of MIP, so that we do bounds standardization - detail::problem_t standardized_problem(op_problem); - detail::problem_t original_problem(op_problem); + mip::problem_t standardized_problem(op_problem); + mip::problem_t original_problem(op_problem); standardized_problem.preprocess_problem(); trivial_presolve(standardized_problem); - detail::problem_t sub_problem(standardized_problem); + mip::problem_t sub_problem(standardized_problem); mip_solver_settings_t default_settings{}; - detail::solution_t solution_1(standardized_problem); - detail::relaxed_lp_settings_t lp_settings; + mip::solution_t solution_1(standardized_problem); + mip::relaxed_lp_settings_t lp_settings; lp_settings.time_limit = 120.; lp_settings.tolerance = default_settings.tolerances.absolute_tolerance; lp_settings.per_constraint_residual = false; // run the problem through pdlp - auto result_1 = detail::get_relaxed_lp_solution(standardized_problem, solution_1, lp_settings); + auto result_1 = mip::get_relaxed_lp_solution(standardized_problem, solution_1, lp_settings); solution_1.compute_feasibility(); // the solution might not be feasible per row as we are getting the result of pdlp bool sol_1_feasible = (int)result_1.get_termination_status() == CUOPT_TERMINATION_STATUS_OPTIMAL; @@ -173,13 +173,13 @@ void test_elim_var_solution(std::string test_instance) trivial_presolve(sub_problem); - detail::solution_t solution_2(sub_problem); - detail::relaxed_lp_settings_t lp_settings_2; + mip::solution_t solution_2(sub_problem); + mip::relaxed_lp_settings_t lp_settings_2; lp_settings_2.time_limit = 120.; lp_settings_2.tolerance = default_settings.tolerances.absolute_tolerance; lp_settings_2.per_constraint_residual = false; // run the problem through pdlp - auto result_2 = detail::get_relaxed_lp_solution(sub_problem, solution_2, lp_settings_2); + auto result_2 = mip::get_relaxed_lp_solution(sub_problem, solution_2, lp_settings_2); solution_2.compute_feasibility(); bool sol_2_feasible = (int)result_2.get_termination_status() == CUOPT_TERMINATION_STATUS_OPTIMAL; EXPECT_EQ((int)result_2.get_termination_status(), CUOPT_TERMINATION_STATUS_OPTIMAL); @@ -212,4 +212,4 @@ TEST(mip_solve, elim_var_remap_solution_test) } } -} // namespace cuopt::linear_programming::test +} // namespace cuopt::mathematical_optimization::test diff --git a/cpp/tests/mip/empty_fixed_problems_test.cu b/cpp/tests/mip/empty_fixed_problems_test.cu index 53acd82b06..b8a1bb556d 100644 --- a/cpp/tests/mip/empty_fixed_problems_test.cu +++ b/cpp/tests/mip/empty_fixed_problems_test.cu @@ -8,7 +8,7 @@ #include "../linear_programming/utilities/pdlp_test_utilities.cuh" #include "mip_utils.cuh" -#include +#include #include #include #include @@ -32,7 +32,7 @@ #include #include -namespace cuopt::linear_programming::test { +namespace cuopt::mathematical_optimization::test { TEST(mip_solve, fixed_problem_test) { @@ -75,4 +75,4 @@ TEST(mip_solve, mip_presolved_to_lp) EXPECT_NEAR(obj_val, 0, 1e-5); } -} // namespace cuopt::linear_programming::test +} // namespace cuopt::mathematical_optimization::test diff --git a/cpp/tests/mip/feasibility_jump_tests.cu b/cpp/tests/mip/feasibility_jump_tests.cu index 7820f1f6a0..c0c7800cad 100644 --- a/cpp/tests/mip/feasibility_jump_tests.cu +++ b/cpp/tests/mip/feasibility_jump_tests.cu @@ -9,9 +9,9 @@ #include "mip_utils.cuh" #include -#include -#include -#include +#include +#include +#include #include #include #include @@ -35,7 +35,7 @@ #include #include -namespace cuopt::linear_programming::test { +namespace cuopt::mathematical_optimization::test { void init_handler(const raft::handle_t* handle_ptr) { @@ -51,7 +51,7 @@ struct fj_tweaks_t { }; struct fj_state_t { - detail::solution_t solution; + mip::solution_t solution; std::vector solution_vector; int minimums; double incumbent_objective; @@ -60,7 +60,7 @@ struct fj_state_t { // Helper function to setup MIP solver and run FJ with given settings and initial solution static fj_state_t run_fj(std::string test_instance, - const detail::fj_settings_t& fj_settings, + const mip::fj_settings_t& fj_settings, fj_tweaks_t tweaks = {}, std::vector initial_solution = {}) { @@ -68,24 +68,24 @@ static fj_state_t run_fj(std::string test_instance, std::cout << "Running: " << test_instance << std::endl; auto path = cuopt::test::get_rapids_dataset_root_dir() + ("/mip/" + test_instance); - cuopt::linear_programming::io::mps_data_model_t mps_problem = - cuopt::linear_programming::io::read_mps(path, false); + cuopt::mathematical_optimization::io::mps_data_model_t mps_problem = + cuopt::mathematical_optimization::io::read_mps(path, false); handle_.sync_stream(); auto op_problem = mps_data_model_to_optimization_problem(&handle_, mps_problem); problem_checking_t::check_problem_representation(op_problem); init_handler(op_problem.get_handle_ptr()); // run the problem constructor of MIP, so that we do bounds standardization - detail::problem_t problem(op_problem); + mip::problem_t problem(op_problem); problem.preprocess_problem(); - detail::mip_scaling_strategy_t scaling(problem); + mip::mip_scaling_strategy_t scaling(problem); auto settings = mip_solver_settings_t{}; settings.time_limit = 30.; auto timer = cuopt::timer_t(30); - detail::mip_solver_t solver(problem, settings, scaling, timer); + mip::mip_solver_t solver(problem, settings, scaling, timer); - detail::solution_t solution(*solver.context.problem_ptr); + mip::solution_t solution(*solver.context.problem_ptr); if (initial_solution.size() > 0) { expand_device_copy(solution.assignment, initial_solution, solution.handle_ptr->get_stream()); } else { @@ -96,7 +96,7 @@ static fj_state_t run_fj(std::string test_instance, } solution.clamp_within_bounds(); - detail::fj_t fj(solver.context, fj_settings); + mip::fj_t fj(solver.context, fj_settings); fj.reset_weights(solution.handle_ptr->get_stream(), 1.); fj.objective_weight.set_value_async(tweaks.objective_weight, solution.handle_ptr->get_stream()); solution.handle_ptr->sync_stream(); @@ -115,9 +115,9 @@ static fj_state_t run_fj(std::string test_instance, // Ensure this is fixed on instances that historically triggered it. static bool run_fj_check_no_obj_runoff(std::string test_instance) { - detail::fj_settings_t fj_settings; + mip::fj_settings_t fj_settings; fj_settings.time_limit = 30.; - fj_settings.mode = detail::fj_mode_t::EXIT_NON_IMPROVING; + fj_settings.mode = mip::fj_mode_t::EXIT_NON_IMPROVING; fj_settings.n_of_minimums_for_exit = 20000 * 1000; fj_settings.update_weights = true; fj_settings.feasibility_run = false; @@ -137,9 +137,9 @@ static bool run_fj_check_objective(std::string test_instance, int iter_limit, do // tolerance obj_target += 1e-4; - detail::fj_settings_t fj_settings; + mip::fj_settings_t fj_settings; fj_settings.time_limit = 30.; - fj_settings.mode = detail::fj_mode_t::EXIT_NON_IMPROVING; + fj_settings.mode = mip::fj_mode_t::EXIT_NON_IMPROVING; fj_settings.n_of_minimums_for_exit = 20000 * 1000; fj_settings.update_weights = true; fj_settings.feasibility_run = obj_target == +std::numeric_limits::infinity(); @@ -164,9 +164,9 @@ static bool run_fj_check_objective(std::string test_instance, int iter_limit, do static bool run_fj_check_feasible(std::string test_instance) { - detail::fj_settings_t fj_settings; + mip::fj_settings_t fj_settings; fj_settings.time_limit = 30.; - fj_settings.mode = detail::fj_mode_t::EXIT_NON_IMPROVING; + fj_settings.mode = mip::fj_mode_t::EXIT_NON_IMPROVING; fj_settings.n_of_minimums_for_exit = 20000 * 1000; fj_settings.update_weights = true; fj_settings.feasibility_run = false; @@ -259,4 +259,4 @@ TEST(mip_solve, feasibility_jump_obj_runoff_test) } } -} // namespace cuopt::linear_programming::test +} // namespace cuopt::mathematical_optimization::test diff --git a/cpp/tests/mip/heuristics_hyper_params_test.cu b/cpp/tests/mip/heuristics_hyper_params_test.cu index 24b15f8cc8..c3ec4371f0 100644 --- a/cpp/tests/mip/heuristics_hyper_params_test.cu +++ b/cpp/tests/mip/heuristics_hyper_params_test.cu @@ -6,8 +6,8 @@ /* clang-format on */ #include -#include -#include +#include +#include #include @@ -16,7 +16,7 @@ #include #include -namespace cuopt::linear_programming::test { +namespace cuopt::mathematical_optimization::test { using settings_t = solver_settings_t; @@ -280,4 +280,4 @@ TEST_F(HeuristicsHyperParamsTest, UnterminatedQuoteThrows) EXPECT_THROW(settings.load_parameters_from_file(tmp_path), cuopt::logic_error); } -} // namespace cuopt::linear_programming::test +} // namespace cuopt::mathematical_optimization::test diff --git a/cpp/tests/mip/incumbent_callback_test.cu b/cpp/tests/mip/incumbent_callback_test.cu index 2dce940f73..f9d6b1445b 100644 --- a/cpp/tests/mip/incumbent_callback_test.cu +++ b/cpp/tests/mip/incumbent_callback_test.cu @@ -8,9 +8,9 @@ #include "../linear_programming/utilities/pdlp_test_utilities.cuh" #include "mip_utils.cuh" -#include -#include -#include +#include +#include +#include #include #include @@ -32,7 +32,7 @@ #include #include -namespace cuopt::linear_programming::test { +namespace cuopt::mathematical_optimization::test { class test_set_solution_callback_t : public cuopt::internals::set_solution_callback_t { public: @@ -89,9 +89,10 @@ class test_get_solution_callback_t : public cuopt::internals::get_solution_callb int n_variables; }; -void check_solutions(const test_get_solution_callback_t& get_solution_callback, - const cuopt::linear_programming::io::mps_data_model_t& op_problem, - const cuopt::linear_programming::mip_solver_settings_t& settings) +void check_solutions( + const test_get_solution_callback_t& get_solution_callback, + const cuopt::mathematical_optimization::io::mps_data_model_t& op_problem, + const cuopt::mathematical_optimization::mip_solver_settings_t& settings) { for (const auto& solution : get_solution_callback.solutions) { EXPECT_EQ(solution.first.size(), op_problem.get_variable_lower_bounds().size()); @@ -112,8 +113,8 @@ void test_incumbent_callback(std::string test_instance, bool include_set_callbac const raft::handle_t handle_{}; std::cout << "Running: " << test_instance << std::endl; auto path = make_path_absolute(test_instance); - cuopt::linear_programming::io::mps_data_model_t mps_problem = - cuopt::linear_programming::io::read_mps(path, false); + cuopt::mathematical_optimization::io::mps_data_model_t mps_problem = + cuopt::mathematical_optimization::io::read_mps(path, false); handle_.sync_stream(); auto op_problem = mps_data_model_to_optimization_problem(&handle_, mps_problem); @@ -164,8 +165,8 @@ TEST(mip_solve, early_heuristic_incumbent_fallback) const raft::handle_t handle_{}; auto path = make_path_absolute("mip/pk1.mps"); - cuopt::linear_programming::io::mps_data_model_t mps_problem = - cuopt::linear_programming::io::read_mps(path, false); + cuopt::mathematical_optimization::io::mps_data_model_t mps_problem = + cuopt::mathematical_optimization::io::read_mps(path, false); handle_.sync_stream(); auto op_problem = mps_data_model_to_optimization_problem(&handle_, mps_problem); @@ -194,4 +195,4 @@ TEST(mip_solve, early_heuristic_incumbent_fallback) if (!callback_solutions.empty()) { check_solutions(get_cb, mps_problem, settings); } } -} // namespace cuopt::linear_programming::test +} // namespace cuopt::mathematical_optimization::test diff --git a/cpp/tests/mip/integer_with_real_bounds.cu b/cpp/tests/mip/integer_with_real_bounds.cu index 2e526f7801..a205ba4834 100644 --- a/cpp/tests/mip/integer_with_real_bounds.cu +++ b/cpp/tests/mip/integer_with_real_bounds.cu @@ -8,20 +8,20 @@ #include "../linear_programming/utilities/pdlp_test_utilities.cuh" #include "mip_utils.cuh" -#include -#include +#include +#include #include #include -namespace cuopt::linear_programming::test { +namespace cuopt::mathematical_optimization::test { TEST(mip_solve, integer_with_real_bounds_test) { auto time_limit = 1; auto heuristics_only = true; - auto presolver = cuopt::linear_programming::presolver_t::None; + auto presolver = cuopt::mathematical_optimization::presolver_t::None; auto [termination_status, obj_val, lb] = test_mps_file("mip/integer-with-real-bounds.mps", time_limit, heuristics_only, presolver); EXPECT_EQ(termination_status, mip_termination_status_t::Optimal); EXPECT_NEAR(obj_val, 4, 1e-5); } -} // namespace cuopt::linear_programming::test +} // namespace cuopt::mathematical_optimization::test diff --git a/cpp/tests/mip/load_balancing_test.cu b/cpp/tests/mip/load_balancing_test.cu index afdc275e15..c686388aad 100644 --- a/cpp/tests/mip/load_balancing_test.cu +++ b/cpp/tests/mip/load_balancing_test.cu @@ -9,7 +9,7 @@ #include "mip_utils.cuh" #include -#include +#include #include #include #include @@ -30,7 +30,7 @@ #include #include -namespace cuopt::linear_programming::test { +namespace cuopt::mathematical_optimization::test { inline auto make_async() { return rmm::mr::cuda_async_memory_resource(); } @@ -44,7 +44,7 @@ void init_handler(const raft::handle_t* handle_ptr) } std::tuple, std::vector, std::vector> select_k_random( - detail::problem_t& problem, int sample_size) + mip::problem_t& problem, int sample_size) { auto seed = std::random_device{}(); std::cerr << "Tested with seed " << seed << "\n"; @@ -90,9 +90,9 @@ convert_probe_tuple(std::tuple, std::vector, std::vecto } std::tuple, std::vector, std::vector, std::vector> -bounds_probe_results(detail::bound_presolve_t& bnd_prb_0, - detail::bound_presolve_t& bnd_prb_1, - detail::problem_t& problem, +bounds_probe_results(mip::bound_presolve_t& bnd_prb_0, + mip::bound_presolve_t& bnd_prb_1, + mip::problem_t& problem, const std::pair>, std::vector>>& probe) { @@ -121,19 +121,19 @@ void test_multi_probe(std::string path) auto memory_resource = make_async(); rmm::mr::set_current_device_resource(memory_resource); const raft::handle_t handle_{}; - cuopt::linear_programming::io::mps_data_model_t mps_problem = - cuopt::linear_programming::io::read_mps(path, false); + cuopt::mathematical_optimization::io::mps_data_model_t mps_problem = + cuopt::mathematical_optimization::io::read_mps(path, false); handle_.sync_stream(); auto op_problem = mps_data_model_to_optimization_problem(&handle_, mps_problem); problem_checking_t::check_problem_representation(op_problem); - detail::problem_t problem(op_problem); + mip::problem_t problem(op_problem); mip_solver_settings_t default_settings{}; - detail::mip_scaling_strategy_t scaling(problem); - detail::mip_solver_t solver(problem, default_settings, scaling, cuopt::timer_t(0)); - detail::load_balanced_problem_t lb_problem(problem); - detail::load_balanced_bounds_presolve_t lb_prs(lb_problem, solver.context); + mip::mip_scaling_strategy_t scaling(problem); + mip::mip_solver_t solver(problem, default_settings, scaling, cuopt::timer_t(0)); + mip::load_balanced_problem_t lb_problem(problem); + mip::load_balanced_bounds_presolve_t lb_prs(lb_problem, solver.context); - detail::bound_presolve_t bnd_prb(solver.context); + mip::bound_presolve_t bnd_prb(solver.context); auto probe_tuple = select_k_random(problem, 100); auto bounds_probe_vals = convert_probe_tuple(probe_tuple); @@ -168,4 +168,4 @@ TEST(presolve, multi_probe) } } -} // namespace cuopt::linear_programming::test +} // namespace cuopt::mathematical_optimization::test diff --git a/cpp/tests/mip/mip_utils.cuh b/cpp/tests/mip/mip_utils.cuh index 057047cefd..29d4732d42 100644 --- a/cpp/tests/mip/mip_utils.cuh +++ b/cpp/tests/mip/mip_utils.cuh @@ -6,18 +6,18 @@ /* clang-format on */ #include -#include -#include -#include +#include +#include +#include #include #include -namespace cuopt::linear_programming::test { +namespace cuopt::mathematical_optimization::test { static void test_variable_bounds( - const cuopt::linear_programming::io::mps_data_model_t& problem, + const cuopt::mathematical_optimization::io::mps_data_model_t& problem, const rmm::device_uvector& solution, - const cuopt::linear_programming::mip_solver_settings_t settings) + const cuopt::mathematical_optimization::mip_solver_settings_t settings) { const double* lower_bound_ptr = problem.get_variable_lower_bounds().data(); const double* upper_bound_ptr = problem.get_variable_upper_bounds().data(); @@ -43,9 +43,9 @@ static void test_variable_bounds( } static void test_variable_bounds( - const cuopt::linear_programming::io::mps_data_model_t& problem, + const cuopt::mathematical_optimization::io::mps_data_model_t& problem, const std::vector& solution, - const cuopt::linear_programming::mip_solver_settings_t settings) + const cuopt::mathematical_optimization::mip_solver_settings_t settings) { const double* lower_bound_ptr = problem.get_variable_lower_bounds().data(); const double* upper_bound_ptr = problem.get_variable_upper_bounds().data(); @@ -94,7 +94,7 @@ struct violation { }; static void test_constraint_sanity_per_row( - const cuopt::linear_programming::io::mps_data_model_t& op_problem, + const cuopt::mathematical_optimization::io::mps_data_model_t& op_problem, const rmm::device_uvector& solution, double abs_tolerance, double rel_tolerance) @@ -128,7 +128,7 @@ static void test_constraint_sanity_per_row( } static void test_constraint_sanity_per_row( - const cuopt::linear_programming::io::mps_data_model_t& op_problem, + const cuopt::mathematical_optimization::io::mps_data_model_t& op_problem, const std::vector& solution, double abs_tolerance, double rel_tolerance) @@ -167,8 +167,8 @@ static std::tuple test_mps_file( const raft::handle_t handle_{}; auto path = make_path_absolute(test_instance); - cuopt::linear_programming::io::mps_data_model_t problem = - cuopt::linear_programming::io::read_mps(path, false); + cuopt::mathematical_optimization::io::mps_data_model_t problem = + cuopt::mathematical_optimization::io::read_mps(path, false); handle_.sync_stream(); mip_solver_settings_t settings; settings.time_limit = time_limit; @@ -180,4 +180,4 @@ static std::tuple test_mps_file( solution.get_solution_bound()); } -} // namespace cuopt::linear_programming::test +} // namespace cuopt::mathematical_optimization::test diff --git a/cpp/tests/mip/miplib_test.cu b/cpp/tests/mip/miplib_test.cu index 0e255d35a9..924763c437 100644 --- a/cpp/tests/mip/miplib_test.cu +++ b/cpp/tests/mip/miplib_test.cu @@ -7,12 +7,12 @@ #include "../linear_programming/utilities/pdlp_test_utilities.cuh" #include "branch_and_bound/branch_and_bound.hpp" -#include "cuopt/linear_programming/mip/solver_settings.hpp" +#include "cuopt/mathematical_optimization/mip/solver_settings.hpp" #include "dual_simplex/simplex_solver_settings.hpp" #include "mip_utils.cuh" -#include -#include +#include +#include #include #include @@ -26,7 +26,7 @@ #include #include -namespace cuopt::linear_programming::test { +namespace cuopt::mathematical_optimization::test { struct result_map_t { std::string file; @@ -38,8 +38,8 @@ void test_miplib_file(result_map_t test_instance, mip_solver_settings_t problem = - cuopt::linear_programming::io::read_mps(path, false); + cuopt::mathematical_optimization::io::mps_data_model_t problem = + cuopt::mathematical_optimization::io::read_mps(path, false); handle_.sync_stream(); // set the time limit depending on we are in assert mode or not #ifdef ASSERT_MODE @@ -80,8 +80,8 @@ TEST(mip_solve, low_thread_count_test) const raft::handle_t handle_{}; auto path = make_path_absolute("mip/dominating_set.mps"); - cuopt::linear_programming::io::mps_data_model_t problem = - cuopt::linear_programming::io::read_mps(path, false); + cuopt::mathematical_optimization::io::mps_data_model_t problem = + cuopt::mathematical_optimization::io::read_mps(path, false); handle_.sync_stream(); mip_solution_t solution = solve_mip(&handle_, problem, settings); @@ -104,8 +104,8 @@ TEST(mip_solve, node_limit_test) const raft::handle_t handle_{}; auto path = make_path_absolute("mip/swath1.mps"); - cuopt::linear_programming::io::mps_data_model_t problem = - cuopt::linear_programming::io::read_mps(path, false); + cuopt::mathematical_optimization::io::mps_data_model_t problem = + cuopt::mathematical_optimization::io::read_mps(path, false); handle_.sync_stream(); mip_solution_t solution = solve_mip(&handle_, problem, settings); @@ -117,4 +117,4 @@ TEST(mip_solve, node_limit_test) test_variable_bounds(problem, solution.get_solution(), settings); } -} // namespace cuopt::linear_programming::test +} // namespace cuopt::mathematical_optimization::test diff --git a/cpp/tests/mip/multi_probe_test.cu b/cpp/tests/mip/multi_probe_test.cu index b6ffb1e592..d7241f9325 100644 --- a/cpp/tests/mip/multi_probe_test.cu +++ b/cpp/tests/mip/multi_probe_test.cu @@ -9,7 +9,7 @@ #include "mip_utils.cuh" #include -#include +#include #include #include #include @@ -29,7 +29,7 @@ #include #include -namespace cuopt::linear_programming::test { +namespace cuopt::mathematical_optimization::test { inline auto make_async() { return rmm::mr::cuda_async_memory_resource(); } @@ -43,7 +43,7 @@ void init_handler(const raft::handle_t* handle_ptr) } std::tuple, std::vector, std::vector> select_k_random( - detail::problem_t& problem, int sample_size) + mip::problem_t& problem, int sample_size) { auto seed = std::random_device{}(); std::cerr << "Tested with seed " << seed << "\n"; @@ -89,9 +89,9 @@ convert_probe_tuple(std::tuple, std::vector, std::vecto } std::tuple, std::vector, std::vector, std::vector> -bounds_probe_results(detail::bound_presolve_t& bnd_prb_0, - detail::bound_presolve_t& bnd_prb_1, - detail::problem_t& problem, +bounds_probe_results(mip::bound_presolve_t& bnd_prb_0, + mip::bound_presolve_t& bnd_prb_1, + mip::problem_t& problem, const std::pair>, std::vector>>& probe) { @@ -117,8 +117,8 @@ bounds_probe_results(detail::bound_presolve_t& bnd_prb_0, std::tuple, std::vector, std::vector, std::vector> multi_probe_results( - detail::multi_probe_t& prb, - detail::problem_t& problem, + mip::multi_probe_t& prb, + mip::problem_t& problem, const std::tuple, std::vector, std::vector>& probe_tuple) { prb.solve(problem, probe_tuple); @@ -143,17 +143,17 @@ void test_multi_probe(std::string path) auto memory_resource = make_async(); rmm::mr::set_current_device_resource(memory_resource); const raft::handle_t handle_{}; - cuopt::linear_programming::io::mps_data_model_t mps_problem = - cuopt::linear_programming::io::read_mps(path, false); + cuopt::mathematical_optimization::io::mps_data_model_t mps_problem = + cuopt::mathematical_optimization::io::read_mps(path, false); handle_.sync_stream(); auto op_problem = mps_data_model_to_optimization_problem(&handle_, mps_problem); problem_checking_t::check_problem_representation(op_problem); - detail::problem_t problem(op_problem); + mip::problem_t problem(op_problem); mip_solver_settings_t default_settings{}; - detail::mip_solver_t solver(problem, default_settings, cuopt::timer_t(0)); - detail::bound_presolve_t bnd_prb_0(solver.context); - detail::bound_presolve_t bnd_prb_1(solver.context); - detail::multi_probe_t multi_probe_prs(solver.context); + mip::mip_solver_t solver(problem, default_settings, cuopt::timer_t(0)); + mip::bound_presolve_t bnd_prb_0(solver.context); + mip::bound_presolve_t bnd_prb_1(solver.context); + mip::multi_probe_t multi_probe_prs(solver.context); auto probe_tuple = select_k_random(problem, 100); auto bounds_probe_vals = convert_probe_tuple(probe_tuple); @@ -200,4 +200,4 @@ TEST(presolve, multi_probe) } } -} // namespace cuopt::linear_programming::test +} // namespace cuopt::mathematical_optimization::test diff --git a/cpp/tests/mip/presolve_test.cu b/cpp/tests/mip/presolve_test.cu index a400d04854..5d82dcec0a 100644 --- a/cpp/tests/mip/presolve_test.cu +++ b/cpp/tests/mip/presolve_test.cu @@ -7,9 +7,9 @@ #include "../linear_programming/utilities/pdlp_test_utilities.cuh" -#include -#include -#include +#include +#include +#include #include #include #include @@ -27,28 +27,28 @@ #include #include -namespace cuopt::linear_programming::test { +namespace cuopt::mathematical_optimization::test { TEST(problem, find_implied_integers) { const raft::handle_t handle_{}; auto path = make_path_absolute("mip/fiball.mps"); - auto mps_data_model = cuopt::linear_programming::io::read_mps(path, false); + auto mps_data_model = cuopt::mathematical_optimization::io::read_mps(path, false); auto op_problem = mps_data_model_to_optimization_problem(&handle_, mps_data_model); - auto presolver = std::make_unique>(); + auto presolver = std::make_unique>(); auto result = presolver->apply(op_problem, - cuopt::linear_programming::problem_category_t::MIP, - cuopt::linear_programming::presolver_t::Papilo, + cuopt::mathematical_optimization::problem_category_t::MIP, + cuopt::mathematical_optimization::presolver_t::Papilo, false, 1e-6, 1e-12, 20, 1); - ASSERT_NE(result.status, detail::third_party_presolve_status_t::INFEASIBLE); - ASSERT_NE(result.status, detail::third_party_presolve_status_t::UNBNDORINFEAS); + ASSERT_NE(result.status, mip::third_party_presolve_status_t::INFEASIBLE); + ASSERT_NE(result.status, mip::third_party_presolve_status_t::UNBNDORINFEAS); - auto problem = detail::problem_t(result.reduced_problem); + auto problem = mip::problem_t(result.reduced_problem); problem.set_implied_integers(result.implied_integer_indices); ASSERT_TRUE(result.implied_integer_indices.size() > 0); auto var_types = host_copy(problem.variable_types, handle_.get_stream()); @@ -60,7 +60,7 @@ TEST(problem, find_implied_integers) ASSERT_EQ(problem.presolve_data.var_flags.size(), var_types.size()); // Ensure it is an implied integer EXPECT_EQ(problem.presolve_data.var_flags.element(it - var_types.begin(), handle_.get_stream()), - ((int)detail::problem_t::var_flags_t::VAR_IMPLIED_INTEGER)); + ((int)mip::problem_t::var_flags_t::VAR_IMPLIED_INTEGER)); } -} // namespace cuopt::linear_programming::test +} // namespace cuopt::mathematical_optimization::test diff --git a/cpp/tests/mip/problem_test.cu b/cpp/tests/mip/problem_test.cu index ef488eadba..1504df1ad4 100644 --- a/cpp/tests/mip/problem_test.cu +++ b/cpp/tests/mip/problem_test.cu @@ -7,9 +7,9 @@ #include "../linear_programming/utilities/pdlp_test_utilities.cuh" -#include -#include -#include +#include +#include +#include #include #include #include @@ -39,10 +39,10 @@ #include #include -namespace cuopt::linear_programming::test { +namespace cuopt::mathematical_optimization::test { -namespace lp = cuopt::linear_programming; -namespace dtl = cuopt::linear_programming::detail; +namespace lp = cuopt::mathematical_optimization; +namespace dtl = cuopt::mathematical_optimization::mip; template thrust::host_vector rand_vec(i_t size, T dist_beg, T dist_end) @@ -192,7 +192,7 @@ void test_equal_val_bounds(i_t n_cnst, i_t n_var) problem.preprocess_problem(); - detail::trivial_presolve(problem); + mip::trivial_presolve(problem); EXPECT_EQ(selected_vars.size() + problem.n_variables, n_var); } @@ -205,7 +205,7 @@ TEST(problem, run_small_tests) } } -namespace ds = cuopt::linear_programming::dual_simplex; +namespace ds = cuopt::mathematical_optimization::simplex; template void test_roundtrip_equivalence(i_t n_cnst, i_t n_var) @@ -322,7 +322,7 @@ TEST(problem, setting_both_rhs_and_constraints_bounds) raft::handle_t handle; optimization_problem_t op_problem(&handle); fill_problem(op_problem); - cuopt::linear_programming::detail::problem_t problem(op_problem); + cuopt::mathematical_optimization::mip::problem_t problem(op_problem); const auto constraints_lower_bounds = host_copy(problem.constraint_lower_bounds, handle.get_stream()); @@ -342,7 +342,7 @@ TEST(problem, setting_both_rhs_and_constraints_bounds) double upper[] = {3.0}; op_problem.set_constraint_lower_bounds(lower, 1); op_problem.set_constraint_upper_bounds(upper, 1); - cuopt::linear_programming::detail::problem_t problem(op_problem); + cuopt::mathematical_optimization::mip::problem_t problem(op_problem); const auto constraints_lower_bounds = host_copy(problem.constraint_lower_bounds, handle.get_stream()); @@ -362,7 +362,7 @@ TEST(problem, setting_both_rhs_and_constraints_bounds) op_problem.set_constraint_lower_bounds(lower, 1); op_problem.set_constraint_upper_bounds(upper, 1); fill_problem(op_problem); - cuopt::linear_programming::detail::problem_t problem(op_problem); + cuopt::mathematical_optimization::mip::problem_t problem(op_problem); const auto constraints_lower_bounds = host_copy(problem.constraint_lower_bounds, handle.get_stream()); @@ -381,7 +381,7 @@ TEST(optimization_problem_t_DeathTest, test_check_problem_validity) raft::handle_t handle; auto op_problem = optimization_problem_t(&handle); - using custom_problem_t = cuopt::linear_programming::detail::problem_t; + using custom_problem_t = cuopt::mathematical_optimization::mip::problem_t; // Check if assert if nothing EXPECT_DEATH({ custom_problem_t problem(op_problem); }, ""); @@ -484,4 +484,4 @@ TEST(optimization_problem_t_DeathTest, test_check_problem_validity) } #endif -} // namespace cuopt::linear_programming::test +} // namespace cuopt::mathematical_optimization::test diff --git a/cpp/tests/mip/semi_continuous_test.cu b/cpp/tests/mip/semi_continuous_test.cu index ee88eafcbb..168388e948 100644 --- a/cpp/tests/mip/semi_continuous_test.cu +++ b/cpp/tests/mip/semi_continuous_test.cu @@ -5,12 +5,12 @@ */ /* clang-format on */ -#include "cuopt/linear_programming/mip/solver_settings.hpp" +#include "cuopt/mathematical_optimization/mip/solver_settings.hpp" #include "../utilities/inline_lp_test_utils.hpp" #include "../utilities/inline_mps_test_utils.hpp" -#include +#include #include #include @@ -22,7 +22,7 @@ #include #include -namespace cuopt::linear_programming::test { +namespace cuopt::mathematical_optimization::test { struct sc_result_t { std::string name; @@ -142,4 +142,4 @@ TEST(mip_solve, semi_continuous_equal_bounds_supported) } } -} // namespace cuopt::linear_programming::test +} // namespace cuopt::mathematical_optimization::test diff --git a/cpp/tests/mip/server_test.cu b/cpp/tests/mip/server_test.cu index 83cac7e11e..a97c59a450 100644 --- a/cpp/tests/mip/server_test.cu +++ b/cpp/tests/mip/server_test.cu @@ -8,7 +8,7 @@ #include "../linear_programming/utilities/pdlp_test_utilities.cuh" #include "mip_utils.cuh" -#include +#include #include #include @@ -16,7 +16,7 @@ #include -namespace cuopt::linear_programming::test { +namespace cuopt::mathematical_optimization::test { io::mps_data_model_t create_std_lp_problem() { @@ -47,19 +47,19 @@ TEST(ServerTest, TestSampleLP) raft::handle_t handle; auto problem = create_std_lp_problem(); - cuopt::linear_programming::pdlp_solver_settings_t settings{}; + cuopt::mathematical_optimization::pdlp_solver_settings_t settings{}; settings.set_optimality_tolerance(1e-4); settings.set_time_limit(5); - auto result = cuopt::linear_programming::solve_lp(&handle, problem, settings); + auto result = cuopt::mathematical_optimization::solve_lp(&handle, problem, settings); EXPECT_EQ(result.get_termination_status(), - cuopt::linear_programming::pdlp_termination_status_t::Optimal); + cuopt::mathematical_optimization::pdlp_termination_status_t::Optimal); } class MILPTestParams : public testing::TestWithParam< - std::tuple> {}; + std::tuple> {}; TEST_P(MILPTestParams, TestSampleMILP) { @@ -71,12 +71,12 @@ TEST_P(MILPTestParams, TestSampleMILP) raft::handle_t handle; auto problem = create_std_milp_problem(maximize); - cuopt::linear_programming::mip_solver_settings_t settings{}; + cuopt::mathematical_optimization::mip_solver_settings_t settings{}; settings.time_limit = 5; settings.mip_scaling = scaling; settings.heuristics_only = heuristics_only; - auto result = cuopt::linear_programming::solve_mip(&handle, problem, settings); + auto result = cuopt::mathematical_optimization::solve_mip(&handle, problem, settings); EXPECT_EQ(result.get_termination_status(), expected_termination_status); } @@ -88,18 +88,18 @@ INSTANTIATE_TEST_SUITE_P( std::make_tuple(true, CUOPT_MIP_SCALING_ON, true, - cuopt::linear_programming::mip_termination_status_t::FeasibleFound), + cuopt::mathematical_optimization::mip_termination_status_t::FeasibleFound), std::make_tuple(false, CUOPT_MIP_SCALING_ON, false, - cuopt::linear_programming::mip_termination_status_t::Optimal), + cuopt::mathematical_optimization::mip_termination_status_t::Optimal), std::make_tuple(true, CUOPT_MIP_SCALING_OFF, true, - cuopt::linear_programming::mip_termination_status_t::FeasibleFound), + cuopt::mathematical_optimization::mip_termination_status_t::FeasibleFound), std::make_tuple(false, CUOPT_MIP_SCALING_OFF, false, - cuopt::linear_programming::mip_termination_status_t::Optimal))); + cuopt::mathematical_optimization::mip_termination_status_t::Optimal))); -} // namespace cuopt::linear_programming::test +} // namespace cuopt::mathematical_optimization::test diff --git a/cpp/tests/mip/termination_test.cu b/cpp/tests/mip/termination_test.cu index 4874ccfd5d..f73b4d88ae 100644 --- a/cpp/tests/mip/termination_test.cu +++ b/cpp/tests/mip/termination_test.cu @@ -8,8 +8,8 @@ #include "../linear_programming/utilities/pdlp_test_utilities.cuh" #include "mip_utils.cuh" -#include -#include +#include +#include #include #include #include @@ -33,7 +33,7 @@ #include #include -namespace cuopt::linear_programming::test { +namespace cuopt::mathematical_optimization::test { constexpr double default_time_limit = 10; constexpr bool default_heuristics_only = true; @@ -132,4 +132,4 @@ TEST(termination_status, bb_infeasible_test) } } -} // namespace cuopt::linear_programming::test +} // namespace cuopt::mathematical_optimization::test diff --git a/cpp/tests/mip/unit_test.cu b/cpp/tests/mip/unit_test.cu index 9eae3455bb..20865b93ff 100644 --- a/cpp/tests/mip/unit_test.cu +++ b/cpp/tests/mip/unit_test.cu @@ -8,8 +8,8 @@ #include "../linear_programming/utilities/pdlp_test_utilities.cuh" #include "mip_utils.cuh" -#include -#include +#include +#include #include #include #include @@ -20,7 +20,7 @@ #include -namespace cuopt::linear_programming::test { +namespace cuopt::mathematical_optimization::test { io::mps_data_model_t create_std_lp_problem() { @@ -82,17 +82,17 @@ Subject To End )LP"); - cuopt::linear_programming::pdlp_solver_settings_t settings{}; + cuopt::mathematical_optimization::pdlp_solver_settings_t settings{}; settings.set_optimality_tolerance(1e-2); - settings.method = cuopt::linear_programming::method_t::PDLP; + settings.method = cuopt::mathematical_optimization::method_t::PDLP; settings.time_limit = 5; // Solve - auto result = cuopt::linear_programming::solve_lp(&handle, problem, settings); + auto result = cuopt::mathematical_optimization::solve_lp(&handle, problem, settings); // Check results EXPECT_EQ(result.get_termination_status(), - cuopt::linear_programming::pdlp_termination_status_t::Optimal); + cuopt::mathematical_optimization::pdlp_termination_status_t::Optimal); ASSERT_EQ(result.get_primal_solution().size(), 1); // Copy solution to host to access values @@ -108,15 +108,15 @@ TEST(LPTest, TestSampleLP) raft::handle_t handle; auto problem = create_std_lp_problem(); - cuopt::linear_programming::pdlp_solver_settings_t settings{}; + cuopt::mathematical_optimization::pdlp_solver_settings_t settings{}; settings.set_optimality_tolerance(1e-4); settings.time_limit = 5; - settings.presolver = cuopt::linear_programming::presolver_t::None; + settings.presolver = cuopt::mathematical_optimization::presolver_t::None; - auto result = cuopt::linear_programming::solve_lp(&handle, problem, settings); + auto result = cuopt::mathematical_optimization::solve_lp(&handle, problem, settings); EXPECT_EQ(result.get_termination_status(), - cuopt::linear_programming::pdlp_termination_status_t::Optimal); + cuopt::mathematical_optimization::pdlp_termination_status_t::Optimal); } TEST(ErrorTest, TestError) @@ -124,9 +124,9 @@ TEST(ErrorTest, TestError) raft::handle_t handle; auto problem = create_std_milp_problem(false); - cuopt::linear_programming::mip_solver_settings_t settings{}; + cuopt::mathematical_optimization::mip_solver_settings_t settings{}; settings.time_limit = 5; - settings.presolver = cuopt::linear_programming::presolver_t::None; + settings.presolver = cuopt::mathematical_optimization::presolver_t::None; // Set constraint bounds std::vector lower_bounds = {1.0}; @@ -134,15 +134,15 @@ TEST(ErrorTest, TestError) problem.set_constraint_lower_bounds(lower_bounds); problem.set_constraint_upper_bounds(upper_bounds); - auto result = cuopt::linear_programming::solve_mip(&handle, problem, settings); + auto result = cuopt::mathematical_optimization::solve_mip(&handle, problem, settings); EXPECT_EQ(result.get_termination_status(), - cuopt::linear_programming::mip_termination_status_t::NoTermination); + cuopt::mathematical_optimization::mip_termination_status_t::NoTermination); } class MILPTestParams : public testing::TestWithParam< - std::tuple> {}; + std::tuple> {}; TEST_P(MILPTestParams, TestSampleMILP) { @@ -154,13 +154,13 @@ TEST_P(MILPTestParams, TestSampleMILP) raft::handle_t handle; auto problem = create_std_milp_problem(maximize); - cuopt::linear_programming::mip_solver_settings_t settings{}; + cuopt::mathematical_optimization::mip_solver_settings_t settings{}; settings.time_limit = 5; settings.mip_scaling = scaling; settings.heuristics_only = heuristics_only; - settings.presolver = cuopt::linear_programming::presolver_t::None; + settings.presolver = cuopt::mathematical_optimization::presolver_t::None; - auto result = cuopt::linear_programming::solve_mip(&handle, problem, settings); + auto result = cuopt::mathematical_optimization::solve_mip(&handle, problem, settings); EXPECT_EQ(result.get_termination_status(), expected_termination_status); } @@ -175,37 +175,38 @@ TEST_P(MILPTestParams, TestSingleVarMILP) raft::handle_t handle; auto problem = create_single_var_milp_problem(maximize); - cuopt::linear_programming::mip_solver_settings_t settings{}; + cuopt::mathematical_optimization::mip_solver_settings_t settings{}; settings.time_limit = 5; settings.mip_scaling = scaling; settings.heuristics_only = heuristics_only; - settings.presolver = cuopt::linear_programming::presolver_t::None; + settings.presolver = cuopt::mathematical_optimization::presolver_t::None; - auto result = cuopt::linear_programming::solve_mip(&handle, problem, settings); + auto result = cuopt::mathematical_optimization::solve_mip(&handle, problem, settings); EXPECT_EQ(result.get_termination_status(), - cuopt::linear_programming::mip_termination_status_t::Optimal); + cuopt::mathematical_optimization::mip_termination_status_t::Optimal); } INSTANTIATE_TEST_SUITE_P( MILPTests, MILPTestParams, - testing::Values(std::make_tuple(true, - CUOPT_MIP_SCALING_ON, - true, - cuopt::linear_programming::mip_termination_status_t::Optimal), - std::make_tuple(false, - CUOPT_MIP_SCALING_ON, - false, - cuopt::linear_programming::mip_termination_status_t::Optimal), - std::make_tuple(true, - CUOPT_MIP_SCALING_OFF, - true, - cuopt::linear_programming::mip_termination_status_t::Optimal), - std::make_tuple(false, - CUOPT_MIP_SCALING_OFF, - false, - cuopt::linear_programming::mip_termination_status_t::Optimal))); + testing::Values( + std::make_tuple(true, + CUOPT_MIP_SCALING_ON, + true, + cuopt::mathematical_optimization::mip_termination_status_t::Optimal), + std::make_tuple(false, + CUOPT_MIP_SCALING_ON, + false, + cuopt::mathematical_optimization::mip_termination_status_t::Optimal), + std::make_tuple(true, + CUOPT_MIP_SCALING_OFF, + true, + cuopt::mathematical_optimization::mip_termination_status_t::Optimal), + std::make_tuple(false, + CUOPT_MIP_SCALING_OFF, + false, + cuopt::mathematical_optimization::mip_termination_status_t::Optimal))); // --------------------------------------------------------------------------- // Scaling integrality preservation test @@ -267,7 +268,7 @@ TEST(ScalingIntegrity, IntegerCoefficientsPreservedAfterScaling) } } - detail::mip_scaling_strategy_t scaling(op_problem); + mip::mip_scaling_strategy_t scaling(op_problem); scaling.scale_problem(); auto post_values = @@ -318,7 +319,7 @@ TEST(ScalingIntegrity, NoObjectiveScalingPreservesIntegerCoefficients) } } - detail::mip_scaling_strategy_t scaling(op_problem); + mip::mip_scaling_strategy_t scaling(op_problem); scaling.scale_problem(/*scale_objective=*/false); auto post_values = @@ -337,4 +338,4 @@ TEST(ScalingIntegrity, NoObjectiveScalingPreservesIntegerCoefficients) << " integer coefficients lost integrality after scaling (no-obj mode)"; } -} // namespace cuopt::linear_programming::test +} // namespace cuopt::mathematical_optimization::test diff --git a/cpp/tests/qp/unit_tests/lp_parser_solve_test.cu b/cpp/tests/qp/unit_tests/lp_parser_solve_test.cu index 31b65e3a9b..98b3675b0a 100644 --- a/cpp/tests/qp/unit_tests/lp_parser_solve_test.cu +++ b/cpp/tests/qp/unit_tests/lp_parser_solve_test.cu @@ -6,10 +6,10 @@ #include #include -#include -#include -#include -#include +#include +#include +#include +#include #include #include @@ -21,7 +21,7 @@ #include #include -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { // End-to-end smoke tests that parse an LP file and solve via PDLP. // Validates objective value and primal solution against hand-computed @@ -118,4 +118,4 @@ End {4.0, 2.0}); } -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/tests/qp/unit_tests/mps_writer_test.cpp b/cpp/tests/qp/unit_tests/mps_writer_test.cpp index 62951ccb9b..feae3985ea 100644 --- a/cpp/tests/qp/unit_tests/mps_writer_test.cpp +++ b/cpp/tests/qp/unit_tests/mps_writer_test.cpp @@ -13,8 +13,8 @@ #include -#include -#include +#include +#include #include @@ -136,8 +136,9 @@ void setup_two_var_unconstrained_qp(Op& op) op.set_variable_lower_bounds(lb_host, 2); op.set_variable_upper_bounds(ub_host, 2); - cuopt::linear_programming::var_t const var_types_host[] = { - cuopt::linear_programming::var_t::CONTINUOUS, cuopt::linear_programming::var_t::CONTINUOUS}; + cuopt::mathematical_optimization::var_t const var_types_host[] = { + cuopt::mathematical_optimization::var_t::CONTINUOUS, + cuopt::mathematical_optimization::var_t::CONTINUOUS}; op.set_variable_types(var_types_host, 2); double c_host[] = {0.0, 0.0}; @@ -160,10 +161,10 @@ void setup_three_var_unconstrained_qp(Op& op) op.set_variable_lower_bounds(lb_host, 3); op.set_variable_upper_bounds(ub_host, 3); - cuopt::linear_programming::var_t const var_types_host[] = { - cuopt::linear_programming::var_t::CONTINUOUS, - cuopt::linear_programming::var_t::CONTINUOUS, - cuopt::linear_programming::var_t::CONTINUOUS}; + cuopt::mathematical_optimization::var_t const var_types_host[] = { + cuopt::mathematical_optimization::var_t::CONTINUOUS, + cuopt::mathematical_optimization::var_t::CONTINUOUS, + cuopt::mathematical_optimization::var_t::CONTINUOUS}; op.set_variable_types(var_types_host, 3); double c_host[] = {0.0, 0.0, 0.0}; @@ -172,7 +173,7 @@ void setup_three_var_unconstrained_qp(Op& op) } // namespace -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { TEST(mps_writer_op, write_to_mps_diagonal_qp_quadobj_matches_symmetrized_hessian) { @@ -257,4 +258,4 @@ TEST(mps_writer_op, write_to_mps_nonsymmetric_Q_quadobj_matches_Q_plus_Q_transpo } } -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/tests/qp/unit_tests/no_constraints.cu b/cpp/tests/qp/unit_tests/no_constraints.cu index b2c494e963..e138fa9719 100644 --- a/cpp/tests/qp/unit_tests/no_constraints.cu +++ b/cpp/tests/qp/unit_tests/no_constraints.cu @@ -7,14 +7,14 @@ #include #include -#include -#include +#include +#include #include #include -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { TEST(no_constraints_test, simple_test) { @@ -40,4 +40,4 @@ End EXPECT_NEAR(sol_vec[1], 0.0, 1e-6); } -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/tests/qp/unit_tests/two_variable_test.cu b/cpp/tests/qp/unit_tests/two_variable_test.cu index 6d4ee39a5d..89cb2b40b8 100644 --- a/cpp/tests/qp/unit_tests/two_variable_test.cu +++ b/cpp/tests/qp/unit_tests/two_variable_test.cu @@ -8,14 +8,14 @@ #include #include -#include -#include +#include +#include #include #include -namespace cuopt::linear_programming { +namespace cuopt::mathematical_optimization { TEST(two_variable_test, simple_test) { @@ -44,4 +44,4 @@ End EXPECT_NEAR(sol_vec[1], 2.0, 1e-6); } -} // namespace cuopt::linear_programming +} // namespace cuopt::mathematical_optimization diff --git a/cpp/tests/socp/general_quadratic_test.cu b/cpp/tests/socp/general_quadratic_test.cu index 2918d80a7d..870c1b62ae 100644 --- a/cpp/tests/socp/general_quadratic_test.cu +++ b/cpp/tests/socp/general_quadratic_test.cu @@ -8,7 +8,7 @@ #include #include -#include +#include #include #include #include @@ -19,7 +19,16 @@ #include #include -namespace cuopt::linear_programming::detail::test { +namespace cuopt::mathematical_optimization::barrier::test { + +using simplex::csr_matrix_t; +using simplex::inf; +using simplex::lp_solution_t; +using simplex::lp_status_t; +using simplex::simplex_solver_settings_t; +using simplex::solve_linear_program_with_barrier; +using simplex::user_problem_t; +using simplex::variable_type_t; using i_t = int; using f_t = double; @@ -46,7 +55,6 @@ TEST(general_quadratic, dense_pd_2x2_solve) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::linear_programming::dual_simplex; user_problem_t user_problem(&handle); // Need at least one linear constraint for the barrier solver. @@ -91,7 +99,7 @@ TEST(general_quadratic, dense_pd_2x2_solve) qc.vals = {2.0, 1.0, 2.0}; // Convert to CSR for translation (must include the linear constraint row) - dual_simplex::csr_matrix_t csr_A(m, n, nz); + csr_matrix_t csr_A(m, n, nz); csr_A.m = m; csr_A.n = n; csr_A.row_start = {0, 2}; @@ -159,7 +167,6 @@ TEST(general_quadratic, rejects_non_convex) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::linear_programming::dual_simplex; user_problem_t user_problem(&handle); constexpr int m = 0; @@ -194,7 +201,7 @@ TEST(general_quadratic, rejects_non_convex) qc.cols = {0, 0, 1}; qc.vals = {1.0, 4.0, 1.0}; - dual_simplex::csr_matrix_t csr_A(m, n, nz); + csr_matrix_t csr_A(m, n, nz); csr_A.m = m; csr_A.n = n; csr_A.row_start = {0}; @@ -217,7 +224,6 @@ TEST(general_quadratic, rank_deficient_psd_solve) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::linear_programming::dual_simplex; user_problem_t user_problem(&handle); constexpr int m = 1; @@ -257,7 +263,7 @@ TEST(general_quadratic, rank_deficient_psd_solve) qc.cols = {0, 0, 1}; qc.vals = {1.0, 2.0, 1.0}; - dual_simplex::csr_matrix_t csr_A(m, n, nz); + csr_matrix_t csr_A(m, n, nz); csr_A.m = m; csr_A.n = n; csr_A.row_start = {0, 2}; @@ -302,7 +308,6 @@ TEST(general_quadratic, with_inequality_constraint) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::linear_programming::dual_simplex; user_problem_t user_problem(&handle); // 2 constraints: one equality, one inequality @@ -348,7 +353,7 @@ TEST(general_quadratic, with_inequality_constraint) qc.vals = {2.0, 1.0, 2.0}; // Build CSR matching the A matrix - dual_simplex::csr_matrix_t csr_A(m, n, nz); + csr_matrix_t csr_A(m, n, nz); csr_A.m = m; csr_A.n = n; csr_A.row_start = {0, 2, 4}; @@ -400,7 +405,6 @@ TEST(general_quadratic, least_squares_b_in_range) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::linear_programming::dual_simplex; user_problem_t user_problem(&handle); // Variables: x0, x1, u (u = t - b^T*b = t - 5). @@ -460,7 +464,7 @@ TEST(general_quadratic, least_squares_b_in_range) qc.linear_indices = {0, 1, 2}; // Build CSR with the linear constraint: x0 + x1 = 2 - dual_simplex::csr_matrix_t csr_A(m, n, nz); + csr_matrix_t csr_A(m, n, nz); csr_A.m = m; csr_A.n = n; csr_A.row_start = {0, 2}; @@ -519,7 +523,6 @@ TEST(general_quadratic, least_squares_b_not_in_range) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::linear_programming::dual_simplex; user_problem_t user_problem(&handle); constexpr int m = 1; @@ -562,7 +565,7 @@ TEST(general_quadratic, least_squares_b_not_in_range) qc.linear_indices = {0, 1, 2}; // Build CSR: x0 + x1 = 2 - dual_simplex::csr_matrix_t csr_A(m, n, nz); + csr_matrix_t csr_A(m, n, nz); csr_A.m = m; csr_A.n = n; csr_A.row_start = {0, 2}; @@ -592,7 +595,6 @@ TEST(general_quadratic, soc_head_nonneg_accepted) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::linear_programming::dual_simplex; user_problem_t user_problem(&handle); // Variables: x0, x1, t. Constraint: x0^2 + x1^2 - t^2 <= 0 @@ -637,7 +639,7 @@ TEST(general_quadratic, soc_head_nonneg_accepted) qc.cols = {0, 1, 2}; qc.vals = {1.0, 1.0, -1.0}; - dual_simplex::csr_matrix_t csr_A(m, n, 1); + csr_matrix_t csr_A(m, n, 1); csr_A.m = m; csr_A.n = n; csr_A.row_start = {0, 1}; @@ -659,7 +661,6 @@ TEST(general_quadratic, soc_head_free_rejected) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::linear_programming::dual_simplex; user_problem_t user_problem(&handle); constexpr int m = 1; @@ -695,7 +696,7 @@ TEST(general_quadratic, soc_head_free_rejected) qc.cols = {0, 1, 2}; qc.vals = {1.0, 1.0, -1.0}; - dual_simplex::csr_matrix_t csr_A(m, n, nz); + csr_matrix_t csr_A(m, n, nz); csr_A.m = m; csr_A.n = n; csr_A.row_start = {0, 1}; @@ -715,7 +716,6 @@ TEST(general_quadratic, rotated_soc_heads_nonneg_accepted) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::linear_programming::dual_simplex; user_problem_t user_problem(&handle); // Variables: x0, x1, y, z. Constraint: x0^2 + x1^2 - 2*y*z <= 0 @@ -753,7 +753,7 @@ TEST(general_quadratic, rotated_soc_heads_nonneg_accepted) qc.cols = {0, 1, 3, 2}; qc.vals = {1.0, 1.0, -1.0, -1.0}; - dual_simplex::csr_matrix_t csr_A(m, n, nz); + csr_matrix_t csr_A(m, n, nz); csr_A.m = m; csr_A.n = n; csr_A.row_start = {0, 1}; @@ -774,7 +774,6 @@ TEST(general_quadratic, rotated_soc_heads_free_rejected) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::linear_programming::dual_simplex; user_problem_t user_problem(&handle); constexpr int m = 1; @@ -810,7 +809,7 @@ TEST(general_quadratic, rotated_soc_heads_free_rejected) qc.cols = {0, 1, 3, 2}; qc.vals = {1.0, 1.0, -1.0, -1.0}; - dual_simplex::csr_matrix_t csr_A(m, n, nz); + csr_matrix_t csr_A(m, n, nz); csr_A.m = m; csr_A.n = n; csr_A.row_start = {0, 1}; @@ -824,4 +823,4 @@ TEST(general_quadratic, rotated_soc_heads_free_rejected) cuopt::logic_error); } -} // namespace cuopt::linear_programming::detail::test +} // namespace cuopt::mathematical_optimization::barrier::test diff --git a/cpp/tests/socp/second_order_cone_kernels.cu b/cpp/tests/socp/second_order_cone_kernels.cu index 49126ee335..92ac515bf3 100644 --- a/cpp/tests/socp/second_order_cone_kernels.cu +++ b/cpp/tests/socp/second_order_cone_kernels.cu @@ -16,7 +16,7 @@ #include #include -namespace cuopt::linear_programming::dual_simplex::test { +namespace cuopt::mathematical_optimization::barrier::test { TEST(second_order_cone_kernels, topology_and_scratch_layout) { @@ -581,4 +581,4 @@ TEST(second_order_cone_kernels, combined_cone_rhs_matches_host_reference) } } -} // namespace cuopt::linear_programming::dual_simplex::test +} // namespace cuopt::mathematical_optimization::barrier::test diff --git a/cpp/tests/socp/solve_barrier_socp.cu b/cpp/tests/socp/solve_barrier_socp.cu index f960c3dc3a..8a5792185c 100644 --- a/cpp/tests/socp/solve_barrier_socp.cu +++ b/cpp/tests/socp/solve_barrier_socp.cu @@ -7,8 +7,8 @@ #include -#include -#include +#include +#include #include #include #include @@ -20,7 +20,7 @@ #include #include -namespace cuopt::linear_programming::dual_simplex::test { +namespace cuopt::mathematical_optimization::simplex::test { // This serves as both a warm up but also a mandatory initial call to setup cuSparse and cuBLAS static void init_handler(const raft::handle_t* handle_ptr) @@ -37,7 +37,6 @@ TEST(barrier, cone_metadata_reindexed_when_slack_is_inserted_before_cones) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::linear_programming::dual_simplex; user_problem_t user_problem(&handle); constexpr int m = 1; @@ -98,7 +97,6 @@ TEST(barrier, presolve_reindexes_cone_start_after_empty_column_removal) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::linear_programming::dual_simplex; user_problem_t user_problem(&handle); constexpr int m = 1; @@ -167,7 +165,6 @@ TEST(barrier, presolve_keeps_direct_free_variables_before_cones) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::linear_programming::dual_simplex; user_problem_t user_problem(&handle); constexpr int m = 1; @@ -230,7 +227,6 @@ TEST(barrier, rejects_middle_cone_input_before_barrier) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::linear_programming::dual_simplex; user_problem_t user_problem(&handle); constexpr int m = 3; @@ -282,7 +278,6 @@ TEST(barrier, socp_min_x0_subject_to_norm_constraint) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::linear_programming::dual_simplex; user_problem_t user_problem(&handle); constexpr int m = 1; @@ -343,7 +338,6 @@ TEST(barrier, mixed_linear_and_soc_block) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::linear_programming::dual_simplex; user_problem_t user_problem(&handle); constexpr int m = 2; @@ -409,7 +403,6 @@ TEST(barrier, mixed_linear_and_soc_tail_coupling) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::linear_programming::dual_simplex; user_problem_t user_problem(&handle); constexpr int m = 2; @@ -476,7 +469,6 @@ TEST(barrier, mixed_linear_and_soc_tail_coupling_with_inequality) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::linear_programming::dual_simplex; user_problem_t user_problem(&handle); constexpr int m = 2; @@ -546,7 +538,6 @@ TEST(barrier, mixed_linear_and_two_soc_blocks) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::linear_programming::dual_simplex; user_problem_t user_problem(&handle); constexpr int m = 4; @@ -627,7 +618,6 @@ TEST(barrier, mixed_linear_and_two_soc_blocks_with_inequality) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::linear_programming::dual_simplex; user_problem_t user_problem(&handle); constexpr int m = 4; @@ -707,7 +697,6 @@ TEST(barrier, free_linear_prefix_is_uncrushed_correctly_with_soc_block) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::linear_programming::dual_simplex; user_problem_t user_problem(&handle); constexpr int m = 2; @@ -771,7 +760,6 @@ TEST(barrier, qp_with_soc_block) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::linear_programming::dual_simplex; user_problem_t user_problem(&handle); constexpr int m = 1; @@ -824,4 +812,4 @@ TEST(barrier, qp_with_soc_block) EXPECT_NEAR(std::abs(solution.x[3]), 0.0, 1e-4); } -} // namespace cuopt::linear_programming::dual_simplex::test +} // namespace cuopt::mathematical_optimization::simplex::test diff --git a/cpp/tests/utilities/inline_lp_test_utils.hpp b/cpp/tests/utilities/inline_lp_test_utils.hpp index c0149dc11b..574af11e28 100644 --- a/cpp/tests/utilities/inline_lp_test_utils.hpp +++ b/cpp/tests/utilities/inline_lp_test_utils.hpp @@ -7,16 +7,16 @@ #pragma once -#include +#include #include namespace cuopt::test { -inline cuopt::linear_programming::io::mps_data_model_t parse_inline_lp( +inline cuopt::mathematical_optimization::io::mps_data_model_t parse_inline_lp( std::string_view lp_text) { - return cuopt::linear_programming::io::read_lp_from_string(lp_text); + return cuopt::mathematical_optimization::io::read_lp_from_string(lp_text); } } // namespace cuopt::test diff --git a/cpp/tests/utilities/inline_mps_test_utils.hpp b/cpp/tests/utilities/inline_mps_test_utils.hpp index 6f0370357b..57333a1048 100644 --- a/cpp/tests/utilities/inline_mps_test_utils.hpp +++ b/cpp/tests/utilities/inline_mps_test_utils.hpp @@ -7,7 +7,7 @@ #pragma once -#include +#include #include @@ -101,10 +101,10 @@ BOUNDS ENDATA )"; -inline cuopt::linear_programming::io::mps_data_model_t parse_inline_mps( +inline cuopt::mathematical_optimization::io::mps_data_model_t parse_inline_mps( std::string_view mps_text) { - return cuopt::linear_programming::io::read_mps_from_string(mps_text, false); + return cuopt::mathematical_optimization::io::read_mps_from_string(mps_text, false); } } // namespace cuopt::test::inline_mps diff --git a/docs/cuopt/source/cuopt-c/convex/convex-examples.rst b/docs/cuopt/source/cuopt-c/convex/convex-examples.rst index daca140b02..562b918c6d 100644 --- a/docs/cuopt/source/cuopt-c/convex/convex-examples.rst +++ b/docs/cuopt/source/cuopt-c/convex/convex-examples.rst @@ -154,7 +154,7 @@ used — it dispatches on the file extension (case-insensitive): ``.lp`` / ``.lp.gz`` / ``.lp.bz2`` → LP parser; ``.mps`` / ``.qps`` and their ``.gz`` / ``.bz2`` variants → MPS parser; unknown extensions are rejected. See the ``read_lp`` declaration in -``cuopt/linear_programming/io/parser.hpp`` for the supported subset of +``cuopt/mathematical_optimization/io/parser.hpp`` for the supported subset of the LP format. The example code is available at ``examples/cuopt-c/lp/lp_file_example.c`` (:download:`download `): diff --git a/docs/cuopt/source/cuopt-c/convex/examples/general_quadratic_example.c b/docs/cuopt/source/cuopt-c/convex/examples/general_quadratic_example.c index 69d7ce77a6..cf009ae451 100644 --- a/docs/cuopt/source/cuopt-c/convex/examples/general_quadratic_example.c +++ b/docs/cuopt/source/cuopt-c/convex/examples/general_quadratic_example.c @@ -28,7 +28,7 @@ * ./general_quadratic_example */ -#include +#include #include #include diff --git a/docs/cuopt/source/cuopt-c/convex/examples/lp_file_example.c b/docs/cuopt/source/cuopt-c/convex/examples/lp_file_example.c index 43a8fd7502..bffbb0d431 100644 --- a/docs/cuopt/source/cuopt-c/convex/examples/lp_file_example.c +++ b/docs/cuopt/source/cuopt-c/convex/examples/lp_file_example.c @@ -33,7 +33,7 @@ * ./lp_file_example sample.lp */ -#include +#include #include #include diff --git a/docs/cuopt/source/cuopt-c/convex/examples/mps_file_example.c b/docs/cuopt/source/cuopt-c/convex/examples/mps_file_example.c index b04d327d9c..151f44eaac 100644 --- a/docs/cuopt/source/cuopt-c/convex/examples/mps_file_example.c +++ b/docs/cuopt/source/cuopt-c/convex/examples/mps_file_example.c @@ -38,7 +38,7 @@ * ./mps_file_example sample.mps */ -#include +#include #include #include diff --git a/docs/cuopt/source/cuopt-c/convex/examples/rotated_socp_example.c b/docs/cuopt/source/cuopt-c/convex/examples/rotated_socp_example.c index 0205370570..a62a930756 100644 --- a/docs/cuopt/source/cuopt-c/convex/examples/rotated_socp_example.c +++ b/docs/cuopt/source/cuopt-c/convex/examples/rotated_socp_example.c @@ -28,7 +28,7 @@ * ./rotated_socp_example */ -#include +#include #include #include diff --git a/docs/cuopt/source/cuopt-c/convex/examples/simple_lp_example.c b/docs/cuopt/source/cuopt-c/convex/examples/simple_lp_example.c index 977a173c7b..7c27de8ef6 100644 --- a/docs/cuopt/source/cuopt-c/convex/examples/simple_lp_example.c +++ b/docs/cuopt/source/cuopt-c/convex/examples/simple_lp_example.c @@ -29,7 +29,7 @@ */ // Include the cuOpt linear programming solver header -#include +#include #include #include diff --git a/docs/cuopt/source/cuopt-c/convex/examples/simple_qp_example.c b/docs/cuopt/source/cuopt-c/convex/examples/simple_qp_example.c index 77b3f21f10..29b64e5fa2 100644 --- a/docs/cuopt/source/cuopt-c/convex/examples/simple_qp_example.c +++ b/docs/cuopt/source/cuopt-c/convex/examples/simple_qp_example.c @@ -22,7 +22,7 @@ */ // Include the cuOpt linear programming solver header -#include +#include #include #include diff --git a/docs/cuopt/source/cuopt-c/convex/examples/simple_socp_example.c b/docs/cuopt/source/cuopt-c/convex/examples/simple_socp_example.c index d078e3eec8..b986ba3ca2 100644 --- a/docs/cuopt/source/cuopt-c/convex/examples/simple_socp_example.c +++ b/docs/cuopt/source/cuopt-c/convex/examples/simple_socp_example.c @@ -26,7 +26,7 @@ * ./simple_socp_example */ -#include +#include #include #include diff --git a/docs/cuopt/source/cuopt-c/mip/examples/milp_mps_example.c b/docs/cuopt/source/cuopt-c/mip/examples/milp_mps_example.c index 82109492a7..8e01c9ae24 100644 --- a/docs/cuopt/source/cuopt-c/mip/examples/milp_mps_example.c +++ b/docs/cuopt/source/cuopt-c/mip/examples/milp_mps_example.c @@ -6,7 +6,7 @@ * Example program for solving MPS files with cuOpt MILP solver */ -#include +#include #include #include diff --git a/docs/cuopt/source/cuopt-c/mip/examples/simple_milp_example.c b/docs/cuopt/source/cuopt-c/mip/examples/simple_milp_example.c index 401c87a2dc..06b9e8ca02 100644 --- a/docs/cuopt/source/cuopt-c/mip/examples/simple_milp_example.c +++ b/docs/cuopt/source/cuopt-c/mip/examples/simple_milp_example.c @@ -7,7 +7,7 @@ */ // Include the cuOpt linear programming solver header -#include +#include #include #include diff --git a/docs/cuopt/source/cuopt-cli/cli-examples.rst b/docs/cuopt/source/cuopt-cli/cli-examples.rst index 1a4f813b2e..62e794285b 100644 --- a/docs/cuopt/source/cuopt-cli/cli-examples.rst +++ b/docs/cuopt/source/cuopt-cli/cli-examples.rst @@ -14,7 +14,7 @@ format is dispatched automatically from the file extension Any other extension (including no extension) is rejected with an error listing the supported suffixes. See ``read`` in -``cuopt/linear_programming/io/parser.hpp`` (and the Python +``cuopt/mathematical_optimization/io/parser.hpp`` (and the Python :func:`~cuopt.linear_programming.io.Read` wrapper). diff --git a/python/cuopt/cuopt/linear_programming/data_model/data_model.pxd b/python/cuopt/cuopt/linear_programming/data_model/data_model.pxd index 761fbb5dd6..b734a17ec5 100644 --- a/python/cuopt/cuopt/linear_programming/data_model/data_model.pxd +++ b/python/cuopt/cuopt/linear_programming/data_model/data_model.pxd @@ -13,7 +13,7 @@ from libcpp.string cimport string from libcpp.vector cimport vector -cdef extern from "cuopt/linear_programming/io/mps_data_model.hpp" namespace "cuopt::linear_programming::io" nogil: # noqa +cdef extern from "cuopt/mathematical_optimization/io/mps_data_model.hpp" namespace "cuopt::mathematical_optimization::io" nogil: # noqa cdef cppclass mps_data_model_t[i_t, f_t]: cppclass quadratic_constraint_t: @@ -28,7 +28,7 @@ cdef extern from "cuopt/linear_programming/io/mps_data_model.hpp" namespace "cuo vector[double] vals -cdef extern from "cuopt/linear_programming/io/data_model_view.hpp" namespace "cuopt::linear_programming::io" nogil: # noqa +cdef extern from "cuopt/mathematical_optimization/io/data_model_view.hpp" namespace "cuopt::mathematical_optimization::io" nogil: # noqa cdef cppclass data_model_view_t[i_t, f_t]: void set_maximize(bool maximize) except + @@ -74,7 +74,7 @@ cdef extern from "cuopt/linear_programming/io/data_model_view.hpp" namespace "cu vector[mps_data_model_t[i_t, f_t].quadratic_constraint_t] constraints) except + -cdef extern from "cuopt/linear_programming/io/writer.hpp" namespace "cuopt::linear_programming::io" nogil: # noqa +cdef extern from "cuopt/mathematical_optimization/io/writer.hpp" namespace "cuopt::mathematical_optimization::io" nogil: # noqa cdef void write_mps( const data_model_view_t[int, double] data_model, diff --git a/python/cuopt/cuopt/linear_programming/internals/internals.pyx b/python/cuopt/cuopt/linear_programming/internals/internals.pyx index 1f44b5d9d2..aaa50cc6ad 100644 --- a/python/cuopt/cuopt/linear_programming/internals/internals.pyx +++ b/python/cuopt/cuopt/linear_programming/internals/internals.pyx @@ -14,7 +14,7 @@ import ctypes import numpy as np -cdef extern from "cuopt/linear_programming/utilities/callbacks_implems.hpp" namespace "cuopt::internals": # noqa +cdef extern from "cuopt/mathematical_optimization/utilities/callbacks_implems.hpp" namespace "cuopt::internals": # noqa cdef cppclass Callback: pass diff --git a/python/cuopt/cuopt/linear_programming/io/parser.pxd b/python/cuopt/cuopt/linear_programming/io/parser.pxd index 947c6cb2a0..5c55ec7859 100644 --- a/python/cuopt/cuopt/linear_programming/io/parser.pxd +++ b/python/cuopt/cuopt/linear_programming/io/parser.pxd @@ -12,7 +12,7 @@ from libcpp.string cimport string from libcpp.vector cimport vector -cdef extern from "cuopt/linear_programming/io/mps_data_model.hpp" namespace "cuopt::linear_programming::io": # noqa +cdef extern from "cuopt/mathematical_optimization/io/mps_data_model.hpp" namespace "cuopt::mathematical_optimization::io": # noqa cdef cppclass mps_data_model_t[i_t, f_t]: cppclass quadratic_constraint_t: @@ -49,7 +49,7 @@ cdef extern from "cuopt/linear_programming/io/mps_data_model.hpp" namespace "cuo string problem_name_ const vector[quadratic_constraint_t]& get_quadratic_constraints() const -cdef extern from "cuopt/linear_programming/io/utilities/cython_parser.hpp" namespace "cuopt::cython": # noqa +cdef extern from "cuopt/mathematical_optimization/io/utilities/cython_parser.hpp" namespace "cuopt::cython": # noqa cdef unique_ptr[mps_data_model_t[int, double]] call_read( const string& file_path, diff --git a/python/cuopt/cuopt/linear_programming/solver/solver.pxd b/python/cuopt/cuopt/linear_programming/solver/solver.pxd index 5570af1a04..04b75ce4e5 100644 --- a/python/cuopt/cuopt/linear_programming/solver/solver.pxd +++ b/python/cuopt/cuopt/linear_programming/solver/solver.pxd @@ -23,11 +23,11 @@ from cuopt.linear_programming.solver_settings.solver_settings cimport ( ) -cdef extern from "cuopt/linear_programming/optimization_problem.hpp" namespace "cuopt::linear_programming": # noqa - ctypedef enum problem_category_t "cuopt::linear_programming::problem_category_t": # noqa - LP "cuopt::linear_programming::problem_category_t::LP" - MIP "cuopt::linear_programming::problem_category_t::MIP" - IP "cuopt::linear_programming::problem_category_t::IP" +cdef extern from "cuopt/mathematical_optimization/optimization_problem.hpp" namespace "cuopt::mathematical_optimization": # noqa + ctypedef enum problem_category_t "cuopt::mathematical_optimization::problem_category_t": # noqa + LP "cuopt::mathematical_optimization::problem_category_t::LP" + MIP "cuopt::mathematical_optimization::problem_category_t::MIP" + IP "cuopt::mathematical_optimization::problem_category_t::IP" cdef extern from "cuopt/error.hpp" namespace "cuopt": # noqa ctypedef enum error_type_t "cuopt::error_type_t": # noqa @@ -36,33 +36,33 @@ cdef extern from "cuopt/error.hpp" namespace "cuopt": # noqa OutOfMemoryError "cuopt::error_type_t::OutOfMemoryError" # noqa RuntimeError "cuopt::error_type_t::RuntimeError" # noqa -cdef extern from "cuopt/linear_programming/mip/solver_solution.hpp" namespace "cuopt::linear_programming": # noqa - ctypedef enum mip_termination_status_t "cuopt::linear_programming::mip_termination_status_t": # noqa - NoTermination "cuopt::linear_programming::mip_termination_status_t::NoTermination" # noqa - Optimal "cuopt::linear_programming::mip_termination_status_t::Optimal" - FeasibleFound "cuopt::linear_programming::mip_termination_status_t::FeasibleFound" # noqa - Infeasible "cuopt::linear_programming::mip_termination_status_t::Infeasible" # noqa - Unbounded "cuopt::linear_programming::mip_termination_status_t::Unbounded" # noqa - TimeLimit "cuopt::linear_programming::mip_termination_status_t::TimeLimit" # noqa - WorkLimit "cuopt::linear_programming::mip_termination_status_t::WorkLimit" # noqa - UnboundedOrInfeasible "cuopt::linear_programming::mip_termination_status_t::UnboundedOrInfeasible" # noqa - - -cdef extern from "cuopt/linear_programming/pdlp/solver_solution.hpp" namespace "cuopt::linear_programming": # noqa - ctypedef enum pdlp_termination_status_t "cuopt::linear_programming::pdlp_termination_status_t": # noqa - NoTermination "cuopt::linear_programming::pdlp_termination_status_t::NoTermination" # noqa - NumericalError "cuopt::linear_programming::pdlp_termination_status_t::NumericalError" # noqa - Optimal "cuopt::linear_programming::pdlp_termination_status_t::Optimal" # noqa - PrimalInfeasible "cuopt::linear_programming::pdlp_termination_status_t::PrimalInfeasible" # noqa - DualInfeasible "cuopt::linear_programming::pdlp_termination_status_t::DualInfeasible" # noqa - IterationLimit "cuopt::linear_programming::pdlp_termination_status_t::IterationLimit" # noqa - TimeLimit "cuopt::linear_programming::pdlp_termination_status_t::TimeLimit" # noqa - ConcurrentLimit "cuopt::linear_programming::pdlp_termination_status_t::ConcurrentLimit" # noqa - PrimalFeasible "cuopt::linear_programming::pdlp_termination_status_t::PrimalFeasible" # noqa - UnboundedOrInfeasible "cuopt::linear_programming::pdlp_termination_status_t::UnboundedOrInfeasible" # noqa - - -cdef extern from "cuopt/linear_programming/utilities/cython_types.hpp" namespace "cuopt::cython": # noqa +cdef extern from "cuopt/mathematical_optimization/mip/solver_solution.hpp" namespace "cuopt::mathematical_optimization": # noqa + ctypedef enum mip_termination_status_t "cuopt::mathematical_optimization::mip_termination_status_t": # noqa + NoTermination "cuopt::mathematical_optimization::mip_termination_status_t::NoTermination" # noqa + Optimal "cuopt::mathematical_optimization::mip_termination_status_t::Optimal" + FeasibleFound "cuopt::mathematical_optimization::mip_termination_status_t::FeasibleFound" # noqa + Infeasible "cuopt::mathematical_optimization::mip_termination_status_t::Infeasible" # noqa + Unbounded "cuopt::mathematical_optimization::mip_termination_status_t::Unbounded" # noqa + TimeLimit "cuopt::mathematical_optimization::mip_termination_status_t::TimeLimit" # noqa + WorkLimit "cuopt::mathematical_optimization::mip_termination_status_t::WorkLimit" # noqa + UnboundedOrInfeasible "cuopt::mathematical_optimization::mip_termination_status_t::UnboundedOrInfeasible" # noqa + + +cdef extern from "cuopt/mathematical_optimization/pdlp/solver_solution.hpp" namespace "cuopt::mathematical_optimization": # noqa + ctypedef enum pdlp_termination_status_t "cuopt::mathematical_optimization::pdlp_termination_status_t": # noqa + NoTermination "cuopt::mathematical_optimization::pdlp_termination_status_t::NoTermination" # noqa + NumericalError "cuopt::mathematical_optimization::pdlp_termination_status_t::NumericalError" # noqa + Optimal "cuopt::mathematical_optimization::pdlp_termination_status_t::Optimal" # noqa + PrimalInfeasible "cuopt::mathematical_optimization::pdlp_termination_status_t::PrimalInfeasible" # noqa + DualInfeasible "cuopt::mathematical_optimization::pdlp_termination_status_t::DualInfeasible" # noqa + IterationLimit "cuopt::mathematical_optimization::pdlp_termination_status_t::IterationLimit" # noqa + TimeLimit "cuopt::mathematical_optimization::pdlp_termination_status_t::TimeLimit" # noqa + ConcurrentLimit "cuopt::mathematical_optimization::pdlp_termination_status_t::ConcurrentLimit" # noqa + PrimalFeasible "cuopt::mathematical_optimization::pdlp_termination_status_t::PrimalFeasible" # noqa + UnboundedOrInfeasible "cuopt::mathematical_optimization::pdlp_termination_status_t::UnboundedOrInfeasible" # noqa + + +cdef extern from "cuopt/mathematical_optimization/utilities/cython_types.hpp" namespace "cuopt::cython": # noqa # Inner struct types for LP solution vectors (GPU backend) cdef cppclass lp_gpu_solutions_t "cuopt::cython::linear_programming_ret_t::gpu_solutions_t": # noqa unique_ptr[device_buffer] primal_solution_ @@ -93,7 +93,7 @@ cdef extern from "cuopt/linear_programming/utilities/cython_types.hpp" namespace vector[double] last_restart_duality_gap_primal_solution_ vector[double] last_restart_duality_gap_dual_solution_ -cdef extern from "cuopt/linear_programming/utilities/cython_solve.hpp" namespace "cuopt::cython": # noqa +cdef extern from "cuopt/mathematical_optimization/utilities/cython_solve.hpp" namespace "cuopt::cython": # noqa # Unified LP solution struct — solutions_ variant accessed via helpers cdef cppclass linear_programming_ret_t: # PDLP warm start scalars @@ -156,7 +156,7 @@ cdef extern from "cuopt/linear_programming/utilities/cython_solve.hpp" namespace cdef extern from *: """ #include - #include + #include // MIP: extract GPU (unique_ptr) or CPU (vector) solution inline std::unique_ptr& get_gpu_mip_solution(cuopt::cython::mip_ret_t& m) { diff --git a/python/cuopt/cuopt/linear_programming/solver/solver_wrapper.pyx b/python/cuopt/cuopt/linear_programming/solver/solver_wrapper.pyx index 925dd8797b..5124195073 100644 --- a/python/cuopt/cuopt/linear_programming/solver/solver_wrapper.pyx +++ b/python/cuopt/cuopt/linear_programming/solver/solver_wrapper.pyx @@ -72,7 +72,7 @@ from cuopt.utilities import InputValidationError, get_data_ptr, series_from_buf import pyarrow as pa -cdef extern from "cuopt/linear_programming/utilities/internals.hpp" namespace "cuopt::internals": # noqa +cdef extern from "cuopt/mathematical_optimization/utilities/internals.hpp" namespace "cuopt::internals": # noqa cdef cppclass base_solution_callback_t diff --git a/python/cuopt/cuopt/linear_programming/solver_settings/solver_settings.pxd b/python/cuopt/cuopt/linear_programming/solver_settings/solver_settings.pxd index 83a87575fe..03958d2286 100644 --- a/python/cuopt/cuopt/linear_programming/solver_settings/solver_settings.pxd +++ b/python/cuopt/cuopt/linear_programming/solver_settings/solver_settings.pxd @@ -12,25 +12,25 @@ from libcpp cimport bool from libcpp.string cimport string from libcpp.vector cimport vector -cdef extern from "cuopt/linear_programming/utilities/internals.hpp" namespace "cuopt::internals": # noqa +cdef extern from "cuopt/mathematical_optimization/utilities/internals.hpp" namespace "cuopt::internals": # noqa cdef cppclass base_solution_callback_t -cdef extern from "cuopt/linear_programming/pdlp/solver_settings.hpp" namespace "cuopt::linear_programming": # noqa - ctypedef enum pdlp_solver_mode_t "cuopt::linear_programming::pdlp_solver_mode_t": # noqa - Stable1 "cuopt::linear_programming::pdlp_solver_mode_t::Stable1" # noqa - Stable2 "cuopt::linear_programming::pdlp_solver_mode_t::Stable2" # noqa - Methodical1 "cuopt::linear_programming::pdlp_solver_mode_t::Methodical1" # noqa - Fast1 "cuopt::linear_programming::pdlp_solver_mode_t::Fast1" # noqa - Stable3 "cuopt::linear_programming::pdlp_solver_mode_t::Stable3" # noqa - - ctypedef enum method_t "cuopt::linear_programming::method_t": # noqa - Concurrent "cuopt::linear_programming::method_t::Concurrent" # noqa - PDLP "cuopt::linear_programming::method_t::PDLP" # noqa - DualSimplex "cuopt::linear_programming::method_t::DualSimplex" # noqa - Barrier "cuopt::linear_programming::method_t::Barrier" # noqa - Unset "cuopt::linear_programming::method_t::Unset" # noqa - -cdef extern from "cuopt/linear_programming/solver_settings.hpp" namespace "cuopt::linear_programming": # noqa +cdef extern from "cuopt/mathematical_optimization/pdlp/solver_settings.hpp" namespace "cuopt::mathematical_optimization": # noqa + ctypedef enum pdlp_solver_mode_t "cuopt::mathematical_optimization::pdlp_solver_mode_t": # noqa + Stable1 "cuopt::mathematical_optimization::pdlp_solver_mode_t::Stable1" # noqa + Stable2 "cuopt::mathematical_optimization::pdlp_solver_mode_t::Stable2" # noqa + Methodical1 "cuopt::mathematical_optimization::pdlp_solver_mode_t::Methodical1" # noqa + Fast1 "cuopt::mathematical_optimization::pdlp_solver_mode_t::Fast1" # noqa + Stable3 "cuopt::mathematical_optimization::pdlp_solver_mode_t::Stable3" # noqa + + ctypedef enum method_t "cuopt::mathematical_optimization::method_t": # noqa + Concurrent "cuopt::mathematical_optimization::method_t::Concurrent" # noqa + PDLP "cuopt::mathematical_optimization::method_t::PDLP" # noqa + DualSimplex "cuopt::mathematical_optimization::method_t::DualSimplex" # noqa + Barrier "cuopt::mathematical_optimization::method_t::Barrier" # noqa + Unset "cuopt::mathematical_optimization::method_t::Unset" # noqa + +cdef extern from "cuopt/mathematical_optimization/solver_settings.hpp" namespace "cuopt::mathematical_optimization": # noqa cdef cppclass solver_settings_t[i_t, f_t]: solver_settings_t() except + diff --git a/skills/cuopt-developer/references/python_bindings.md b/skills/cuopt-developer/references/python_bindings.md index 92a44fc680..7315e1a09b 100644 --- a/skills/cuopt-developer/references/python_bindings.md +++ b/skills/cuopt-developer/references/python_bindings.md @@ -23,7 +23,7 @@ C++ Implementation (.hpp/.cu) ← Solver logic, CUDA kernels | Cython bindings | `python/cuopt/cuopt/linear_programming/data_model/data_model_wrapper.pyx` | Data model bridge | | Cython declarations | `python/cuopt/cuopt/linear_programming/solver/solver.pxd` | C++ interface declarations | | Cython declarations | `python/cuopt/cuopt/linear_programming/data_model/data_model.pxd` | C++ interface declarations | -| C++ headers | `cpp/include/cuopt/linear_programming/` | Public API | +| C++ headers | `cpp/include/cuopt/mathematical_optimization/` | Public API | | C++ implementation | `cpp/src/` | Solver internals | ## File Types @@ -126,10 +126,10 @@ void solver_settings_t::set_parameter_from_string( ### Declaring C++ classes in .pxd ```cython -cdef extern from "cuopt/linear_programming/solver_settings.hpp" namespace "cuopt::linear_programming": - ctypedef enum pdlp_solver_mode_t "cuopt::linear_programming::pdlp_solver_mode_t": - Stable1 "cuopt::linear_programming::pdlp_solver_mode_t::Stable1" - Stable2 "cuopt::linear_programming::pdlp_solver_mode_t::Stable2" +cdef extern from "cuopt/mathematical_optimization/solver_settings.hpp" namespace "cuopt::mathematical_optimization": + ctypedef enum pdlp_solver_mode_t "cuopt::mathematical_optimization::pdlp_solver_mode_t": + Stable1 "cuopt::mathematical_optimization::pdlp_solver_mode_t::Stable1" + Stable2 "cuopt::mathematical_optimization::pdlp_solver_mode_t::Stable2" cdef cppclass solver_settings_t[i_t, f_t]: solver_settings_t() except + diff --git a/skills/cuopt-install/references/verification_examples.md b/skills/cuopt-install/references/verification_examples.md index 83628437d7..5509729d57 100644 --- a/skills/cuopt-install/references/verification_examples.md +++ b/skills/cuopt-install/references/verification_examples.md @@ -83,7 +83,7 @@ find ${CONDA_PREFIX:-/usr} -name "libcuopt.so" 2>/dev/null # Test compile (if gcc available) cat > /tmp/test_cuopt.c << 'EOF' -#include +#include #include int main() { printf("cuopt_c.h found and compilable\n"); diff --git a/skills/cuopt-numerical-optimization-api-c/SKILL.md b/skills/cuopt-numerical-optimization-api-c/SKILL.md index 9362936b88..dcc71876c9 100644 --- a/skills/cuopt-numerical-optimization-api-c/SKILL.md +++ b/skills/cuopt-numerical-optimization-api-c/SKILL.md @@ -24,11 +24,11 @@ This skill is **C only**. ## API Call Sequence -For LP/MILP, the ordered C entry points are: `cuOptCreateRangedProblem` (sense `CUOPT_MINIMIZE` / `CUOPT_MAXIMIZE`, CSR constraint matrix as `row_offsets` / `col_indices` / `values`, `var_types` char array using `CUOPT_CONTINUOUS` / `CUOPT_INTEGER` macros) → `cuOptSolve(problem, settings, &solution)` → `cuOptGetObjectiveValue(solution, &obj_value)` → matching `cuOptDestroy*` calls. Include ``. Full ordered code with build instructions in [references/examples.md](references/examples.md). +For LP/MILP, the ordered C entry points are: `cuOptCreateRangedProblem` (sense `CUOPT_MINIMIZE` / `CUOPT_MAXIMIZE`, CSR constraint matrix as `row_offsets` / `col_indices` / `values`, `var_types` char array using `CUOPT_CONTINUOUS` / `CUOPT_INTEGER` macros) → `cuOptSolve(problem, settings, &solution)` → `cuOptGetObjectiveValue(solution, &obj_value)` → matching `cuOptDestroy*` calls. Include ``. Full ordered code with build instructions in [references/examples.md](references/examples.md). ## QP via C API (beta) -QP uses the same library, include/lib paths, and build pattern as LP/MILP — only the problem-creation call differs (it accepts a quadratic objective). See the cuOpt C headers (`cpp/include/cuopt/linear_programming/`) for the QP-specific creation/solve calls and the repo docs at `docs/cuopt/source/cuopt-c/lp-qp-milp/` for end-to-end QP examples. +QP uses the same library, include/lib paths, and build pattern as LP/MILP — only the problem-creation call differs (it accepts a quadratic objective). See the cuOpt C headers (`cpp/include/cuopt/mathematical_optimization/`) for the QP-specific creation/solve calls and the repo docs at `docs/cuopt/source/cuopt-c/lp-qp-milp/` for end-to-end QP examples. **QP rules:** - **MINIMIZE only** (`CUOPT_MINIMIZE`). To maximize `f(x)`, negate objective coefficients and Q entries. diff --git a/skills/cuopt-numerical-optimization-api-c/assets/lp_basic/lp_simple.c b/skills/cuopt-numerical-optimization-api-c/assets/lp_basic/lp_simple.c index a21e17ab7b..f816e5dcd4 100644 --- a/skills/cuopt-numerical-optimization-api-c/assets/lp_basic/lp_simple.c +++ b/skills/cuopt-numerical-optimization-api-c/assets/lp_basic/lp_simple.c @@ -7,8 +7,8 @@ * Simple LP (C API): minimize -0.2*x1 + 0.1*x2 * subject to 3*x1 + 4*x2 <= 5.4, 2.7*x1 + 10.1*x2 <= 4.9, x1,x2 >= 0 */ -#include -#include +#include +#include #include #include diff --git a/skills/cuopt-numerical-optimization-api-c/assets/lp_duals/lp_duals.c b/skills/cuopt-numerical-optimization-api-c/assets/lp_duals/lp_duals.c index a92262d18a..8fed250714 100644 --- a/skills/cuopt-numerical-optimization-api-c/assets/lp_duals/lp_duals.c +++ b/skills/cuopt-numerical-optimization-api-c/assets/lp_duals/lp_duals.c @@ -7,8 +7,8 @@ * LP with dual values and reduced costs (C API). * Problem: Minimize 3x + 2y + 5z subject to x + y + z = 4, 2x + y + z = 5, x,y,z >= 0. */ -#include -#include +#include +#include #include #include diff --git a/skills/cuopt-numerical-optimization-api-c/assets/milp_basic/milp_simple.c b/skills/cuopt-numerical-optimization-api-c/assets/milp_basic/milp_simple.c index 585b961c3e..b1ccbf1a3a 100644 --- a/skills/cuopt-numerical-optimization-api-c/assets/milp_basic/milp_simple.c +++ b/skills/cuopt-numerical-optimization-api-c/assets/milp_basic/milp_simple.c @@ -6,8 +6,8 @@ /* * Simple MILP (C API): same as LP but x1 is integer */ -#include -#include +#include +#include #include #include diff --git a/skills/cuopt-numerical-optimization-api-c/assets/milp_production_planning/milp_production.c b/skills/cuopt-numerical-optimization-api-c/assets/milp_production_planning/milp_production.c index 093cdc8115..53ca9e3a96 100644 --- a/skills/cuopt-numerical-optimization-api-c/assets/milp_production_planning/milp_production.c +++ b/skills/cuopt-numerical-optimization-api-c/assets/milp_production_planning/milp_production.c @@ -9,8 +9,8 @@ * Constraints: 2*x1+x2 <= 100 (machine), x1+3*x2 <= 120 (labor), 4*x1+2*x2 <= 200 (material). * Objective: maximize 50*x1 + 30*x2 => minimize -50*x1 - 30*x2. */ -#include -#include +#include +#include #include #include diff --git a/skills/cuopt-numerical-optimization-api-c/assets/mps_solver/mps_solver.c b/skills/cuopt-numerical-optimization-api-c/assets/mps_solver/mps_solver.c index 9aeb6f952a..8fda44d05d 100644 --- a/skills/cuopt-numerical-optimization-api-c/assets/mps_solver/mps_solver.c +++ b/skills/cuopt-numerical-optimization-api-c/assets/mps_solver/mps_solver.c @@ -7,8 +7,8 @@ * Solve LP/MILP from MPS file (C API). * Usage: mps_solver */ -#include -#include +#include +#include #include #include diff --git a/skills/cuopt-numerical-optimization-api-c/evals/evals.json b/skills/cuopt-numerical-optimization-api-c/evals/evals.json index a3ec9c4183..e1af18fe65 100644 --- a/skills/cuopt-numerical-optimization-api-c/evals/evals.json +++ b/skills/cuopt-numerical-optimization-api-c/evals/evals.json @@ -4,7 +4,7 @@ "question": "I want to solve a small MILP (some integer variables, linear objective, linear constraints) with the cuOpt C API. List the C functions and structs I need in order — names only, one line each, no full source.", "expected_skill": "cuopt-numerical-optimization-api-c", "expected_script": null, - "ground_truth": "The agent produces an ordered list of C API entry points without writing a full source file: include cuopt/linear_programming/cuopt_c.h, then call cuOptCreateRangedProblem with sense CUOPT_MINIMIZE or CUOPT_MAXIMIZE, then cuOptSolve(problem, settings, &solution), then cuOptGetObjectiveValue.", + "ground_truth": "The agent produces an ordered list of C API entry points without writing a full source file: include cuopt/mathematical_optimization/cuopt_c.h, then call cuOptCreateRangedProblem with sense CUOPT_MINIMIZE or CUOPT_MAXIMIZE, then cuOptSolve(problem, settings, &solution), then cuOptGetObjectiveValue.", "expected_behavior": [ "Lists C API call sequence without writing a complete source file", "Names cuOptCreateRangedProblem, cuOptSolve, cuOptGetObjectiveValue in order" diff --git a/skills/cuopt-numerical-optimization-api-c/references/examples.md b/skills/cuopt-numerical-optimization-api-c/references/examples.md index 8e8e7cd4e6..96818bd9b7 100644 --- a/skills/cuopt-numerical-optimization-api-c/references/examples.md +++ b/skills/cuopt-numerical-optimization-api-c/references/examples.md @@ -3,8 +3,8 @@ ## Required Headers ```c -#include // Core API -#include // Parameter name macros (CUOPT_TIME_LIMIT, etc.) +#include // Core API +#include // Parameter name macros (CUOPT_TIME_LIMIT, etc.) ``` ## Parameter Setting Functions @@ -30,8 +30,8 @@ * 2.7*x1 + 10.1*x2 <= 4.9 * x1, x2 >= 0 */ -#include -#include +#include +#include #include #include @@ -139,8 +139,8 @@ cleanup: /* * Same as LP but x1 is integer */ -#include -#include +#include +#include #include #include @@ -291,7 +291,7 @@ CUOPT_PDLP_SOLVER_MODE_FAST1 // 3 CUOPT_PDLP_SOLVER_MODE_STABLE3 // 4 ``` -> **Complete list:** See `cpp/include/cuopt/linear_programming/constants.h` for all 50+ parameter constants including termination status codes, constraint senses, and file format constants. +> **Complete list:** See `cpp/include/cuopt/mathematical_optimization/constants.h` for all 50+ parameter constants including termination status codes, constraint senses, and file format constants. --- @@ -301,8 +301,8 @@ For more complete C examples with full error handling, see: | Resource | Location | |----------|----------| -| **Constants Header** | `cpp/include/cuopt/linear_programming/constants.h` | -| C API Header | `cpp/include/cuopt/linear_programming/cuopt_c.h` | +| **Constants Header** | `cpp/include/cuopt/mathematical_optimization/constants.h` | +| C API Header | `cpp/include/cuopt/mathematical_optimization/cuopt_c.h` | | C API Documentation | `docs/cuopt/source/cuopt-c/lp-qp-milp/lp-qp-milp-c-api.rst` | | Simple LP Example | `docs/cuopt/source/cuopt-c/lp-qp-milp/examples/simple_lp_example.c` | | Simple MILP Example | `docs/cuopt/source/cuopt-c/lp-qp-milp/examples/simple_milp_example.c` |