From 380e20cb5b9a63c83e98e9742e5d01ac107877fc Mon Sep 17 00:00:00 2001 From: Miles Lubin Date: Sat, 20 Jun 2026 18:37:14 +0000 Subject: [PATCH 01/17] refactor: rename cuopt::linear_programming -> cuopt::math_optimization Mechanical rename of the umbrella namespace and public include path (include/cuopt/linear_programming -> include/cuopt/math_optimization). No structural or behavioral change. Python package cuopt.linear_programming intentionally unchanged. Co-Authored-By: Claude Opus 4.8 (1M context) Signed-off-by: Miles Lubin --- .coderabbit.yaml | 2 +- .github/.coderabbit_review_guide.md | 6 +- 1 | 421 ++++++++++ .../cuopt/benchmark_helper.hpp | 20 +- .../cuopt/initial_problem_check.hpp | 2 +- .../linear_programming/cuopt/run_mip.cpp | 42 +- .../linear_programming/cuopt/run_pdlp.cu | 60 +- best_results.txt | 0 ci/test_doc_examples.sh | 8 +- cpp/cuopt_cli.cpp | 56 +- cpp/doxygen/Doxyfile | 4 +- cpp/include/cuopt/error.hpp | 2 +- .../backend_selection.hpp | 4 +- .../constants.h | 0 .../cpu_optimization_problem.hpp | 6 +- .../cpu_optimization_problem_solution.hpp | 16 +- .../cpu_pdlp_warm_start_data.hpp | 6 +- .../csr_matrix_utils.hpp | 4 +- .../cuopt_c.h | 2 +- .../io/data_model_view.hpp | 6 +- .../io/mps_data_model.hpp | 4 +- .../io/mps_writer.hpp | 8 +- .../io/parser.hpp | 6 +- .../io/utilities/cython_parser.hpp | 6 +- .../io/writer.hpp | 6 +- .../mip/diving_hyper_params.hpp | 4 +- .../mip/heuristics_hyper_params.hpp | 4 +- .../mip/solver_settings.hpp | 14 +- .../mip/solver_solution.hpp | 10 +- .../mip/solver_stats.hpp | 4 +- .../optimization_problem.hpp | 8 +- .../optimization_problem_interface.hpp | 6 +- .../optimization_problem_solution.hpp | 14 +- ...ptimization_problem_solution_interface.hpp | 14 +- .../optimization_problem_utils.hpp | 16 +- .../pdlp/pdlp_hyper_params.cuh | 4 +- .../pdlp/pdlp_warm_start_data.hpp | 4 +- .../pdlp/solver_settings.hpp | 14 +- .../pdlp/solver_solution.hpp | 12 +- .../solve.hpp | 36 +- .../solve_remote.hpp | 6 +- .../solver_settings.hpp | 14 +- .../utilities/callbacks_implems.hpp | 2 +- .../utilities/cython_solve.hpp | 36 +- .../utilities/cython_types.hpp | 12 +- .../utilities/internals.hpp | 6 +- .../utilities/segmented_sum_handler.cuh | 4 +- cpp/src/barrier/barrier.cu | 4 +- cpp/src/barrier/barrier.hpp | 4 +- cpp/src/barrier/conjugate_gradient.hpp | 4 +- cpp/src/barrier/cusparse_info.hpp | 4 +- cpp/src/barrier/cusparse_view.cu | 4 +- cpp/src/barrier/cusparse_view.hpp | 4 +- cpp/src/barrier/dense_matrix.hpp | 4 +- cpp/src/barrier/dense_vector.hpp | 4 +- cpp/src/barrier/device_sparse_matrix.cu | 4 +- cpp/src/barrier/device_sparse_matrix.cuh | 4 +- cpp/src/barrier/iterative_refinement.hpp | 4 +- cpp/src/barrier/pinned_host_allocator.cu | 6 +- cpp/src/barrier/pinned_host_allocator.hpp | 4 +- cpp/src/barrier/second_order_cone_kernels.cuh | 4 +- .../barrier/second_order_cone_reduction.cuh | 4 +- cpp/src/barrier/sparse_cholesky.cuh | 4 +- cpp/src/barrier/sparse_matrix_kernels.cuh | 4 +- cpp/src/barrier/translate_soc.hpp | 20 +- cpp/src/branch_and_bound/bb_event.hpp | 4 +- cpp/src/branch_and_bound/branch_and_bound.cpp | 6 +- cpp/src/branch_and_bound/branch_and_bound.hpp | 8 +- cpp/src/branch_and_bound/constants.hpp | 4 +- .../deterministic_workers.hpp | 4 +- .../branch_and_bound/diving_heuristics.cpp | 4 +- .../branch_and_bound/diving_heuristics.hpp | 6 +- cpp/src/branch_and_bound/mip_node.hpp | 4 +- cpp/src/branch_and_bound/node_queue.hpp | 4 +- cpp/src/branch_and_bound/pseudo_costs.cpp | 10 +- cpp/src/branch_and_bound/pseudo_costs.hpp | 4 +- .../shared_strong_branching_context.hpp | 4 +- cpp/src/branch_and_bound/symmetry.hpp | 4 +- cpp/src/branch_and_bound/worker.hpp | 4 +- cpp/src/branch_and_bound/worker_pool.hpp | 4 +- cpp/src/cuts/cuts.cpp | 4 +- cpp/src/cuts/cuts.hpp | 6 +- cpp/src/cuts/objective_step.cpp | 4 +- cpp/src/cuts/objective_step.hpp | 4 +- cpp/src/cuts/rational.hpp | 4 +- cpp/src/dual_simplex/basis_solves.cpp | 4 +- cpp/src/dual_simplex/basis_solves.hpp | 4 +- cpp/src/dual_simplex/basis_updates.cpp | 4 +- cpp/src/dual_simplex/basis_updates.hpp | 4 +- .../bound_flipping_ratio_test.cpp | 4 +- .../bound_flipping_ratio_test.hpp | 4 +- cpp/src/dual_simplex/bounds_strengthening.cpp | 4 +- cpp/src/dual_simplex/bounds_strengthening.hpp | 4 +- cpp/src/dual_simplex/crossover.cpp | 4 +- cpp/src/dual_simplex/crossover.hpp | 6 +- cpp/src/dual_simplex/folding.cpp | 4 +- cpp/src/dual_simplex/folding.hpp | 6 +- cpp/src/dual_simplex/initial_basis.cpp | 4 +- cpp/src/dual_simplex/initial_basis.hpp | 4 +- cpp/src/dual_simplex/logger.hpp | 4 +- cpp/src/dual_simplex/phase1.cpp | 6 +- cpp/src/dual_simplex/phase1.hpp | 6 +- cpp/src/dual_simplex/phase2.cpp | 4 +- cpp/src/dual_simplex/phase2.hpp | 4 +- cpp/src/dual_simplex/presolve.cpp | 4 +- cpp/src/dual_simplex/presolve.hpp | 4 +- cpp/src/dual_simplex/primal.cpp | 4 +- cpp/src/dual_simplex/primal.hpp | 4 +- cpp/src/dual_simplex/random.hpp | 6 +- cpp/src/dual_simplex/right_looking_lu.cpp | 4 +- cpp/src/dual_simplex/right_looking_lu.hpp | 4 +- cpp/src/dual_simplex/scaling.cpp | 4 +- cpp/src/dual_simplex/scaling.hpp | 4 +- .../dual_simplex/simplex_solver_settings.hpp | 10 +- cpp/src/dual_simplex/singletons.cpp | 4 +- cpp/src/dual_simplex/singletons.hpp | 4 +- cpp/src/dual_simplex/solution.hpp | 4 +- cpp/src/dual_simplex/solve.cpp | 4 +- cpp/src/dual_simplex/solve.hpp | 4 +- cpp/src/dual_simplex/sparse_matrix.cpp | 4 +- cpp/src/dual_simplex/sparse_matrix.hpp | 7 +- cpp/src/dual_simplex/sparse_vector.cpp | 4 +- cpp/src/dual_simplex/sparse_vector.hpp | 4 +- cpp/src/dual_simplex/tic_toc.cpp | 6 +- cpp/src/dual_simplex/tic_toc.hpp | 6 +- cpp/src/dual_simplex/triangle_solve.cpp | 4 +- cpp/src/dual_simplex/triangle_solve.hpp | 4 +- cpp/src/dual_simplex/types.hpp | 4 +- cpp/src/dual_simplex/user_problem.hpp | 4 +- cpp/src/dual_simplex/vector_math.cpp | 4 +- cpp/src/dual_simplex/vector_math.cuh | 4 +- cpp/src/dual_simplex/vector_math.hpp | 4 +- cpp/src/grpc/client/grpc_client.cpp | 8 +- cpp/src/grpc/client/grpc_client.hpp | 12 +- cpp/src/grpc/client/solve_remote.cpp | 12 +- cpp/src/grpc/codegen/field_registry.yaml | 2 +- cpp/src/grpc/grpc_chunk_key.hpp | 4 +- cpp/src/grpc/grpc_problem_mapper.cpp | 12 +- cpp/src/grpc/grpc_problem_mapper.hpp | 4 +- cpp/src/grpc/grpc_service_mapper.cpp | 10 +- cpp/src/grpc/grpc_service_mapper.hpp | 4 +- cpp/src/grpc/grpc_settings_mapper.cpp | 12 +- cpp/src/grpc/grpc_settings_mapper.hpp | 4 +- cpp/src/grpc/grpc_solution_mapper.cpp | 12 +- cpp/src/grpc/grpc_solution_mapper.hpp | 10 +- .../grpc/server/grpc_pipe_serialization.hpp | 17 +- cpp/src/grpc/server/grpc_server_types.hpp | 12 +- cpp/src/grpc/server/grpc_service_impl.cpp | 2 +- cpp/src/grpc/server/grpc_worker.cpp | 2 +- cpp/src/io/data_model_view.cpp | 6 +- cpp/src/io/file_to_string.cpp | 10 +- cpp/src/io/file_to_string.hpp | 4 +- cpp/src/io/lp_parser.cpp | 6 +- cpp/src/io/lp_parser.hpp | 6 +- cpp/src/io/mps_data_model.cpp | 6 +- cpp/src/io/mps_parser.cpp | 12 +- cpp/src/io/mps_parser_internal.hpp | 6 +- cpp/src/io/mps_writer.cpp | 10 +- cpp/src/io/parser.cpp | 6 +- cpp/src/io/utilities/cython_parser.cpp | 16 +- cpp/src/io/utilities/error.hpp | 4 +- cpp/src/io/writer.cpp | 8 +- cpp/src/math_optimization/solution_reader.cu | 6 +- cpp/src/math_optimization/solution_reader.hpp | 6 +- cpp/src/math_optimization/solution_writer.cu | 4 +- cpp/src/math_optimization/solution_writer.hpp | 4 +- cpp/src/math_optimization/solver_settings.cu | 6 +- .../diversity/assignment_hash_map.cu | 4 +- .../diversity/assignment_hash_map.cuh | 4 +- .../diversity/diversity_config.hpp | 4 +- .../diversity/diversity_manager.cu | 4 +- .../diversity/diversity_manager.cuh | 8 +- cpp/src/mip_heuristics/diversity/lns/rins.cu | 6 +- cpp/src/mip_heuristics/diversity/lns/rins.cuh | 4 +- .../diversity/multi_armed_bandit.cu | 4 +- .../diversity/multi_armed_bandit.cuh | 4 +- .../mip_heuristics/diversity/population.cu | 4 +- .../mip_heuristics/diversity/population.cuh | 4 +- .../recombiners/bound_prop_recombiner.cuh | 4 +- .../diversity/recombiners/fp_recombiner.cuh | 4 +- .../recombiners/line_segment_recombiner.cuh | 4 +- .../diversity/recombiners/recombiner.cuh | 4 +- .../recombiners/recombiner_configs.hpp | 6 +- .../recombiners/recombiner_stats.hpp | 4 +- .../diversity/recombiners/sub_mip.cuh | 8 +- cpp/src/mip_heuristics/diversity/weights.cuh | 6 +- cpp/src/mip_heuristics/early_heuristic.cuh | 6 +- .../feasibility_jump/cpu_fj_thread.cuh | 4 +- .../feasibility_jump/early_cpufj.cu | 4 +- .../feasibility_jump/early_cpufj.cuh | 4 +- .../feasibility_jump/early_gpufj.cu | 4 +- .../feasibility_jump/early_gpufj.cuh | 4 +- .../feasibility_jump/feasibility_jump.cu | 4 +- .../feasibility_jump/feasibility_jump.cuh | 6 +- .../feasibility_jump_impl_common.cuh | 4 +- .../feasibility_jump_kernels.cu | 4 +- .../feasibility_jump_kernels.cuh | 4 +- .../mip_heuristics/feasibility_jump/fj_cpu.cu | 4 +- .../feasibility_jump/fj_cpu.cuh | 4 +- .../mip_heuristics/feasibility_jump/utils.cuh | 6 +- .../feasibility_pump/feasibility_pump.cu | 6 +- .../feasibility_pump/feasibility_pump.cuh | 4 +- .../local_search/lagrangian.cuh | 4 +- .../line_segment_search.cu | 4 +- .../line_segment_search.cuh | 4 +- .../local_search/local_search.cu | 4 +- .../local_search/local_search.cuh | 6 +- .../local_search/local_search_config.hpp | 6 +- .../local_search/rounding/bounds_repair.cu | 4 +- .../local_search/rounding/bounds_repair.cuh | 4 +- .../local_search/rounding/constraint_prop.cu | 4 +- .../local_search/rounding/constraint_prop.cuh | 4 +- .../local_search/rounding/lb_bounds_repair.cu | 4 +- .../rounding/lb_bounds_repair.cuh | 4 +- .../rounding/lb_constraint_prop.cu | 4 +- .../rounding/lb_constraint_prop.cuh | 4 +- .../local_search/rounding/simple_rounding.cu | 4 +- .../local_search/rounding/simple_rounding.cuh | 4 +- .../rounding/simple_rounding_kernels.cuh | 4 +- cpp/src/mip_heuristics/logger.cuh | 6 +- cpp/src/mip_heuristics/mip_constants.hpp | 2 +- .../mip_heuristics/mip_scaling_strategy.cu | 18 +- .../mip_heuristics/mip_scaling_strategy.cuh | 8 +- .../presolve/bounds_presolve.cu | 6 +- .../presolve/bounds_presolve.cuh | 4 +- .../presolve/bounds_presolve_helpers.cuh | 6 +- .../presolve/bounds_update_data.cu | 4 +- .../presolve/bounds_update_data.cuh | 4 +- .../presolve/bounds_update_helpers.cuh | 4 +- .../conditional_bound_strengthening.cu | 4 +- .../conditional_bound_strengthening.cuh | 4 +- .../presolve/conflict_graph/clique_table.cu | 4 +- .../presolve/conflict_graph/clique_table.cuh | 6 +- .../mip_heuristics/presolve/gf2_presolve.cpp | 4 +- .../mip_heuristics/presolve/gf2_presolve.hpp | 4 +- .../presolve/lb_probing_cache.cu | 4 +- .../presolve/load_balanced_bounds_presolve.cu | 4 +- .../load_balanced_bounds_presolve.cuh | 4 +- .../load_balanced_bounds_presolve_helpers.cuh | 4 +- .../load_balanced_bounds_presolve_kernels.cuh | 4 +- .../load_balanced_partition_helpers.cuh | 4 +- .../mip_heuristics/presolve/multi_probe.cu | 4 +- .../mip_heuristics/presolve/multi_probe.cuh | 4 +- .../mip_heuristics/presolve/probing_cache.cu | 4 +- .../mip_heuristics/presolve/probing_cache.cuh | 4 +- .../presolve/semi_continuous.cu | 4 +- .../presolve/semi_continuous.cuh | 8 +- .../presolve/third_party_presolve.cpp | 16 +- .../presolve/third_party_presolve.hpp | 12 +- .../presolve/trivial_presolve.cu | 4 +- .../presolve/trivial_presolve.cuh | 4 +- .../presolve/trivial_presolve_helpers.cuh | 4 +- cpp/src/mip_heuristics/presolve/utils.cuh | 6 +- .../mip_heuristics/problem/host_helper.cuh | 6 +- .../problem/load_balanced_problem.cu | 4 +- .../problem/load_balanced_problem.cuh | 8 +- .../mip_heuristics/problem/presolve_data.cu | 10 +- .../mip_heuristics/problem/presolve_data.cuh | 6 +- cpp/src/mip_heuristics/problem/problem.cu | 14 +- cpp/src/mip_heuristics/problem/problem.cuh | 20 +- .../mip_heuristics/problem/problem_fixing.cuh | 6 +- .../problem/problem_helpers.cuh | 4 +- .../problem/problem_kernels.cuh | 6 +- cpp/src/mip_heuristics/problem/write_mps.cu | 4 +- .../mip_heuristics/relaxed_lp/lp_state.cuh | 4 +- .../mip_heuristics/relaxed_lp/relaxed_lp.cu | 4 +- .../mip_heuristics/relaxed_lp/relaxed_lp.cuh | 8 +- .../solution/feasibility_test.cuh | 4 +- cpp/src/mip_heuristics/solution/solution.cu | 4 +- cpp/src/mip_heuristics/solution/solution.cuh | 10 +- .../solution/solution_kernels.cuh | 6 +- cpp/src/mip_heuristics/solve.cu | 32 +- cpp/src/mip_heuristics/solver.cu | 12 +- cpp/src/mip_heuristics/solver.cuh | 10 +- cpp/src/mip_heuristics/solver_context.cuh | 8 +- cpp/src/mip_heuristics/solver_settings.cu | 6 +- cpp/src/mip_heuristics/solver_solution.cu | 6 +- cpp/src/mip_heuristics/utilities/sort_csr.cuh | 4 +- cpp/src/mip_heuristics/utils.cuh | 6 +- cpp/src/pdlp/backend_selection.cpp | 6 +- cpp/src/pdlp/cpu_optimization_problem.cpp | 20 +- cpp/src/pdlp/cpu_pdlp_warm_start_data.cu | 8 +- cpp/src/pdlp/cuopt_c.cpp | 24 +- cpp/src/pdlp/cuopt_c_internal.hpp | 18 +- cpp/src/pdlp/cusparse_view.cu | 4 +- cpp/src/pdlp/cusparse_view.hpp | 6 +- .../initial_scaling.cu | 8 +- .../initial_scaling.cuh | 6 +- .../optimal_batch_size_handler.cu | 4 +- .../optimal_batch_size_handler.hpp | 4 +- cpp/src/pdlp/optimization_problem.cu | 20 +- cpp/src/pdlp/pdhg.cu | 4 +- cpp/src/pdlp/pdhg.hpp | 6 +- cpp/src/pdlp/pdlp.cu | 12 +- cpp/src/pdlp/pdlp.cuh | 8 +- cpp/src/pdlp/pdlp_constants.hpp | 4 +- cpp/src/pdlp/pdlp_warm_start_data.cu | 8 +- .../localized_duality_gap_container.cu | 6 +- .../localized_duality_gap_container.hpp | 6 +- .../restart_strategy/pdlp_restart_strategy.cu | 6 +- .../pdlp_restart_strategy.cuh | 6 +- .../weighted_average_solution.cu | 4 +- .../weighted_average_solution.hpp | 4 +- cpp/src/pdlp/saddle_point.cu | 4 +- cpp/src/pdlp/saddle_point.hpp | 6 +- cpp/src/pdlp/solution_conversion.cu | 10 +- cpp/src/pdlp/solve.cu | 52 +- cpp/src/pdlp/solve.cuh | 20 +- cpp/src/pdlp/solver_settings.cu | 8 +- cpp/src/pdlp/solver_solution.cu | 6 +- .../adaptive_step_size_strategy.cu | 6 +- .../adaptive_step_size_strategy.hpp | 6 +- cpp/src/pdlp/swap_and_resize_helper.cuh | 4 +- .../convergence_information.cu | 6 +- .../convergence_information.hpp | 10 +- .../infeasibility_information.cu | 6 +- .../infeasibility_information.hpp | 8 +- .../termination_strategy.cu | 10 +- .../termination_strategy.hpp | 10 +- cpp/src/pdlp/translate.hpp | 20 +- cpp/src/pdlp/utilities/cython_solve.cu | 95 ++- cpp/src/pdlp/utilities/ping_pong_graph.cu | 4 +- cpp/src/pdlp/utilities/ping_pong_graph.cuh | 4 +- cpp/src/pdlp/utilities/problem_checking.cu | 6 +- cpp/src/pdlp/utilities/problem_checking.cuh | 12 +- cpp/src/pdlp/utils.cuh | 4 +- cpp/src/utilities/device_utils.cuh | 6 +- cpp/src/utilities/double_buffer.hpp | 6 +- cpp/src/utilities/hashing.hpp | 4 +- .../unit_tests/right_looking_ldlt.cpp | 4 +- cpp/tests/dual_simplex/unit_tests/solve.cpp | 31 +- .../dual_simplex/unit_tests/solve_barrier.cu | 22 +- .../c_api_tests/c_api_test.c | 2 +- .../c_api_tests/c_api_tests.cpp | 8 +- .../c_api_tests/c_api_tests.h | 2 +- .../grpc/grpc_client_test.cpp | 14 +- .../grpc/grpc_client_test_helper.hpp | 4 +- .../grpc/grpc_integration_test.cpp | 20 +- .../grpc/grpc_pipe_serialization_test.cpp | 2 +- .../grpc/grpc_test_log_capture.hpp | 4 +- cpp/tests/linear_programming/parser_test.cpp | 8 +- cpp/tests/linear_programming/pdlp_test.cu | 752 +++++++++--------- .../unit_tests/optimization_problem_test.cu | 10 +- .../unit_tests/presolve_test.cu | 38 +- .../unit_tests/solution_interface_test.cu | 22 +- .../unit_tests/solver_settings_test.cu | 22 +- .../utilities/pdlp_test_utilities.cuh | 44 +- cpp/tests/mip/bounds_standardization_test.cu | 16 +- cpp/tests/mip/cuts_test.cu | 14 +- cpp/tests/mip/determinism_test.cu | 12 +- cpp/tests/mip/doc_example_test.cu | 14 +- cpp/tests/mip/elim_var_remap_test.cu | 14 +- cpp/tests/mip/empty_fixed_problems_test.cu | 6 +- cpp/tests/mip/feasibility_jump_tests.cu | 14 +- cpp/tests/mip/heuristics_hyper_params_test.cu | 8 +- cpp/tests/mip/incumbent_callback_test.cu | 22 +- cpp/tests/mip/integer_with_real_bounds.cu | 10 +- cpp/tests/mip/load_balancing_test.cu | 10 +- cpp/tests/mip/mip_utils.cuh | 26 +- cpp/tests/mip/miplib_test.cu | 22 +- cpp/tests/mip/multi_probe_test.cu | 10 +- cpp/tests/mip/presolve_test.cu | 16 +- cpp/tests/mip/problem_test.cu | 24 +- cpp/tests/mip/semi_continuous_test.cu | 8 +- cpp/tests/mip/server_test.cu | 26 +- cpp/tests/mip/termination_test.cu | 8 +- cpp/tests/mip/unit_test.cu | 56 +- .../qp/unit_tests/lp_parser_solve_test.cu | 12 +- cpp/tests/qp/unit_tests/mps_writer_test.cpp | 20 +- cpp/tests/qp/unit_tests/no_constraints.cu | 8 +- cpp/tests/qp/unit_tests/two_variable_test.cu | 8 +- cpp/tests/socp/general_quadratic_test.cu | 26 +- cpp/tests/socp/second_order_cone_kernels.cu | 4 +- cpp/tests/socp/solve_barrier_socp.cu | 32 +- cpp/tests/utilities/inline_lp_test_utils.hpp | 6 +- cpp/tests/utilities/inline_mps_test_utils.hpp | 6 +- .../source/cuopt-c/convex/convex-examples.rst | 2 +- .../examples/general_quadratic_example.c | 2 +- .../cuopt-c/convex/examples/lp_file_example.c | 2 +- .../convex/examples/mps_file_example.c | 2 +- .../convex/examples/rotated_socp_example.c | 2 +- .../convex/examples/simple_lp_example.c | 2 +- .../convex/examples/simple_qp_example.c | 2 +- .../convex/examples/simple_socp_example.c | 2 +- .../cuopt-c/mip/examples/milp_mps_example.c | 2 +- .../mip/examples/simple_milp_example.c | 2 +- docs/cuopt/source/cuopt-cli/cli-examples.rst | 2 +- .../data_model/data_model.pxd | 6 +- .../internals/internals.pyx | 2 +- .../cuopt/linear_programming/io/parser.pxd | 4 +- .../linear_programming/solver/solver.pxd | 68 +- .../solver/solver_wrapper.pyx | 2 +- .../solver_settings/solver_settings.pxd | 34 +- .../references/python_bindings.md | 10 +- .../references/verification_examples.md | 2 +- .../SKILL.md | 4 +- .../assets/lp_basic/lp_simple.c | 4 +- .../assets/lp_duals/lp_duals.c | 4 +- .../assets/milp_basic/milp_simple.c | 4 +- .../milp_production.c | 4 +- .../assets/mps_solver/mps_solver.c | 4 +- .../evals/evals.json | 2 +- .../references/examples.md | 18 +- 403 files changed, 2424 insertions(+), 2007 deletions(-) create mode 100644 1 create mode 100644 best_results.txt rename cpp/include/cuopt/{linear_programming => math_optimization}/backend_selection.hpp (95%) rename cpp/include/cuopt/{linear_programming => math_optimization}/constants.h (100%) rename cpp/include/cuopt/{linear_programming => math_optimization}/cpu_optimization_problem.hpp (98%) rename cpp/include/cuopt/{linear_programming => math_optimization}/cpu_optimization_problem_solution.hpp (96%) rename cpp/include/cuopt/{linear_programming => math_optimization}/cpu_pdlp_warm_start_data.hpp (97%) rename cpp/include/cuopt/{linear_programming => math_optimization}/csr_matrix_utils.hpp (97%) rename cpp/include/cuopt/{linear_programming => math_optimization}/cuopt_c.h (99%) rename cpp/include/cuopt/{linear_programming => math_optimization}/io/data_model_view.hpp (99%) rename cpp/include/cuopt/{linear_programming => math_optimization}/io/mps_data_model.hpp (99%) rename cpp/include/cuopt/{linear_programming => math_optimization}/io/mps_writer.hpp (88%) rename cpp/include/cuopt/{linear_programming => math_optimization}/io/parser.hpp (97%) rename cpp/include/cuopt/{linear_programming => math_optimization}/io/utilities/cython_parser.hpp (64%) rename cpp/include/cuopt/{linear_programming => math_optimization}/io/writer.hpp (81%) rename cpp/include/cuopt/{linear_programming => math_optimization}/mip/diving_hyper_params.hpp (96%) rename cpp/include/cuopt/{linear_programming => math_optimization}/mip/heuristics_hyper_params.hpp (96%) rename cpp/include/cuopt/{linear_programming => math_optimization}/mip/solver_settings.hpp (95%) rename cpp/include/cuopt/{linear_programming => math_optimization}/mip/solver_solution.hpp (93%) rename cpp/include/cuopt/{linear_programming => math_optimization}/mip/solver_stats.hpp (94%) rename cpp/include/cuopt/{linear_programming => math_optimization}/optimization_problem.hpp (98%) rename cpp/include/cuopt/{linear_programming => math_optimization}/optimization_problem_interface.hpp (99%) rename cpp/include/cuopt/{linear_programming => math_optimization}/optimization_problem_solution.hpp (97%) rename cpp/include/cuopt/{linear_programming => math_optimization}/optimization_problem_solution_interface.hpp (97%) rename cpp/include/cuopt/{linear_programming => math_optimization}/optimization_problem_utils.hpp (96%) rename cpp/include/cuopt/{linear_programming => math_optimization}/pdlp/pdlp_hyper_params.cuh (96%) rename cpp/include/cuopt/{linear_programming => math_optimization}/pdlp/pdlp_warm_start_data.hpp (98%) rename cpp/include/cuopt/{linear_programming => math_optimization}/pdlp/solver_settings.hpp (97%) rename cpp/include/cuopt/{linear_programming => math_optimization}/pdlp/solver_solution.hpp (97%) rename cpp/include/cuopt/{linear_programming => math_optimization}/solve.hpp (89%) rename cpp/include/cuopt/{linear_programming => math_optimization}/solve_remote.hpp (89%) rename cpp/include/cuopt/{linear_programming => math_optimization}/solver_settings.hpp (92%) rename cpp/include/cuopt/{linear_programming => math_optimization}/utilities/callbacks_implems.hpp (98%) rename cpp/include/cuopt/{linear_programming => math_optimization}/utilities/cython_solve.hpp (56%) rename cpp/include/cuopt/{linear_programming => math_optimization}/utilities/cython_types.hpp (89%) rename cpp/include/cuopt/{linear_programming => math_optimization}/utilities/internals.hpp (96%) rename cpp/include/cuopt/{linear_programming => math_optimization}/utilities/segmented_sum_handler.cuh (97%) diff --git a/.coderabbit.yaml b/.coderabbit.yaml index 1fe59b5032..73e1043905 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/math_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..94d39210c8 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/math_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/math_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/math_optimization/cuopt_c.h` — flag as ABI-sensitive - Python API changes without `DeprecationWarning` - Server API endpoint changes without deprecation path diff --git a/1 b/1 new file mode 100644 index 0000000000..9549760458 --- /dev/null +++ b/1 @@ -0,0 +1,421 @@ +Setting parameter absolute_dual_tolerance to 1.000000e-05 +Setting parameter relative_dual_tolerance to 1.000000e-05 +Setting parameter absolute_primal_tolerance to 1.000000e-05 +Setting parameter relative_primal_tolerance to 1.000000e-05 +Setting parameter absolute_gap_tolerance to 1.000000e-05 +Setting parameter relative_gap_tolerance to 1.000000e-05 +Setting parameter primal_infeasible_tolerance to 1.000000e-05 +Setting parameter dual_infeasible_tolerance to 1.000000e-05 +Setting parameter time_limit to 1.020000e+01 +Setting parameter iteration_limit to 10 +Setting parameter infeasibility_detection to false +Setting parameter mip_relative_tolerance to 1.000000e-02 +Setting parameter mip_cut_min_orthogonality to 0.000000e+00 +Setting parameter mip_absolute_gap to 1.000000e-02 +Setting parameter eliminate_dense_columns to false +Setting parameter mip_clique_cuts to 0 +Setting parameter absolute_primal_tolerance to 0.000000e+00 +Setting parameter node_limit to 2147483646 +Setting parameter mip_objective_step to 0 +Setting parameter mip_hyper_heuristic_presolve_max_time to 6.000000e+01 +Setting parameter mip_hyper_diving_coefficient to -1 +Setting parameter mip_mixed_integer_gomory_cuts to 0 +Setting parameter pdlp_precision to 0 +Setting parameter mip_reliability_branching to 0 +Setting parameter mip_cut_change_threshold to -5.000000e-01 +Setting parameter folding to 0 +Setting parameter pdlp_solver_mode to 3 +Setting parameter mip_implied_bound_cuts to 0 +Setting parameter relative_gap_tolerance to 0.000000e+00 +Setting parameter mip_relative_gap to 2.000000e-04 +Setting parameter mip_hyper_heuristic_cycle_detection_length to 30 +Setting parameter mip_hyper_heuristic_max_iterations_without_improvement to 8 +Setting parameter mip_knapsack_cuts to 0 +Setting parameter presolve to 1 +Setting parameter mip_hyper_heuristic_num_cpufj_threads to 8 +Setting parameter mip_hyper_heuristic_stagnation_trigger to 3 +Setting parameter iteration_limit to 9999999 +Setting parameter strict_infeasibility to true +Setting parameter num_cpu_threads to 0 +Setting parameter mip_hyper_heuristic_related_vars_time_limit to 3.000000e+01 +Setting parameter relative_dual_tolerance to 0.000000e+00 +Setting parameter primal_infeasible_tolerance to 1.000000e-02 +Setting parameter method to 2 +Setting parameter mip_hyper_heuristic_root_lp_time_ratio to 1.000000e-01 +Setting parameter mip_batch_pdlp_reliability_branching to 1 +Setting parameter mip_batch_pdlp_strong_branching to 1 +Setting parameter dual_infeasible_tolerance to 1.000000e-02 +Setting parameter per_constraint_residual to true +Setting parameter mip_determinism_mode to 1 +Setting parameter mip_hyper_heuristic_presolve_time_ratio to 1.000000e-01 +Setting parameter mip_cut_passes to 9 +Setting parameter mip_hyper_diving_node_limit to 500 +Setting parameter mip_hyper_diving_iteration_limit_factor to 5.000000e-02 +Setting parameter mip_hyper_heuristic_population_size to 32 +Setting parameter log_to_console to false +Setting parameter mip_absolute_tolerance to 0.000000e+00 +Setting parameter save_best_primal_so_far to true +Setting parameter mip_mixed_integer_rounding_cuts to 0 +Setting parameter mip_hyper_diving_backtrack_limit to 5 +Setting parameter mip_hyper_diving_show_type to false +Setting parameter relative_primal_tolerance to 0.000000e+00 +Setting parameter crossover to true +Setting parameter mip_scaling to 1 +Setting parameter mip_hyper_diving_pseudocost to -1 +Setting parameter mip_hyper_heuristic_relaxed_lp_time_limit to 1.000000e+00 +Setting parameter random_seed to 0 +Setting parameter work_limit to 7.200000e+03 +Setting parameter augmented to 0 +Setting parameter mip_hyper_diving_farkas to -1 +Setting parameter num_gpus to 2 +Setting parameter mip_flow_cover_cuts to 0 +Setting parameter mip_strong_chvatal_gomory_cuts to 0 +Setting parameter mip_hyper_heuristic_rins_fix_rate to 5.000000e-01 +Setting parameter user_problem_file to +Setting parameter mip_hyper_heuristic_rins_max_time_limit to 2.000000e+01 +Setting parameter absolute_gap_tolerance to 0.000000e+00 +Setting parameter mip_heuristics_only to true +Setting parameter presolve_file to 1 +Setting parameter mip_reduced_cost_strengthening to 0 +Setting parameter first_primal_feasible to true +Setting parameter infeasibility_detection to true +Setting parameter log_file to 1 +Setting parameter mip_hyper_heuristic_enabled_recombiners to 15 +Setting parameter mip_strong_branching_simplex_iteration_limit to 0 +Setting parameter barrier_step_scale to 5.000000e-01 +Setting parameter time_limit to 3.600000e+03 +Setting parameter mip_symmetry to 0 +Setting parameter mip_semi_continuous_big_m to 5.000000e+09 +Setting parameter barrier_iterative_refinement to false +Setting parameter absolute_dual_tolerance to 0.000000e+00 +Setting parameter dual_postsolve to false +Setting parameter mip_hyper_diving_min_node_depth to 10 +Setting parameter mip_hyper_heuristic_root_lp_max_time to 1.500000e+01 +Setting parameter cudss_deterministic to true +Setting parameter mip_integrality_tolerance to 0.000000e+00 +Setting parameter mip_hyper_diving_line_search to -1 +Setting parameter mip_hyper_diving_vector_length to -1 +Setting parameter barrier_dual_initial_point to 0 +Setting parameter mip_hyper_heuristic_n_of_minimums_for_exit to 7000 +Setting parameter mip_hyper_heuristic_rins_time_limit to 3.000000e+00 +Setting parameter mip_hyper_heuristic_initial_infeasibility_weight to 1.000000e+03 +Setting parameter ordering to 0 +Setting parameter mip_probing to false +Setting parameter solution_file to +Setting parameter mip_hyper_diving_guided to -1 +Setting parameter dualize to 0 +Setting parameter iteration_limit to 9999999 +Setting parameter node_limit to 2147483646 +Setting parameter pdlp_solver_mode to 3 +Setting parameter method to 2 +Setting parameter num_cpu_threads to 0 +Setting parameter augmented to 0 +Setting parameter folding to 0 +Setting parameter dualize to 0 +Setting parameter ordering to 0 +Setting parameter barrier_dual_initial_point to 0 +Setting parameter mip_cut_passes to 9 +Setting parameter mip_mixed_integer_rounding_cuts to 0 +Setting parameter mip_mixed_integer_gomory_cuts to 0 +Setting parameter mip_knapsack_cuts to 0 +Setting parameter mip_flow_cover_cuts to 0 +Setting parameter mip_clique_cuts to 0 +Setting parameter mip_implied_bound_cuts to 0 +Setting parameter mip_strong_chvatal_gomory_cuts to 0 +Setting parameter mip_reduced_cost_strengthening to 0 +Setting parameter mip_objective_step to 0 +Setting parameter num_gpus to 2 +Setting parameter num_gpus to 2 +Setting parameter mip_batch_pdlp_strong_branching to 1 +Setting parameter mip_batch_pdlp_reliability_branching to 1 +Setting parameter mip_strong_branching_simplex_iteration_limit to 0 +Setting parameter presolve to 1 +Setting parameter presolve to 1 +Setting parameter mip_determinism_mode to 1 +Setting parameter random_seed to 0 +Setting parameter mip_reliability_branching to 0 +Setting parameter pdlp_precision to 0 +Setting parameter mip_symmetry to 0 +Setting parameter mip_scaling to 1 +Setting parameter mip_hyper_heuristic_population_size to 32 +Setting parameter mip_hyper_heuristic_num_cpufj_threads to 8 +Setting parameter mip_hyper_heuristic_stagnation_trigger to 3 +Setting parameter mip_hyper_heuristic_max_iterations_without_improvement to 8 +Setting parameter mip_hyper_heuristic_n_of_minimums_for_exit to 7000 +Setting parameter mip_hyper_heuristic_enabled_recombiners to 15 +Setting parameter mip_hyper_heuristic_cycle_detection_length to 30 +Setting parameter mip_hyper_diving_line_search to -1 +Setting parameter mip_hyper_diving_pseudocost to -1 +Setting parameter mip_hyper_diving_guided to -1 +Setting parameter mip_hyper_diving_coefficient to -1 +Setting parameter mip_hyper_diving_farkas to -1 +Setting parameter mip_hyper_diving_vector_length to -1 +Setting parameter mip_hyper_diving_min_node_depth to 10 +Setting parameter mip_hyper_diving_node_limit to 500 +Setting parameter mip_hyper_diving_backtrack_limit to 5 +Setting parameter time_limit to 3.600000e+03 +Setting parameter time_limit to 3.600000e+03 +Setting parameter work_limit to 7.200000e+03 +Setting parameter absolute_dual_tolerance to 0.000000e+00 +Setting parameter relative_dual_tolerance to 0.000000e+00 +Setting parameter absolute_primal_tolerance to 0.000000e+00 +Setting parameter relative_primal_tolerance to 0.000000e+00 +Setting parameter absolute_gap_tolerance to 0.000000e+00 +Setting parameter relative_gap_tolerance to 0.000000e+00 +Setting parameter mip_absolute_tolerance to 0.000000e+00 +Setting parameter mip_relative_tolerance to 1.000000e-02 +Setting parameter mip_integrality_tolerance to 0.000000e+00 +Setting parameter mip_absolute_gap to 1.000000e-02 +Setting parameter mip_relative_gap to 2.000000e-04 +Setting parameter primal_infeasible_tolerance to 1.000000e-02 +Setting parameter dual_infeasible_tolerance to 1.000000e-02 +Setting parameter mip_cut_change_threshold to -5.000000e-01 +Setting parameter mip_cut_min_orthogonality to 0.000000e+00 +Setting parameter barrier_step_scale to 5.000000e-01 +Setting parameter mip_hyper_heuristic_presolve_time_ratio to 1.000000e-01 +Setting parameter mip_hyper_heuristic_presolve_max_time to 6.000000e+01 +Setting parameter mip_hyper_heuristic_root_lp_time_ratio to 1.000000e-01 +Setting parameter mip_hyper_heuristic_root_lp_max_time to 1.500000e+01 +Setting parameter mip_hyper_heuristic_rins_time_limit to 3.000000e+00 +Setting parameter mip_hyper_heuristic_rins_max_time_limit to 2.000000e+01 +Setting parameter mip_hyper_heuristic_rins_fix_rate to 5.000000e-01 +Setting parameter mip_hyper_heuristic_initial_infeasibility_weight to 1.000000e+03 +Setting parameter mip_hyper_heuristic_relaxed_lp_time_limit to 1.000000e+00 +Setting parameter mip_hyper_heuristic_related_vars_time_limit to 3.000000e+01 +Setting parameter mip_semi_continuous_big_m to 5.000000e+09 +Setting parameter mip_hyper_diving_iteration_limit_factor to 5.000000e-02 +Setting parameter infeasibility_detection to true +Setting parameter strict_infeasibility to true +Setting parameter per_constraint_residual to true +Setting parameter save_best_primal_so_far to true +Setting parameter first_primal_feasible to true +Setting parameter mip_heuristics_only to true +Setting parameter log_to_console to false +Setting parameter log_to_console to false +Setting parameter crossover to true +Setting parameter eliminate_dense_columns to false +Setting parameter cudss_deterministic to true +Setting parameter dual_postsolve to false +Setting parameter barrier_iterative_refinement to false +Setting parameter mip_probing to false +Setting parameter mip_hyper_diving_show_type to false +Setting parameter log_file to 1 +Setting parameter log_file to 1 +Setting parameter solution_file to +Setting parameter solution_file to +Setting parameter user_problem_file to +Setting parameter user_problem_file to +Setting parameter presolve_file to 1 +Setting parameter presolve_file to 1 +Parameters loaded from: /tmp/pytest-of-horde/pytest-0/test_solver_settings0/solver_settings_load.config +Setting parameter iteration_limit to 9999999 +Setting parameter node_limit to 2147483646 +Setting parameter pdlp_solver_mode to 3 +Setting parameter method to 2 +Setting parameter num_cpu_threads to 0 +Setting parameter augmented to 0 +Setting parameter folding to 0 +Setting parameter dualize to 0 +Setting parameter ordering to 0 +Setting parameter barrier_dual_initial_point to 0 +Setting parameter mip_cut_passes to 9 +Setting parameter mip_mixed_integer_rounding_cuts to 0 +Setting parameter mip_mixed_integer_gomory_cuts to 0 +Setting parameter mip_knapsack_cuts to 0 +Setting parameter mip_flow_cover_cuts to 0 +Setting parameter mip_clique_cuts to 0 +Setting parameter mip_implied_bound_cuts to 0 +Setting parameter mip_strong_chvatal_gomory_cuts to 0 +Setting parameter mip_reduced_cost_strengthening to 0 +Setting parameter mip_objective_step to 0 +Setting parameter num_gpus to 2 +Setting parameter mip_batch_pdlp_strong_branching to 1 +Setting parameter mip_batch_pdlp_reliability_branching to 1 +Setting parameter mip_strong_branching_simplex_iteration_limit to 0 +Setting parameter presolve to 1 +Setting parameter mip_determinism_mode to 1 +Setting parameter random_seed to 0 +Setting parameter mip_reliability_branching to 0 +Setting parameter pdlp_precision to 0 +Setting parameter mip_symmetry to 0 +Setting parameter mip_scaling to 1 +Setting parameter mip_hyper_heuristic_population_size to 32 +Setting parameter mip_hyper_heuristic_num_cpufj_threads to 8 +Setting parameter mip_hyper_heuristic_stagnation_trigger to 3 +Setting parameter mip_hyper_heuristic_max_iterations_without_improvement to 8 +Setting parameter mip_hyper_heuristic_n_of_minimums_for_exit to 7000 +Setting parameter mip_hyper_heuristic_enabled_recombiners to 15 +Setting parameter mip_hyper_heuristic_cycle_detection_length to 30 +Setting parameter mip_hyper_diving_line_search to -1 +Setting parameter mip_hyper_diving_pseudocost to -1 +Setting parameter mip_hyper_diving_guided to -1 +Setting parameter mip_hyper_diving_coefficient to -1 +Setting parameter mip_hyper_diving_farkas to -1 +Setting parameter mip_hyper_diving_vector_length to -1 +Setting parameter mip_hyper_diving_min_node_depth to 10 +Setting parameter mip_hyper_diving_node_limit to 500 +Setting parameter mip_hyper_diving_backtrack_limit to 5 +Setting parameter time_limit to 3.600000e+03 +Setting parameter work_limit to 7.200000e+03 +Setting parameter absolute_dual_tolerance to 0.000000e+00 +Setting parameter relative_dual_tolerance to 0.000000e+00 +Setting parameter absolute_primal_tolerance to 0.000000e+00 +Setting parameter relative_primal_tolerance to 0.000000e+00 +Setting parameter absolute_gap_tolerance to 0.000000e+00 +Setting parameter relative_gap_tolerance to 0.000000e+00 +Setting parameter mip_absolute_tolerance to 0.000000e+00 +Setting parameter mip_relative_tolerance to 1.000000e-02 +Setting parameter mip_integrality_tolerance to 0.000000e+00 +Setting parameter mip_absolute_gap to 1.000000e-02 +Setting parameter mip_relative_gap to 2.000000e-04 +Setting parameter primal_infeasible_tolerance to 1.000000e-02 +Setting parameter dual_infeasible_tolerance to 1.000000e-02 +Setting parameter mip_cut_change_threshold to -5.000000e-01 +Setting parameter mip_cut_min_orthogonality to 0.000000e+00 +Setting parameter barrier_step_scale to 5.000000e-01 +Setting parameter mip_hyper_heuristic_presolve_time_ratio to 1.000000e-01 +Setting parameter mip_hyper_heuristic_presolve_max_time to 6.000000e+01 +Setting parameter mip_hyper_heuristic_root_lp_time_ratio to 1.000000e-01 +Setting parameter mip_hyper_heuristic_root_lp_max_time to 1.500000e+01 +Setting parameter mip_hyper_heuristic_rins_time_limit to 3.000000e+00 +Setting parameter mip_hyper_heuristic_rins_max_time_limit to 2.000000e+01 +Setting parameter mip_hyper_heuristic_rins_fix_rate to 5.000000e-01 +Setting parameter mip_hyper_heuristic_initial_infeasibility_weight to 1.000000e+03 +Setting parameter mip_hyper_heuristic_relaxed_lp_time_limit to 1.000000e+00 +Setting parameter mip_hyper_heuristic_related_vars_time_limit to 3.000000e+01 +Setting parameter mip_semi_continuous_big_m to 5.000000e+09 +Setting parameter mip_hyper_diving_iteration_limit_factor to 5.000000e-02 +Setting parameter infeasibility_detection to true +Setting parameter strict_infeasibility to true +Setting parameter per_constraint_residual to true +Setting parameter save_best_primal_so_far to true +Setting parameter first_primal_feasible to true +Setting parameter mip_heuristics_only to true +Setting parameter log_to_console to false +Setting parameter crossover to true +Setting parameter eliminate_dense_columns to false +Setting parameter cudss_deterministic to true +Setting parameter dual_postsolve to false +Setting parameter barrier_iterative_refinement to false +Setting parameter mip_probing to false +Setting parameter mip_hyper_diving_show_type to false +Setting parameter log_file to 1 +Setting parameter solution_file to +Setting parameter user_problem_file to +Setting parameter presolve_file to 1 +Setting parameter iteration_limit to 9999999 +Setting parameter node_limit to 2147483646 +Setting parameter pdlp_solver_mode to 3 +Setting parameter method to 2 +Setting parameter num_cpu_threads to 0 +Setting parameter augmented to 0 +Setting parameter folding to 0 +Setting parameter dualize to 0 +Setting parameter ordering to 0 +Setting parameter barrier_dual_initial_point to 0 +Setting parameter mip_cut_passes to 9 +Setting parameter mip_mixed_integer_rounding_cuts to 0 +Setting parameter mip_mixed_integer_gomory_cuts to 0 +Setting parameter mip_knapsack_cuts to 0 +Setting parameter mip_flow_cover_cuts to 0 +Setting parameter mip_clique_cuts to 0 +Setting parameter mip_implied_bound_cuts to 0 +Setting parameter mip_strong_chvatal_gomory_cuts to 0 +Setting parameter mip_reduced_cost_strengthening to 0 +Setting parameter mip_objective_step to 0 +Setting parameter num_gpus to 2 +Setting parameter mip_batch_pdlp_strong_branching to 1 +Setting parameter mip_batch_pdlp_reliability_branching to 1 +Setting parameter mip_strong_branching_simplex_iteration_limit to 0 +Setting parameter presolve to 1 +Setting parameter mip_determinism_mode to 1 +Setting parameter random_seed to 0 +Setting parameter mip_reliability_branching to 0 +Setting parameter pdlp_precision to 0 +Setting parameter mip_symmetry to 0 +Setting parameter mip_scaling to 1 +Setting parameter mip_hyper_heuristic_population_size to 32 +Setting parameter mip_hyper_heuristic_num_cpufj_threads to 8 +Setting parameter mip_hyper_heuristic_stagnation_trigger to 3 +Setting parameter mip_hyper_heuristic_max_iterations_without_improvement to 8 +Setting parameter mip_hyper_heuristic_n_of_minimums_for_exit to 7000 +Setting parameter mip_hyper_heuristic_enabled_recombiners to 15 +Setting parameter mip_hyper_heuristic_cycle_detection_length to 30 +Setting parameter mip_hyper_diving_line_search to -1 +Setting parameter mip_hyper_diving_pseudocost to -1 +Setting parameter mip_hyper_diving_guided to -1 +Setting parameter mip_hyper_diving_coefficient to -1 +Setting parameter mip_hyper_diving_farkas to -1 +Setting parameter mip_hyper_diving_vector_length to -1 +Setting parameter mip_hyper_diving_min_node_depth to 10 +Setting parameter mip_hyper_diving_node_limit to 500 +Setting parameter mip_hyper_diving_backtrack_limit to 5 +Setting parameter time_limit to 3.600000e+03 +Setting parameter work_limit to 7.200000e+03 +Setting parameter absolute_dual_tolerance to 0.000000e+00 +Setting parameter relative_dual_tolerance to 0.000000e+00 +Setting parameter absolute_primal_tolerance to 0.000000e+00 +Setting parameter relative_primal_tolerance to 0.000000e+00 +Setting parameter absolute_gap_tolerance to 0.000000e+00 +Setting parameter relative_gap_tolerance to 0.000000e+00 +Setting parameter mip_absolute_tolerance to 0.000000e+00 +Setting parameter mip_relative_tolerance to 1.000000e-02 +Setting parameter mip_integrality_tolerance to 0.000000e+00 +Setting parameter mip_absolute_gap to 1.000000e-02 +Setting parameter mip_relative_gap to 2.000000e-04 +Setting parameter primal_infeasible_tolerance to 1.000000e-02 +Setting parameter dual_infeasible_tolerance to 1.000000e-02 +Setting parameter mip_cut_change_threshold to -5.000000e-01 +Setting parameter mip_cut_min_orthogonality to 0.000000e+00 +Setting parameter barrier_step_scale to 5.000000e-01 +Setting parameter mip_hyper_heuristic_presolve_time_ratio to 1.000000e-01 +Setting parameter mip_hyper_heuristic_presolve_max_time to 6.000000e+01 +Setting parameter mip_hyper_heuristic_root_lp_time_ratio to 1.000000e-01 +Setting parameter mip_hyper_heuristic_root_lp_max_time to 1.500000e+01 +Setting parameter mip_hyper_heuristic_rins_time_limit to 3.000000e+00 +Setting parameter mip_hyper_heuristic_rins_max_time_limit to 2.000000e+01 +Setting parameter mip_hyper_heuristic_rins_fix_rate to 5.000000e-01 +Setting parameter mip_hyper_heuristic_initial_infeasibility_weight to 1.000000e+03 +Setting parameter mip_hyper_heuristic_relaxed_lp_time_limit to 1.000000e+00 +Setting parameter mip_hyper_heuristic_related_vars_time_limit to 3.000000e+01 +Setting parameter mip_semi_continuous_big_m to 5.000000e+09 +Setting parameter mip_hyper_diving_iteration_limit_factor to 5.000000e-02 +Setting parameter infeasibility_detection to true +Setting parameter strict_infeasibility to true +Setting parameter per_constraint_residual to true +Setting parameter save_best_primal_so_far to true +Setting parameter first_primal_feasible to true +Setting parameter mip_heuristics_only to true +Setting parameter log_to_console to false +Setting parameter crossover to true +Setting parameter eliminate_dense_columns to false +Setting parameter cudss_deterministic to true +Setting parameter dual_postsolve to false +Setting parameter barrier_iterative_refinement to false +Setting parameter mip_probing to false +Setting parameter mip_hyper_diving_show_type to false +Setting parameter log_file to 1 +Setting parameter solution_file to +Setting parameter user_problem_file to +Setting parameter presolve_file to 1 +cuOpt version: 26.8.0, git hash: 03fe3fc4, host arch: x86_64, device archs: 89-real +CPU: Intel(R) Xeon(R) Platinum 8362 CPU @ 2.80GHz, threads (physical/logical): 64/128, RAM: 890.33 GiB +CUDA 12.9, device: NVIDIA L40 (ID 0), VRAM: 47.38 GiB +CUDA device UUID: ce15376b-c11d-6252-d099-c87a5667ce97 + +Solving a problem with 2 constraints, 1 variables (0 integers), and 2 nonzeros +Problem scaling: +Objective coefficents range: [1e+00, 1e+00] +Constraint matrix coefficients range: [1e+00, 1e+00] +Constraint rhs / bounds range: [0e+00, 1e+00] +Variable bounds range: [0e+00, 0e+00] + +Original problem: 2 constraints, 1 variables, 2 nonzeros +Calling Papilo presolver (git hash 741a2b9c) +Presolve status: reduced the problem +Presolve removed: 2 constraints, 1 variables, 2 nonzeros +Presolved problem: 0 constraints, 0 variables (0 integer), 0 nonzeros +Optimal solution found during presolve +Presolve completely solved the problem +Papilo presolve time: 0.00s +Status: Optimal Objective: 0.000000 diff --git a/benchmarks/linear_programming/cuopt/benchmark_helper.hpp b/benchmarks/linear_programming/cuopt/benchmark_helper.hpp index 2f6de22c6b..af6cc1deb7 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 @@ -59,7 +59,7 @@ void parse_value(std::istringstream& iss, bool& value) void fill_pdlp_hyper_params( const std::string& pdlp_hyper_params_path, - cuopt::linear_programming::pdlp_hyper_params::pdlp_hyper_params_t& params) + cuopt::math_optimization::pdlp_hyper_params::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,7 +205,7 @@ 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, +void write_problem_info(const cuopt::math_optimization::io::mps_data_model_t& op_problem, const std::string& filename) { std::ofstream file(filename); @@ -222,7 +222,7 @@ 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, +void read_problem_info(cuopt::math_optimization::optimization_problem_t& op_problem, const std::string& filename) { std::ifstream file(filename); @@ -274,8 +274,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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_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..9bc43a0d1e 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::math_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..64f88d885e 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::math_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::math_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::math_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::math_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::math_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::math_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::math_optimization::mip_termination_status_t::FeasibleFound || solution.get_termination_status() == - cuopt::linear_programming::mip_termination_status_t::Optimal); + cuopt::math_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::math_optimization::mip_termination_status_t::Optimal: _status_str = "Optimal"; break; - case cuopt::linear_programming::mip_termination_status_t::FeasibleFound: + case cuopt::math_optimization::mip_termination_status_t::FeasibleFound: _status_str = "FeasibleFound"; break; - case cuopt::linear_programming::mip_termination_status_t::TimeLimit: + case cuopt::math_optimization::mip_termination_status_t::TimeLimit: _status_str = "TimeLimit"; break; - case cuopt::linear_programming::mip_termination_status_t::Infeasible: + case cuopt::math_optimization::mip_termination_status_t::Infeasible: _status_str = "Infeasible"; break; default: _status_str = "Other"; break; @@ -280,10 +280,10 @@ int run_single_file(std::string file_path, std::stringstream ss; 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 - ? 1 - : 0; + int is_optimal = + solution.get_termination_status() == cuopt::math_optimization::mip_termination_status_t::Optimal + ? 1 + : 0; ss << std::fixed << std::setprecision(decimal_places) << base_filename << "," << sol_found << "," << obj_val << "," << benchmark_info.objective_of_initial_population << "," << benchmark_info.last_improvement_of_best_feasible << "," diff --git a/benchmarks/linear_programming/cuopt/run_pdlp.cu b/benchmarks/linear_programming/cuopt/run_pdlp.cu index c88e5657df..467e7b16fa 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,50 @@ 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::math_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::math_optimization::presolver_t::None; + if (presolver == "Papilo") return cuopt::math_optimization::presolver_t::Papilo; + if (presolver == "PSLP") return cuopt::math_optimization::presolver_t::PSLP; + if (presolver == "Default") return cuopt::math_optimization::presolver_t::Default; + return cuopt::math_optimization::presolver_t::Default; } -static cuopt::linear_programming::pdlp_precision_t string_to_pdlp_precision( +static cuopt::math_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::math_optimization::pdlp_precision_t::SinglePrecision; + if (precision == "double") return cuopt::math_optimization::pdlp_precision_t::DoublePrecision; + if (precision == "mixed") return cuopt::math_optimization::pdlp_precision_t::MixedPrecision; + return cuopt::math_optimization::pdlp_precision_t::DefaultPrecision; } -static cuopt::linear_programming::pdlp_solver_mode_t string_to_pdlp_solver_mode( +static cuopt::math_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::math_optimization::pdlp_solver_mode_t::Stable1; if (mode == "Stable2") - return cuopt::linear_programming::pdlp_solver_mode_t::Stable2; + return cuopt::math_optimization::pdlp_solver_mode_t::Stable2; else if (mode == "Methodical1") - return cuopt::linear_programming::pdlp_solver_mode_t::Methodical1; + return cuopt::math_optimization::pdlp_solver_mode_t::Methodical1; else if (mode == "Fast1") - return cuopt::linear_programming::pdlp_solver_mode_t::Fast1; + return cuopt::math_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::math_optimization::pdlp_solver_mode_t::Stable3; + return cuopt::math_optimization::pdlp_solver_mode_t::Stable3; } -static cuopt::linear_programming::pdlp_solver_settings_t create_solver_settings( +static cuopt::math_optimization::pdlp_solver_settings_t create_solver_settings( const argparse::ArgumentParser& program) { - cuopt::linear_programming::pdlp_solver_settings_t settings{}; + cuopt::math_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 +148,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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_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::math_optimization::optimization_problem_solution_t solution = + cuopt::math_optimization::solve_lp( &handle_, op_problem, settings, problem_checking, use_pdlp_solver_mode); // Write solution to file if requested diff --git a/best_results.txt b/best_results.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/ci/test_doc_examples.sh b/ci/test_doc_examples.sh index 4bf7243d89..aae968a058 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 "*/math_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/math_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/math_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..28cc508fb1 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::math_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::math_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::math_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::math_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,34 @@ 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::math_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::math_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::math_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::math_optimization::problem_category_t::MIP || problem_interface->get_problem_category() == - cuopt::linear_programming::problem_category_t::IP) && + cuopt::math_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::math_optimization::solution_reader_t::get_variable_values_from_sol_file( initial_solution_file, mps_data_model.get_variable_names()); if (is_mip) { @@ -173,10 +173,10 @@ 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::math_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::math_optimization::solve_lp(problem_interface.get(), lp_settings); } } catch (const std::exception& e) { fprintf(stderr, "cuopt_cli error: %s\n", e.what()); @@ -259,12 +259,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::math_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::math_optimization::solver_settings_t settings; settings.dump_parameters_to_file("/dev/stdout", false); return 0; } @@ -327,7 +327,7 @@ int main(int argc, char* argv[]) { // Add all solver settings as arguments - cuopt::linear_programming::solver_settings_t dummy_settings; + cuopt::math_optimization::solver_settings_t dummy_settings; auto int_params = dummy_settings.get_int_parameters(); auto double_params = dummy_settings.get_float_parameters(); @@ -404,7 +404,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::math_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 +417,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::math_optimization::get_memory_backend_type(); std::vector memory_resources; - if (memory_backend == cuopt::linear_programming::memory_backend_t::GPU) { + if (memory_backend == cuopt::math_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..9e126686f7 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/math_optimization/cuopt_c.h \ + ../include/cuopt/math_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..b0bd95373a 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/math_optimization/constants.h" #include diff --git a/cpp/include/cuopt/linear_programming/backend_selection.hpp b/cpp/include/cuopt/math_optimization/backend_selection.hpp similarity index 95% rename from cpp/include/cuopt/linear_programming/backend_selection.hpp rename to cpp/include/cuopt/math_optimization/backend_selection.hpp index 26bcd942a3..3c86e906cd 100644 --- a/cpp/include/cuopt/linear_programming/backend_selection.hpp +++ b/cpp/include/cuopt/math_optimization/backend_selection.hpp @@ -7,7 +7,7 @@ #pragma once -namespace cuopt::linear_programming { +namespace cuopt::math_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::math_optimization diff --git a/cpp/include/cuopt/linear_programming/constants.h b/cpp/include/cuopt/math_optimization/constants.h similarity index 100% rename from cpp/include/cuopt/linear_programming/constants.h rename to cpp/include/cuopt/math_optimization/constants.h diff --git a/cpp/include/cuopt/linear_programming/cpu_optimization_problem.hpp b/cpp/include/cuopt/math_optimization/cpu_optimization_problem.hpp similarity index 98% rename from cpp/include/cuopt/linear_programming/cpu_optimization_problem.hpp rename to cpp/include/cuopt/math_optimization/cpu_optimization_problem.hpp index 76258ec0bd..9dc38ba5b3 100644 --- a/cpp/include/cuopt/linear_programming/cpu_optimization_problem.hpp +++ b/cpp/include/cuopt/math_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::math_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::math_optimization diff --git a/cpp/include/cuopt/linear_programming/cpu_optimization_problem_solution.hpp b/cpp/include/cuopt/math_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/math_optimization/cpu_optimization_problem_solution.hpp index e86dd0341a..45978e7320 100644 --- a/cpp/include/cuopt/linear_programming/cpu_optimization_problem_solution.hpp +++ b/cpp/include/cuopt/math_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::math_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::math_optimization diff --git a/cpp/include/cuopt/linear_programming/cpu_pdlp_warm_start_data.hpp b/cpp/include/cuopt/math_optimization/cpu_pdlp_warm_start_data.hpp similarity index 97% rename from cpp/include/cuopt/linear_programming/cpu_pdlp_warm_start_data.hpp rename to cpp/include/cuopt/math_optimization/cpu_pdlp_warm_start_data.hpp index 51e98275ed..21f0a5d65f 100644 --- a/cpp/include/cuopt/linear_programming/cpu_pdlp_warm_start_data.hpp +++ b/cpp/include/cuopt/math_optimization/cpu_pdlp_warm_start_data.hpp @@ -7,10 +7,10 @@ #pragma once -#include +#include #include -namespace cuopt::linear_programming { +namespace cuopt::math_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::math_optimization diff --git a/cpp/include/cuopt/linear_programming/csr_matrix_utils.hpp b/cpp/include/cuopt/math_optimization/csr_matrix_utils.hpp similarity index 97% rename from cpp/include/cuopt/linear_programming/csr_matrix_utils.hpp rename to cpp/include/cuopt/math_optimization/csr_matrix_utils.hpp index cd93dc96fe..9b1726d1b7 100644 --- a/cpp/include/cuopt/linear_programming/csr_matrix_utils.hpp +++ b/cpp/include/cuopt/math_optimization/csr_matrix_utils.hpp @@ -12,7 +12,7 @@ #include #include -namespace cuopt::linear_programming { +namespace cuopt::math_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::math_optimization diff --git a/cpp/include/cuopt/linear_programming/cuopt_c.h b/cpp/include/cuopt/math_optimization/cuopt_c.h similarity index 99% rename from cpp/include/cuopt/linear_programming/cuopt_c.h rename to cpp/include/cuopt/math_optimization/cuopt_c.h index 4426b640de..ccc12850f5 100644 --- a/cpp/include/cuopt/linear_programming/cuopt_c.h +++ b/cpp/include/cuopt/math_optimization/cuopt_c.h @@ -8,7 +8,7 @@ #ifndef CUOPT_C_API_H #define CUOPT_C_API_H -#include +#include #include diff --git a/cpp/include/cuopt/linear_programming/io/data_model_view.hpp b/cpp/include/cuopt/math_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/math_optimization/io/data_model_view.hpp index 4d62458263..9784524dbf 100644 --- a/cpp/include/cuopt/linear_programming/io/data_model_view.hpp +++ b/cpp/include/cuopt/math_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::math_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::math_optimization::io diff --git a/cpp/include/cuopt/linear_programming/io/mps_data_model.hpp b/cpp/include/cuopt/math_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/math_optimization/io/mps_data_model.hpp index 145dee51ef..c857ed08b5 100644 --- a/cpp/include/cuopt/linear_programming/io/mps_data_model.hpp +++ b/cpp/include/cuopt/math_optimization/io/mps_data_model.hpp @@ -13,7 +13,7 @@ #include #include -namespace cuopt::linear_programming::io { +namespace cuopt::math_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::math_optimization::io diff --git a/cpp/include/cuopt/linear_programming/io/mps_writer.hpp b/cpp/include/cuopt/math_optimization/io/mps_writer.hpp similarity index 88% rename from cpp/include/cuopt/linear_programming/io/mps_writer.hpp rename to cpp/include/cuopt/math_optimization/io/mps_writer.hpp index 86350dda2b..f75f8fd4a0 100644 --- a/cpp/include/cuopt/linear_programming/io/mps_writer.hpp +++ b/cpp/include/cuopt/math_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::math_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::math_optimization::io diff --git a/cpp/include/cuopt/linear_programming/io/parser.hpp b/cpp/include/cuopt/math_optimization/io/parser.hpp similarity index 97% rename from cpp/include/cuopt/linear_programming/io/parser.hpp rename to cpp/include/cuopt/math_optimization/io/parser.hpp index a63e40f31f..dfe7a6445c 100644 --- a/cpp/include/cuopt/linear_programming/io/parser.hpp +++ b/cpp/include/cuopt/math_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::math_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::math_optimization::io diff --git a/cpp/include/cuopt/linear_programming/io/utilities/cython_parser.hpp b/cpp/include/cuopt/math_optimization/io/utilities/cython_parser.hpp similarity index 64% rename from cpp/include/cuopt/linear_programming/io/utilities/cython_parser.hpp rename to cpp/include/cuopt/math_optimization/io/utilities/cython_parser.hpp index 711f1c73b2..a195e0c426 100644 --- a/cpp/include/cuopt/linear_programming/io/utilities/cython_parser.hpp +++ b/cpp/include/cuopt/math_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/math_optimization/io/writer.hpp similarity index 81% rename from cpp/include/cuopt/linear_programming/io/writer.hpp rename to cpp/include/cuopt/math_optimization/io/writer.hpp index d31f1009ab..dfdb288085 100644 --- a/cpp/include/cuopt/linear_programming/io/writer.hpp +++ b/cpp/include/cuopt/math_optimization/io/writer.hpp @@ -7,9 +7,9 @@ #pragma once -#include +#include -namespace cuopt::linear_programming::io { +namespace cuopt::math_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::math_optimization::io diff --git a/cpp/include/cuopt/linear_programming/mip/diving_hyper_params.hpp b/cpp/include/cuopt/math_optimization/mip/diving_hyper_params.hpp similarity index 96% rename from cpp/include/cuopt/linear_programming/mip/diving_hyper_params.hpp rename to cpp/include/cuopt/math_optimization/mip/diving_hyper_params.hpp index 19463b9150..0dd20d49bc 100644 --- a/cpp/include/cuopt/linear_programming/mip/diving_hyper_params.hpp +++ b/cpp/include/cuopt/math_optimization/mip/diving_hyper_params.hpp @@ -7,7 +7,7 @@ #pragma once -namespace cuopt::linear_programming { +namespace cuopt::math_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::math_optimization diff --git a/cpp/include/cuopt/linear_programming/mip/heuristics_hyper_params.hpp b/cpp/include/cuopt/math_optimization/mip/heuristics_hyper_params.hpp similarity index 96% rename from cpp/include/cuopt/linear_programming/mip/heuristics_hyper_params.hpp rename to cpp/include/cuopt/math_optimization/mip/heuristics_hyper_params.hpp index 71bbbe169a..582b4b5ba6 100644 --- a/cpp/include/cuopt/linear_programming/mip/heuristics_hyper_params.hpp +++ b/cpp/include/cuopt/math_optimization/mip/heuristics_hyper_params.hpp @@ -7,7 +7,7 @@ #pragma once -namespace cuopt::linear_programming { +namespace cuopt::math_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::math_optimization diff --git a/cpp/include/cuopt/linear_programming/mip/solver_settings.hpp b/cpp/include/cuopt/math_optimization/mip/solver_settings.hpp similarity index 95% rename from cpp/include/cuopt/linear_programming/mip/solver_settings.hpp rename to cpp/include/cuopt/math_optimization/mip/solver_settings.hpp index f995d434f0..215952d643 100644 --- a/cpp/include/cuopt/linear_programming/mip/solver_settings.hpp +++ b/cpp/include/cuopt/math_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::math_optimization { struct benchmark_info_t { double last_improvement_of_best_feasible = 0; @@ -235,4 +235,4 @@ struct mip_solver_settings_accessor { } // namespace detail -} // namespace cuopt::linear_programming +} // namespace cuopt::math_optimization diff --git a/cpp/include/cuopt/linear_programming/mip/solver_solution.hpp b/cpp/include/cuopt/math_optimization/mip/solver_solution.hpp similarity index 93% rename from cpp/include/cuopt/linear_programming/mip/solver_solution.hpp rename to cpp/include/cuopt/math_optimization/mip/solver_solution.hpp index b8fa884540..c5cc9b72c5 100644 --- a/cpp/include/cuopt/linear_programming/mip/solver_solution.hpp +++ b/cpp/include/cuopt/math_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::math_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::math_optimization diff --git a/cpp/include/cuopt/linear_programming/mip/solver_stats.hpp b/cpp/include/cuopt/math_optimization/mip/solver_stats.hpp similarity index 94% rename from cpp/include/cuopt/linear_programming/mip/solver_stats.hpp rename to cpp/include/cuopt/math_optimization/mip/solver_stats.hpp index a546354a65..b29b9efafe 100644 --- a/cpp/include/cuopt/linear_programming/mip/solver_stats.hpp +++ b/cpp/include/cuopt/math_optimization/mip/solver_stats.hpp @@ -8,7 +8,7 @@ #include #include -namespace cuopt::linear_programming { +namespace cuopt::math_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::math_optimization diff --git a/cpp/include/cuopt/linear_programming/optimization_problem.hpp b/cpp/include/cuopt/math_optimization/optimization_problem.hpp similarity index 98% rename from cpp/include/cuopt/linear_programming/optimization_problem.hpp rename to cpp/include/cuopt/math_optimization/optimization_problem.hpp index 1b9302978b..a7f39bc4b3 100644 --- a/cpp/include/cuopt/linear_programming/optimization_problem.hpp +++ b/cpp/include/cuopt/math_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::math_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::math_optimization diff --git a/cpp/include/cuopt/linear_programming/optimization_problem_interface.hpp b/cpp/include/cuopt/math_optimization/optimization_problem_interface.hpp similarity index 99% rename from cpp/include/cuopt/linear_programming/optimization_problem_interface.hpp rename to cpp/include/cuopt/math_optimization/optimization_problem_interface.hpp index e39d180d7a..43b008c62f 100644 --- a/cpp/include/cuopt/linear_programming/optimization_problem_interface.hpp +++ b/cpp/include/cuopt/math_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::math_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::math_optimization diff --git a/cpp/include/cuopt/linear_programming/optimization_problem_solution.hpp b/cpp/include/cuopt/math_optimization/optimization_problem_solution.hpp similarity index 97% rename from cpp/include/cuopt/linear_programming/optimization_problem_solution.hpp rename to cpp/include/cuopt/math_optimization/optimization_problem_solution.hpp index ac55256973..5929421296 100644 --- a/cpp/include/cuopt/linear_programming/optimization_problem_solution.hpp +++ b/cpp/include/cuopt/math_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::math_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::math_optimization diff --git a/cpp/include/cuopt/linear_programming/optimization_problem_solution_interface.hpp b/cpp/include/cuopt/math_optimization/optimization_problem_solution_interface.hpp similarity index 97% rename from cpp/include/cuopt/linear_programming/optimization_problem_solution_interface.hpp rename to cpp/include/cuopt/math_optimization/optimization_problem_solution_interface.hpp index 3dc1678c8b..77b6b07bfd 100644 --- a/cpp/include/cuopt/linear_programming/optimization_problem_solution_interface.hpp +++ b/cpp/include/cuopt/math_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::math_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::math_optimization diff --git a/cpp/include/cuopt/linear_programming/optimization_problem_utils.hpp b/cpp/include/cuopt/math_optimization/optimization_problem_utils.hpp similarity index 96% rename from cpp/include/cuopt/linear_programming/optimization_problem_utils.hpp rename to cpp/include/cuopt/math_optimization/optimization_problem_utils.hpp index f6599c4ea6..44bea5f0ad 100644 --- a/cpp/include/cuopt/linear_programming/optimization_problem_utils.hpp +++ b/cpp/include/cuopt/math_optimization/optimization_problem_utils.hpp @@ -8,13 +8,13 @@ #pragma once #include -#include -#include -#include -#include -#include +#include +#include +#include +#include +#include -namespace cuopt::linear_programming { +namespace cuopt::math_optimization { namespace detail { @@ -156,7 +156,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::math_optimization::io::data_model_view_t* data_model, solver_settings_t* solver_settings = nullptr, const raft::handle_t* handle = nullptr) { @@ -300,4 +300,4 @@ void populate_from_data_model_view( } } -} // namespace cuopt::linear_programming +} // namespace cuopt::math_optimization diff --git a/cpp/include/cuopt/linear_programming/pdlp/pdlp_hyper_params.cuh b/cpp/include/cuopt/math_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/math_optimization/pdlp/pdlp_hyper_params.cuh index 282e91d7ef..12263193a0 100644 --- a/cpp/include/cuopt/linear_programming/pdlp/pdlp_hyper_params.cuh +++ b/cpp/include/cuopt/math_optimization/pdlp/pdlp_hyper_params.cuh @@ -7,7 +7,7 @@ #pragma once -namespace cuopt::linear_programming::pdlp_hyper_params { +namespace cuopt::math_optimization::pdlp_hyper_params { 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::math_optimization::pdlp_hyper_params diff --git a/cpp/include/cuopt/linear_programming/pdlp/pdlp_warm_start_data.hpp b/cpp/include/cuopt/math_optimization/pdlp/pdlp_warm_start_data.hpp similarity index 98% rename from cpp/include/cuopt/linear_programming/pdlp/pdlp_warm_start_data.hpp rename to cpp/include/cuopt/math_optimization/pdlp/pdlp_warm_start_data.hpp index c4602b4d48..75603544bb 100644 --- a/cpp/include/cuopt/linear_programming/pdlp/pdlp_warm_start_data.hpp +++ b/cpp/include/cuopt/math_optimization/pdlp/pdlp_warm_start_data.hpp @@ -11,7 +11,7 @@ #include -namespace cuopt::linear_programming { +namespace cuopt::math_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::math_optimization diff --git a/cpp/include/cuopt/linear_programming/pdlp/solver_settings.hpp b/cpp/include/cuopt/math_optimization/pdlp/solver_settings.hpp similarity index 97% rename from cpp/include/cuopt/linear_programming/pdlp/solver_settings.hpp rename to cpp/include/cuopt/math_optimization/pdlp/solver_settings.hpp index b30286f9ce..fb84701acf 100644 --- a/cpp/include/cuopt/linear_programming/pdlp/solver_settings.hpp +++ b/cpp/include/cuopt/math_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::math_optimization { // Forward declare solver_settings_t for friend class template @@ -351,4 +351,4 @@ class pdlp_solver_settings_t { friend class solver_settings_t; }; -} // namespace cuopt::linear_programming +} // namespace cuopt::math_optimization diff --git a/cpp/include/cuopt/linear_programming/pdlp/solver_solution.hpp b/cpp/include/cuopt/math_optimization/pdlp/solver_solution.hpp similarity index 97% rename from cpp/include/cuopt/linear_programming/pdlp/solver_solution.hpp rename to cpp/include/cuopt/math_optimization/pdlp/solver_solution.hpp index 81e911df62..5140f0e1cd 100644 --- a/cpp/include/cuopt/linear_programming/pdlp/solver_solution.hpp +++ b/cpp/include/cuopt/math_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::math_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::math_optimization diff --git a/cpp/include/cuopt/linear_programming/solve.hpp b/cpp/include/cuopt/math_optimization/solve.hpp similarity index 89% rename from cpp/include/cuopt/linear_programming/solve.hpp rename to cpp/include/cuopt/math_optimization/solve.hpp index 42325d296c..350bb2a8a5 100644 --- a/cpp/include/cuopt/linear_programming/solve.hpp +++ b/cpp/include/cuopt/math_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::math_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::math_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); @@ -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::math_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::math_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::math_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::math_optimization diff --git a/cpp/include/cuopt/linear_programming/solve_remote.hpp b/cpp/include/cuopt/math_optimization/solve_remote.hpp similarity index 89% rename from cpp/include/cuopt/linear_programming/solve_remote.hpp rename to cpp/include/cuopt/math_optimization/solve_remote.hpp index b9e309c89c..109e2d14df 100644 --- a/cpp/include/cuopt/linear_programming/solve_remote.hpp +++ b/cpp/include/cuopt/math_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::math_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::math_optimization diff --git a/cpp/include/cuopt/linear_programming/solver_settings.hpp b/cpp/include/cuopt/math_optimization/solver_settings.hpp similarity index 92% rename from cpp/include/cuopt/linear_programming/solver_settings.hpp rename to cpp/include/cuopt/math_optimization/solver_settings.hpp index 1720b0e9f9..1d3972567f 100644 --- a/cpp/include/cuopt/linear_programming/solver_settings.hpp +++ b/cpp/include/cuopt/math_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::math_optimization { template class solver_settings_t { @@ -109,4 +109,4 @@ class solver_settings_t { std::vector> string_parameters; }; -} // namespace cuopt::linear_programming +} // namespace cuopt::math_optimization diff --git a/cpp/include/cuopt/linear_programming/utilities/callbacks_implems.hpp b/cpp/include/cuopt/math_optimization/utilities/callbacks_implems.hpp similarity index 98% rename from cpp/include/cuopt/linear_programming/utilities/callbacks_implems.hpp rename to cpp/include/cuopt/math_optimization/utilities/callbacks_implems.hpp index ef0fe35b98..5c5892e853 100644 --- a/cpp/include/cuopt/linear_programming/utilities/callbacks_implems.hpp +++ b/cpp/include/cuopt/math_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/math_optimization/utilities/cython_solve.hpp similarity index 56% rename from cpp/include/cuopt/linear_programming/utilities/cython_solve.hpp rename to cpp/include/cuopt/math_optimization/utilities/cython_solve.hpp index 9f4fc93923..24c4b5c699 100644 --- a/cpp/include/cuopt/linear_programming/utilities/cython_solve.hpp +++ b/cpp/include/cuopt/math_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; + math_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, +math_optimization::lp_solution_interface_t* call_solve_lp( + math_optimization::optimization_problem_interface_t* problem_interface, + math_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); +math_optimization::mip_solution_interface_t* call_solve_mip( + math_optimization::optimization_problem_interface_t* problem_interface, + math_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::math_optimization::io::data_model_view_t*, + math_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*>, + math_optimization::solver_settings_t*); std::pair>, double> call_batch_solve( - std::vector*>, - linear_programming::solver_settings_t*); + std::vector*>, + math_optimization::solver_settings_t*); } // namespace cython } // namespace cuopt diff --git a/cpp/include/cuopt/linear_programming/utilities/cython_types.hpp b/cpp/include/cuopt/math_optimization/utilities/cython_types.hpp similarity index 89% rename from cpp/include/cuopt/linear_programming/utilities/cython_types.hpp rename to cpp/include/cuopt/math_optimization/utilities/cython_types.hpp index 20db133512..f9f071bac2 100644 --- a/cpp/include/cuopt/linear_programming/utilities/cython_types.hpp +++ b/cpp/include/cuopt/math_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_{}; + math_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_{}; + math_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_{}; + math_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/math_optimization/utilities/internals.hpp similarity index 96% rename from cpp/include/cuopt/linear_programming/utilities/internals.hpp rename to cpp/include/cuopt/math_optimization/utilities/internals.hpp index bdfbb969d2..b22bfca868 100644 --- a/cpp/include/cuopt/linear_programming/utilities/internals.hpp +++ b/cpp/include/cuopt/math_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 math_optimization { class base_solution_t { public: @@ -142,5 +142,5 @@ enum presolver_t : int { PSLP = CUOPT_PRESOLVE_PSLP }; -} // namespace linear_programming +} // namespace math_optimization } // namespace cuopt diff --git a/cpp/include/cuopt/linear_programming/utilities/segmented_sum_handler.cuh b/cpp/include/cuopt/math_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/math_optimization/utilities/segmented_sum_handler.cuh index 0b7e168a76..fb895ffb3a 100644 --- a/cpp/include/cuopt/linear_programming/utilities/segmented_sum_handler.cuh +++ b/cpp/include/cuopt/math_optimization/utilities/segmented_sum_handler.cuh @@ -21,7 +21,7 @@ #include -namespace cuopt::linear_programming::detail { +namespace cuopt::math_optimization::detail { 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::math_optimization::detail diff --git a/cpp/src/barrier/barrier.cu b/cpp/src/barrier/barrier.cu index 1cbeed5cf3..dca93174e2 100644 --- a/cpp/src/barrier/barrier.cu +++ b/cpp/src/barrier/barrier.cu @@ -50,7 +50,7 @@ #include #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::math_optimization::dual_simplex { template bool validate_barrier_cone_layout(const lp_problem_t& problem, @@ -4448,4 +4448,4 @@ template class sparse_cholesky_cudss_t; template class iteration_data_t; #endif -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::math_optimization::dual_simplex diff --git a/cpp/src/barrier/barrier.hpp b/cpp/src/barrier/barrier.hpp index b17cce3979..e5cae7181b 100644 --- a/cpp/src/barrier/barrier.hpp +++ b/cpp/src/barrier/barrier.hpp @@ -16,7 +16,7 @@ #include #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::math_optimization::dual_simplex { /** Validates SOC layout on an lp_problem_t before barrier presolve/solve. */ template @@ -116,4 +116,4 @@ class barrier_solver_t { rmm::cuda_stream_view stream_view_; }; -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::math_optimization::dual_simplex diff --git a/cpp/src/barrier/conjugate_gradient.hpp b/cpp/src/barrier/conjugate_gradient.hpp index ff29a071c3..ba2f0fffbc 100644 --- a/cpp/src/barrier/conjugate_gradient.hpp +++ b/cpp/src/barrier/conjugate_gradient.hpp @@ -16,7 +16,7 @@ #include #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::math_optimization::dual_simplex { template i_t preconditioned_conjugate_gradient(const T& op, @@ -120,4 +120,4 @@ i_t preconditioned_conjugate_gradient(const T& op, return iter; } -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::math_optimization::dual_simplex diff --git a/cpp/src/barrier/cusparse_info.hpp b/cpp/src/barrier/cusparse_info.hpp index 105c470cd7..64977d5971 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::math_optimization::dual_simplex { 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::math_optimization::dual_simplex diff --git a/cpp/src/barrier/cusparse_view.cu b/cpp/src/barrier/cusparse_view.cu index b7673eacd5..6b88982e3c 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::math_optimization::dual_simplex { #define CUDA_VER_12_4_UP (CUDART_VERSION >= 12040) @@ -424,4 +424,4 @@ cusparse_view_t::transpose_spmv, std::alloca double beta, std::vector>& y); -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::math_optimization::dual_simplex diff --git a/cpp/src/barrier/cusparse_view.hpp b/cpp/src/barrier/cusparse_view.hpp index 802fc90f8b..19e147dade 100644 --- a/cpp/src/barrier/cusparse_view.hpp +++ b/cpp/src/barrier/cusparse_view.hpp @@ -21,7 +21,7 @@ // 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::math_optimization::dual_simplex { template class cusparse_view_t { public: @@ -72,4 +72,4 @@ class cusparse_view_t { rmm::device_scalar d_minus_one_; rmm::device_scalar d_zero_; }; -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::math_optimization::dual_simplex diff --git a/cpp/src/barrier/dense_matrix.hpp b/cpp/src/barrier/dense_matrix.hpp index 7fd8258334..2f6b5d38fa 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::math_optimization::dual_simplex { template class dense_matrix_t { @@ -242,4 +242,4 @@ class dense_matrix_t { std::vector values; }; -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::math_optimization::dual_simplex diff --git a/cpp/src/barrier/dense_vector.hpp b/cpp/src/barrier/dense_vector.hpp index 5d6f2b12ec..70a25b48d7 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::math_optimization::dual_simplex { template > class dense_vector_t : public std::vector { @@ -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::math_optimization::dual_simplex diff --git a/cpp/src/barrier/device_sparse_matrix.cu b/cpp/src/barrier/device_sparse_matrix.cu index 0b315b4846..e488a06e6b 100644 --- a/cpp/src/barrier/device_sparse_matrix.cu +++ b/cpp/src/barrier/device_sparse_matrix.cu @@ -10,7 +10,7 @@ #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::math_optimization::dual_simplex { template template @@ -65,4 +65,4 @@ template void csc_matrix_t::scale_columns #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::math_optimization::dual_simplex { template class device_csr_matrix_t; @@ -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::math_optimization::dual_simplex { // 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::math_optimization::dual_simplex diff --git a/cpp/src/barrier/pinned_host_allocator.cu b/cpp/src/barrier/pinned_host_allocator.cu index 56a372bd46..4a651fa6c4 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::math_optimization::dual_simplex { template struct PinnedHostAllocator { @@ -55,4 +55,4 @@ template bool operator!=(const PinnedHostAllocator&, #endif template class PinnedHostAllocator; -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::math_optimization::dual_simplex diff --git a/cpp/src/barrier/pinned_host_allocator.hpp b/cpp/src/barrier/pinned_host_allocator.hpp index c236783ae7..27116e2572 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::math_optimization::dual_simplex { // 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::math_optimization::dual_simplex diff --git a/cpp/src/barrier/second_order_cone_kernels.cuh b/cpp/src/barrier/second_order_cone_kernels.cuh index 5a674fef70..df41509f24 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::math_optimization::dual_simplex { 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::math_optimization::dual_simplex diff --git a/cpp/src/barrier/second_order_cone_reduction.cuh b/cpp/src/barrier/second_order_cone_reduction.cuh index ada9fcfb6a..ad1415d472 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::math_optimization::dual_simplex { template class sparse_cholesky_base_t { @@ -896,4 +896,4 @@ class sparse_cholesky_cudss_t : public sparse_cholesky_base_t { void* cuGetErrorString_func; }; -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::math_optimization::dual_simplex diff --git a/cpp/src/barrier/sparse_matrix_kernels.cuh b/cpp/src/barrier/sparse_matrix_kernels.cuh index 4727c12ec8..6027711b29 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::math_optimization::dual_simplex { 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::math_optimization::dual_simplex diff --git a/cpp/src/barrier/translate_soc.hpp b/cpp/src/barrier/translate_soc.hpp index 3209dee3c6..f993a5478e 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::math_optimization::detail { /** Convert MPS >= ('G') quadratic row to <= ('L') form on a working copy for SOC conversion. */ template @@ -820,7 +820,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::math_optimization::dual_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) { @@ -891,18 +891,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::math_optimization::dual_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::math_optimization::dual_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::math_optimization::dual_simplex::variable_type_t::CONTINUOUS, error_type_t::ValidationError, "Rotated SOC tail variables must be continuous"); } @@ -924,7 +924,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::math_optimization::dual_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) { @@ -1065,7 +1065,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::math_optimization::dual_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) { @@ -1152,7 +1152,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::math_optimization::dual_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) { @@ -1352,4 +1352,4 @@ void project_barrier_solution_to_model_variables( solution.z = std::move(model_z); } -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::math_optimization::detail diff --git a/cpp/src/branch_and_bound/bb_event.hpp b/cpp/src/branch_and_bound/bb_event.hpp index b5ef80a167..fc981699e3 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::math_optimization::dual_simplex { // 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::math_optimization::dual_simplex diff --git a/cpp/src/branch_and_bound/branch_and_bound.cpp b/cpp/src/branch_and_bound/branch_and_bound.cpp index 33641a5fb3..e4d1352fe7 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,7 @@ #include #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::math_optimization::dual_simplex { namespace { template @@ -4188,4 +4188,4 @@ template class branch_and_bound_t; #endif -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::math_optimization::dual_simplex diff --git a/cpp/src/branch_and_bound/branch_and_bound.hpp b/cpp/src/branch_and_bound/branch_and_bound.hpp index 0b32b2ece5..c18a109ba7 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::math_optimization::detail { template struct clique_table_t; } -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::math_optimization::dual_simplex { template struct mip_symmetry_t; @@ -477,4 +477,4 @@ class branch_and_bound_t { heap_t diving_heap_; }; -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::math_optimization::dual_simplex diff --git a/cpp/src/branch_and_bound/constants.hpp b/cpp/src/branch_and_bound/constants.hpp index d507999ed6..aaf607b047 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::math_optimization::dual_simplex { 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::math_optimization::dual_simplex diff --git a/cpp/src/branch_and_bound/deterministic_workers.hpp b/cpp/src/branch_and_bound/deterministic_workers.hpp index fb1c0f450f..5e933d2ed8 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::math_optimization::dual_simplex { template struct backlog_node_compare_t { @@ -455,4 +455,4 @@ class deterministic_diving_worker_pool_t } }; -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::math_optimization::dual_simplex diff --git a/cpp/src/branch_and_bound/diving_heuristics.cpp b/cpp/src/branch_and_bound/diving_heuristics.cpp index 933f67f506..b4e760f431 100644 --- a/cpp/src/branch_and_bound/diving_heuristics.cpp +++ b/cpp/src/branch_and_bound/diving_heuristics.cpp @@ -7,7 +7,7 @@ #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::math_optimization::dual_simplex { template branch_variable_t line_search_diving(const std::vector& fractional, @@ -407,4 +407,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::math_optimization::dual_simplex { // When `log_diving_type` is true, each diving strategy gets its own letter; // otherwise every dive collapses to 'D'. @@ -100,4 +100,4 @@ branch_variable_t vector_length_diving(const lp_problem_t& lp, const std::vector& solution, logger_t& log); -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::math_optimization::dual_simplex diff --git a/cpp/src/branch_and_bound/mip_node.hpp b/cpp/src/branch_and_bound/mip_node.hpp index 2c0968ffce..0daee7150d 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::math_optimization::dual_simplex { enum class node_status_t : int { PENDING = 0, // Node is still in the tree, waiting to be solved @@ -459,4 +459,4 @@ class search_tree_t { static constexpr bool write_graphviz = false; }; -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::math_optimization::dual_simplex diff --git a/cpp/src/branch_and_bound/node_queue.hpp b/cpp/src/branch_and_bound/node_queue.hpp index b07b371b81..ee4d0694f9 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::math_optimization::dual_simplex { // This is a generic heap implementation based // on the STL functions. The main benefit here is @@ -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::math_optimization::dual_simplex diff --git a/cpp/src/branch_and_bound/pseudo_costs.cpp b/cpp/src/branch_and_bound/pseudo_costs.cpp index fc3ee3bb3f..d87173df05 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,7 +25,7 @@ #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::math_optimization::dual_simplex { namespace { static bool is_dual_simplex_done(dual::status_t status) @@ -530,7 +530,7 @@ std::pair trial_branching(const lp_problem_t& ori } // namespace template -static cuopt::linear_programming::io::mps_data_model_t simplex_problem_to_mps_data_model( +static cuopt::math_optimization::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, @@ -549,7 +549,7 @@ 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::math_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); @@ -1994,4 +1994,4 @@ template void strong_branching(const lp_problem_t& ori #endif -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::math_optimization::dual_simplex diff --git a/cpp/src/branch_and_bound/pseudo_costs.hpp b/cpp/src/branch_and_bound/pseudo_costs.hpp index 6fd7dc5bb6..2e86c982ac 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::math_optimization::dual_simplex { template struct mip_symmetry_t; @@ -290,4 +290,4 @@ void strong_branching(const lp_problem_t& original_lp, mip_symmetry_t* symmetry, pseudo_costs_t& pc); -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::math_optimization::dual_simplex 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..6dea27128d 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::math_optimization::dual_simplex { 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::math_optimization::dual_simplex diff --git a/cpp/src/branch_and_bound/symmetry.hpp b/cpp/src/branch_and_bound/symmetry.hpp index bcce5ece2a..9a9df275da 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::math_optimization::dual_simplex { // permutation_t stores a dense permutation plus its support (non-identity entries). template @@ -1138,4 +1138,4 @@ std::unique_ptr> detect_symmetry( return result; } -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::math_optimization::dual_simplex diff --git a/cpp/src/branch_and_bound/worker.hpp b/cpp/src/branch_and_bound/worker.hpp index 62bd0cde6b..7c84b0fc2e 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::math_optimization::dual_simplex { template struct branch_and_bound_stats_t { @@ -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::math_optimization::dual_simplex diff --git a/cpp/src/branch_and_bound/worker_pool.hpp b/cpp/src/branch_and_bound/worker_pool.hpp index d75794bbf0..4073fc07c0 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::math_optimization::dual_simplex { template class worker_pool_t { @@ -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::math_optimization::dual_simplex diff --git a/cpp/src/cuts/cuts.cpp b/cpp/src/cuts/cuts.cpp index a94478adc9..1585c69747 100644 --- a/cpp/src/cuts/cuts.cpp +++ b/cpp/src/cuts/cuts.cpp @@ -27,7 +27,7 @@ #include #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::math_optimization::dual_simplex { namespace { @@ -5599,4 +5599,4 @@ template void verify_cuts_against_saved_solution( const std::vector& saved_solution); #endif -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::math_optimization::dual_simplex diff --git a/cpp/src/cuts/cuts.hpp b/cpp/src/cuts/cuts.hpp index 1a7af97611..5ca35d3ed0 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::math_optimization::detail { template struct clique_table_t; } -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::math_optimization::dual_simplex { enum cut_type_t : int8_t { MIXED_INTEGER_GOMORY = 0, @@ -1069,4 +1069,4 @@ i_t remove_cuts(lp_problem_t& lp, std::vector& nonbasic_list, basis_update_mpf_t& basis_update); -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::math_optimization::dual_simplex diff --git a/cpp/src/cuts/objective_step.cpp b/cpp/src/cuts/objective_step.cpp index a166839343..a588c1912e 100644 --- a/cpp/src/cuts/objective_step.cpp +++ b/cpp/src/cuts/objective_step.cpp @@ -14,7 +14,7 @@ #include #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::math_optimization::dual_simplex { namespace { @@ -408,4 +408,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::math_optimization::dual_simplex diff --git a/cpp/src/cuts/objective_step.hpp b/cpp/src/cuts/objective_step.hpp index 8588cf1384..df4599209c 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::math_optimization::dual_simplex { // 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 @@ -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::math_optimization::dual_simplex diff --git a/cpp/src/cuts/rational.hpp b/cpp/src/cuts/rational.hpp index eee05f984e..f6ab4755b7 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::math_optimization::dual_simplex { // 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::math_optimization::dual_simplex diff --git a/cpp/src/dual_simplex/basis_solves.cpp b/cpp/src/dual_simplex/basis_solves.cpp index c5fee4e108..0926956e44 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::math_optimization::dual_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::math_optimization::dual_simplex diff --git a/cpp/src/dual_simplex/basis_solves.hpp b/cpp/src/dual_simplex/basis_solves.hpp index 76a9c396bc..5d5b2fea49 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::math_optimization::dual_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::math_optimization::dual_simplex diff --git a/cpp/src/dual_simplex/basis_updates.cpp b/cpp/src/dual_simplex/basis_updates.cpp index fdf8acf07d..8360716f9f 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::math_optimization::dual_simplex { template i_t basis_update_t::b_solve(const std::vector& rhs, std::vector& solution) const @@ -2455,4 +2455,4 @@ template class basis_update_t; template class basis_update_mpf_t; #endif -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::math_optimization::dual_simplex diff --git a/cpp/src/dual_simplex/basis_updates.hpp b/cpp/src/dual_simplex/basis_updates.hpp index f313e15c1e..38a6105547 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::math_optimization::dual_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::math_optimization::dual_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..79383ab8f9 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::math_optimization::dual_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::math_optimization::dual_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..ed16b9fbaf 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::math_optimization::dual_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::math_optimization::dual_simplex diff --git a/cpp/src/dual_simplex/bounds_strengthening.cpp b/cpp/src/dual_simplex/bounds_strengthening.cpp index 6506ce4873..757100ce1a 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::math_optimization::dual_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::math_optimization::dual_simplex diff --git a/cpp/src/dual_simplex/bounds_strengthening.hpp b/cpp/src/dual_simplex/bounds_strengthening.hpp index 009f7b2433..a4bc759e27 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::math_optimization::dual_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::math_optimization::dual_simplex diff --git a/cpp/src/dual_simplex/crossover.cpp b/cpp/src/dual_simplex/crossover.cpp index eb3b88ce50..50165e7785 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::math_optimization::dual_simplex { namespace { @@ -1636,4 +1636,4 @@ template crossover_status_t crossover( #endif -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::math_optimization::dual_simplex diff --git a/cpp/src/dual_simplex/crossover.hpp b/cpp/src/dual_simplex/crossover.hpp index 0bb1ff6627..1b3f74ae8a 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::math_optimization::dual_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::math_optimization::dual_simplex diff --git a/cpp/src/dual_simplex/folding.cpp b/cpp/src/dual_simplex/folding.cpp index f851e51d79..d32179d785 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::math_optimization::dual_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::math_optimization::dual_simplex diff --git a/cpp/src/dual_simplex/folding.hpp b/cpp/src/dual_simplex/folding.hpp index bba84dc936..87dff2aa64 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::math_optimization::dual_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::math_optimization::dual_simplex diff --git a/cpp/src/dual_simplex/initial_basis.cpp b/cpp/src/dual_simplex/initial_basis.cpp index e415f03672..c2a73c3e2f 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::math_optimization::dual_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::math_optimization::dual_simplex diff --git a/cpp/src/dual_simplex/initial_basis.hpp b/cpp/src/dual_simplex/initial_basis.hpp index f4cb19efc5..eab3a8d181 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::math_optimization::dual_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::math_optimization::dual_simplex diff --git a/cpp/src/dual_simplex/logger.hpp b/cpp/src/dual_simplex/logger.hpp index f813086708..e5770b95af 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::math_optimization::dual_simplex { class logger_t { public: @@ -128,4 +128,4 @@ class logger_t { std::FILE* log_file; }; -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::math_optimization::dual_simplex diff --git a/cpp/src/dual_simplex/phase1.cpp b/cpp/src/dual_simplex/phase1.cpp index 253c40d056..8b16e694ce 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::math_optimization::dual_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::math_optimization::dual_simplex diff --git a/cpp/src/dual_simplex/phase1.hpp b/cpp/src/dual_simplex/phase1.hpp index fe30321eda..ca943f8307 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::math_optimization::dual_simplex { template i_t create_phase1_problem(const lp_problem_t& lp, lp_problem_t& out); -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::math_optimization::dual_simplex diff --git a/cpp/src/dual_simplex/phase2.cpp b/cpp/src/dual_simplex/phase2.cpp index 7bbbd9a30c..e42157bc4d 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::math_optimization::dual_simplex { constexpr int FEATURE_LOG_INTERVAL = 100; @@ -3802,4 +3802,4 @@ template void compute_initial_nonbasic_end(const std::vector& std::vector& nonbasic_end); #endif -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::math_optimization::dual_simplex diff --git a/cpp/src/dual_simplex/phase2.hpp b/cpp/src/dual_simplex/phase2.hpp index 266d57c19f..85717f8430 100644 --- a/cpp/src/dual_simplex/phase2.hpp +++ b/cpp/src/dual_simplex/phase2.hpp @@ -21,7 +21,7 @@ namespace cuopt { struct work_limit_context_t; } -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::math_optimization::dual_simplex { namespace dual { enum class status_t { @@ -109,4 +109,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::math_optimization::dual_simplex diff --git a/cpp/src/dual_simplex/presolve.cpp b/cpp/src/dual_simplex/presolve.cpp index d438fd133b..9ec2237e15 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::math_optimization::dual_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::math_optimization::dual_simplex diff --git a/cpp/src/dual_simplex/presolve.hpp b/cpp/src/dual_simplex/presolve.hpp index 22e578047f..7e4fc32ba3 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::math_optimization::dual_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::math_optimization::dual_simplex diff --git a/cpp/src/dual_simplex/primal.cpp b/cpp/src/dual_simplex/primal.cpp index d4c6743dc6..0dcb41b547 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::math_optimization::dual_simplex { namespace { @@ -558,4 +558,4 @@ template primal::status_t primal_phase2( #endif -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::math_optimization::dual_simplex diff --git a/cpp/src/dual_simplex/primal.hpp b/cpp/src/dual_simplex/primal.hpp index bd72fee4b3..c300c0040e 100644 --- a/cpp/src/dual_simplex/primal.hpp +++ b/cpp/src/dual_simplex/primal.hpp @@ -15,7 +15,7 @@ #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::math_optimization::dual_simplex { namespace primal { enum class status_t { @@ -38,4 +38,4 @@ primal::status_t primal_phase2(i_t phase, lp_solution_t& sol, i_t& iter); -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::math_optimization::dual_simplex diff --git a/cpp/src/dual_simplex/random.hpp b/cpp/src/dual_simplex/random.hpp index 571a59857a..1ee0304be0 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::math_optimization::dual_simplex { template class random_t { @@ -34,4 +34,4 @@ class random_t { std::mt19937 gen; }; -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::math_optimization::dual_simplex diff --git a/cpp/src/dual_simplex/right_looking_lu.cpp b/cpp/src/dual_simplex/right_looking_lu.cpp index 00f2fefb62..5045979bd7 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::math_optimization::dual_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::math_optimization::dual_simplex diff --git a/cpp/src/dual_simplex/right_looking_lu.hpp b/cpp/src/dual_simplex/right_looking_lu.hpp index 9b2814dfde..8518fdc690 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::math_optimization::dual_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::math_optimization::dual_simplex diff --git a/cpp/src/dual_simplex/scaling.cpp b/cpp/src/dual_simplex/scaling.cpp index 92b4d3377d..ac436efc62 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::math_optimization::dual_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::math_optimization::dual_simplex diff --git a/cpp/src/dual_simplex/scaling.hpp b/cpp/src/dual_simplex/scaling.hpp index df0bf4d845..5ba0b9baa6 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::math_optimization::dual_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::math_optimization::dual_simplex diff --git a/cpp/src/dual_simplex/simplex_solver_settings.hpp b/cpp/src/dual_simplex/simplex_solver_settings.hpp index 286ac7364f..143e9ec69d 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::math_optimization { struct benchmark_info_t; } -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::math_optimization::dual_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::math_optimization::benchmark_info_t* benchmark_info_ptr = nullptr; }; -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::math_optimization::dual_simplex diff --git a/cpp/src/dual_simplex/singletons.cpp b/cpp/src/dual_simplex/singletons.cpp index dbba46f6a5..500d9cdde8 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::math_optimization::dual_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::math_optimization::dual_simplex diff --git a/cpp/src/dual_simplex/singletons.hpp b/cpp/src/dual_simplex/singletons.hpp index 9bbe9270f7..db66488e03 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::math_optimization::dual_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::math_optimization::dual_simplex diff --git a/cpp/src/dual_simplex/solution.hpp b/cpp/src/dual_simplex/solution.hpp index 86213c86e9..53fa9c6867 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::math_optimization::dual_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::math_optimization::dual_simplex diff --git a/cpp/src/dual_simplex/solve.cpp b/cpp/src/dual_simplex/solve.cpp index d81265358a..1b9025d206 100644 --- a/cpp/src/dual_simplex/solve.cpp +++ b/cpp/src/dual_simplex/solve.cpp @@ -33,7 +33,7 @@ #include #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::math_optimization::dual_simplex { namespace { @@ -846,4 +846,4 @@ template int solve_mip_with_guess( #endif -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::math_optimization::dual_simplex diff --git a/cpp/src/dual_simplex/solve.hpp b/cpp/src/dual_simplex/solve.hpp index 84eb6faa02..7b01d6ca37 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::math_optimization::dual_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::math_optimization::dual_simplex diff --git a/cpp/src/dual_simplex/sparse_matrix.cpp b/cpp/src/dual_simplex/sparse_matrix.cpp index 63004be72b..f2e887bfcc 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::math_optimization::dual_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::math_optimization::dual_simplex diff --git a/cpp/src/dual_simplex/sparse_matrix.hpp b/cpp/src/dual_simplex/sparse_matrix.hpp index 09b580cad1..75e3f1bc84 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::math_optimization::dual_simplex { template class csr_matrix_t; // Forward declaration of CSR matrix needed to define CSC @@ -55,8 +55,7 @@ class csc_matrix_t { i_t col_length(i_t j) const { return col_start[j + 1] - col_start[j]; } // Convert the CSC matrix to a CSR matrix - i_t to_compressed_row( - cuopt::linear_programming::dual_simplex::csr_matrix_t& Arow) const; + i_t to_compressed_row(cuopt::math_optimization::dual_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 +311,4 @@ i_t matrix_vector_multiply( return 0; } -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::math_optimization::dual_simplex diff --git a/cpp/src/dual_simplex/sparse_vector.cpp b/cpp/src/dual_simplex/sparse_vector.cpp index 1f3798e7dd..6323bf3dc4 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::math_optimization::dual_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::math_optimization::dual_simplex diff --git a/cpp/src/dual_simplex/sparse_vector.hpp b/cpp/src/dual_simplex/sparse_vector.hpp index d9ca540d18..f3fb2c9e7c 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::math_optimization::dual_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::math_optimization::dual_simplex diff --git a/cpp/src/dual_simplex/tic_toc.cpp b/cpp/src/dual_simplex/tic_toc.cpp index 98eb89bcb4..0b0402c679 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::math_optimization::dual_simplex { double tic() { @@ -24,4 +24,4 @@ double toc(double start) return (now - start); } -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::math_optimization::dual_simplex diff --git a/cpp/src/dual_simplex/tic_toc.hpp b/cpp/src/dual_simplex/tic_toc.hpp index edaf325aea..419e91ce37 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::math_optimization::dual_simplex { double tic(); double toc(double start); -} // namespace cuopt::linear_programming::dual_simplex +} // namespace cuopt::math_optimization::dual_simplex diff --git a/cpp/src/dual_simplex/triangle_solve.cpp b/cpp/src/dual_simplex/triangle_solve.cpp index ad09ae30cf..d04238119b 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::math_optimization::dual_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::math_optimization::dual_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::math_optimization::dual_simplex diff --git a/cpp/src/dual_simplex/types.hpp b/cpp/src/dual_simplex/types.hpp index b4ff4b8cb3..5da243c506 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::math_optimization::dual_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::math_optimization::dual_simplex diff --git a/cpp/src/dual_simplex/user_problem.hpp b/cpp/src/dual_simplex/user_problem.hpp index 548ec9e449..55d7ceb243 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::math_optimization::dual_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::math_optimization::dual_simplex diff --git a/cpp/src/dual_simplex/vector_math.cpp b/cpp/src/dual_simplex/vector_math.cpp index 0db09b00b6..ac5e9f7be7 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::math_optimization::dual_simplex { template f_t vector_norm2_squared(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::math_optimization::dual_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::math_optimization::dual_simplex diff --git a/cpp/src/dual_simplex/vector_math.hpp b/cpp/src/dual_simplex/vector_math.hpp index 478e024e51..9441aa348f 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::math_optimization::dual_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::math_optimization::dual_simplex diff --git a/cpp/src/grpc/client/grpc_client.cpp b/cpp/src/grpc/client/grpc_client.cpp index 060b76f79c..319299656f 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::math_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::math_optimization diff --git a/cpp/src/grpc/client/grpc_client.hpp b/cpp/src/grpc/client/grpc_client.hpp index 4c3aa0c3d3..433f48e1e0 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::math_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::math_optimization diff --git a/cpp/src/grpc/client/solve_remote.cpp b/cpp/src/grpc/client/solve_remote.cpp index fb39a6d184..5d8af78f4b 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::math_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::math_optimization diff --git a/cpp/src/grpc/codegen/field_registry.yaml b/cpp/src/grpc/codegen/field_registry.yaml index 4880b41a6b..4c3c60e2c1 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/math_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..3412d76234 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::math_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::math_optimization diff --git a/cpp/src/grpc/grpc_problem_mapper.cpp b/cpp/src/grpc/grpc_problem_mapper.cpp index 170dfd7aed..f828334e7e 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::math_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::math_optimization diff --git a/cpp/src/grpc/grpc_problem_mapper.hpp b/cpp/src/grpc/grpc_problem_mapper.hpp index 81ff2e927a..b8be14e6bb 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::math_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::math_optimization diff --git a/cpp/src/grpc/grpc_service_mapper.cpp b/cpp/src/grpc/grpc_service_mapper.cpp index dd969c1587..28b7b77f64 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::math_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::math_optimization diff --git a/cpp/src/grpc/grpc_service_mapper.hpp b/cpp/src/grpc/grpc_service_mapper.hpp index ed438a0551..06a314e1a6 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::math_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::math_optimization diff --git a/cpp/src/grpc/grpc_settings_mapper.cpp b/cpp/src/grpc/grpc_settings_mapper.cpp index ffa98e7693..7dc4ba1b56 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::math_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::math_optimization diff --git a/cpp/src/grpc/grpc_settings_mapper.hpp b/cpp/src/grpc/grpc_settings_mapper.hpp index 6daf0d052b..77320c09ff 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::math_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::math_optimization diff --git a/cpp/src/grpc/grpc_solution_mapper.cpp b/cpp/src/grpc/grpc_solution_mapper.cpp index 5f32af212d..ed3792690b 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::math_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::math_optimization diff --git a/cpp/src/grpc/grpc_solution_mapper.hpp b/cpp/src/grpc/grpc_solution_mapper.hpp index f2b6621f29..b20ff460dd 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::math_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::math_optimization diff --git a/cpp/src/grpc/server/grpc_pipe_serialization.hpp b/cpp/src/grpc/server/grpc_pipe_serialization.hpp index 8ad878d6cb..94036f0d16 100644 --- a/cpp/src/grpc/server/grpc_pipe_serialization.hpp +++ b/cpp/src/grpc/server/grpc_pipe_serialization.hpp @@ -229,12 +229,12 @@ 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::math_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); @@ -336,12 +336,11 @@ inline PipeWriteStatus write_chunked_request_to_pipe( return PipeWriteStatus::Success; } -inline bool read_chunked_request_from_pipe( - int fd, - cuopt::remote::ChunkedProblemHeader& header_out, - std::map>& arrays_out, - std::map>& - container_arrays_out) +inline bool read_chunked_request_from_pipe(int fd, + cuopt::remote::ChunkedProblemHeader& header_out, + std::map>& arrays_out, + std::map>& container_arrays_out) { // dest.resize(total_bytes) can throw std::bad_alloc if the wire claims an // allocation larger than the worker can satisfy. Catch it here so the @@ -387,7 +386,7 @@ inline bool read_chunked_request_from_pipe( 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}]; + container_arrays_out[cuopt::math_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 678d8d370a..b569907884 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,7 +60,7 @@ using grpc::ServerWriter; using grpc::Status; using grpc::StatusCode; -using namespace cuopt::linear_programming; +using namespace cuopt::math_optimization; // Note: NOT using "using namespace cuopt::remote" to avoid JobStatus enum conflict // ============================================================================= @@ -216,7 +216,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..6fc363d5ed 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::math_optimization::container_array_key_t key{ cfn_for_size, ac.container_index(), field_id}; meta_ptr = &state.container_field_meta[key]; } else { diff --git a/cpp/src/grpc/server/grpc_worker.cpp b/cpp/src/grpc/server/grpc_worker.cpp index 343a564837..5df602553a 100644 --- a/cpp/src/grpc/server/grpc_worker.cpp +++ b/cpp/src/grpc/server/grpc_worker.cpp @@ -218,7 +218,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; diff --git a/cpp/src/io/data_model_view.cpp b/cpp/src/io/data_model_view.cpp index e23f715f2b..70ef2e7745 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::math_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::math_optimization::io diff --git a/cpp/src/io/file_to_string.cpp b/cpp/src/io/file_to_string.cpp index 77b92d90e9..33665fe22a 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::math_optimization::io::error_type_t; +using cuopt::math_optimization::io::mps_parser_expects; +using cuopt::math_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::math_optimization::io::detail { 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::math_optimization::io::detail diff --git a/cpp/src/io/file_to_string.hpp b/cpp/src/io/file_to_string.hpp index 94b2df821d..84f6f10674 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::math_optimization::io::detail { // 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::math_optimization::io::detail diff --git a/cpp/src/io/lp_parser.cpp b/cpp/src/io/lp_parser.cpp index c72b1c7c82..e844c59bb0 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::math_optimization::io { namespace { @@ -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::math_optimization::io diff --git a/cpp/src/io/lp_parser.hpp b/cpp/src/io/lp_parser.hpp index 83f61785be..6eb3e0d879 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::math_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::math_optimization::io diff --git a/cpp/src/io/mps_data_model.cpp b/cpp/src/io/mps_data_model.cpp index 991c8d42a1..39689cfcd2 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::math_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::math_optimization::io diff --git a/cpp/src/io/mps_parser.cpp b/cpp/src/io/mps_parser.cpp index 5f7cecda94..62b1a6495e 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::math_optimization::io::coo_entries_t; +using cuopt::math_optimization::io::error_type_t; +using cuopt::math_optimization::io::mps_parser_expects; +using cuopt::math_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::math_optimization::io { template std::string_view get_next_string(std::string_view line, i_t& pos, i_t& end) @@ -1538,4 +1538,4 @@ template class mps_parser_t; template class mps_parser_t; -} // namespace cuopt::linear_programming::io +} // namespace cuopt::math_optimization::io diff --git a/cpp/src/io/mps_parser_internal.hpp b/cpp/src/io/mps_parser_internal.hpp index d510bd4f57..4e04f95a74 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::math_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::math_optimization::io diff --git a/cpp/src/io/mps_writer.cpp b/cpp/src/io/mps_writer.cpp index 9db528ca5b..9b8829d041 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::math_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::math_optimization::io diff --git a/cpp/src/io/parser.cpp b/cpp/src/io/parser.cpp index 93d9d9c73c..0684b1751c 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::math_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::math_optimization::io diff --git a/cpp/src/io/utilities/cython_parser.cpp b/cpp/src/io/utilities/cython_parser.cpp index 4de1de9b6f..9ba5567492 100644 --- a/cpp/src/io/utilities/cython_parser.cpp +++ b/cpp/src/io/utilities/cython_parser.cpp @@ -5,24 +5,24 @@ */ /* 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::math_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::math_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..5bdc849c5e 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::math_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::math_optimization::io diff --git a/cpp/src/io/writer.cpp b/cpp/src/io/writer.cpp index 45ffc4c263..7cab17f9cf 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::math_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::math_optimization::io diff --git a/cpp/src/math_optimization/solution_reader.cu b/cpp/src/math_optimization/solution_reader.cu index f4a008d00e..3897fec829 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::math_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::math_optimization diff --git a/cpp/src/math_optimization/solution_reader.hpp b/cpp/src/math_optimization/solution_reader.hpp index 54eb468f6c..efc85aaa77 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::math_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::math_optimization diff --git a/cpp/src/math_optimization/solution_writer.cu b/cpp/src/math_optimization/solution_writer.cu index 880127546d..94400d2a54 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::math_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::math_optimization diff --git a/cpp/src/math_optimization/solution_writer.hpp b/cpp/src/math_optimization/solution_writer.hpp index 0ac1b64464..d4acf2a776 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::math_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::math_optimization diff --git a/cpp/src/math_optimization/solver_settings.cu b/cpp/src/math_optimization/solver_settings.cu index 4a000c6e05..9c86e169f9 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::math_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::math_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..b8413e32dd 100644 --- a/cpp/src/mip_heuristics/diversity/assignment_hash_map.cu +++ b/cpp/src/mip_heuristics/diversity/assignment_hash_map.cu @@ -15,7 +15,7 @@ #include namespace cuopt { -namespace linear_programming { +namespace math_optimization { namespace detail { struct combine_hash { @@ -158,5 +158,5 @@ template class assignment_hash_map_t; #endif } // namespace detail -} // namespace linear_programming +} // namespace math_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..387efad383 100644 --- a/cpp/src/mip_heuristics/diversity/assignment_hash_map.cuh +++ b/cpp/src/mip_heuristics/diversity/assignment_hash_map.cuh @@ -10,7 +10,7 @@ #include namespace cuopt { -namespace linear_programming { +namespace math_optimization { namespace detail { template @@ -31,5 +31,5 @@ class assignment_hash_map_t { }; } // namespace detail -} // namespace linear_programming +} // namespace math_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..0e3ac58a9d 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::math_optimization::detail { 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::math_optimization::detail diff --git a/cpp/src/mip_heuristics/diversity/diversity_manager.cu b/cpp/src/mip_heuristics/diversity/diversity_manager.cu index b88099d8ae..4b31adef05 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::math_optimization::detail { size_t fp_recombiner_config_t::max_n_of_vars_from_other = fp_recombiner_config_t::initial_n_of_vars_from_other; @@ -966,4 +966,4 @@ template class diversity_manager_t; template class diversity_manager_t; #endif -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::math_optimization::detail diff --git a/cpp/src/mip_heuristics/diversity/diversity_manager.cuh b/cpp/src/mip_heuristics/diversity/diversity_manager.cuh index 863933de48..6c1e7c8822 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::math_optimization::detail { template class diversity_manager_t { @@ -110,4 +110,4 @@ class diversity_manager_t { bool run_only_sub_mip_recombiner{false}; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::math_optimization::detail diff --git a/cpp/src/mip_heuristics/diversity/lns/rins.cu b/cpp/src/mip_heuristics/diversity/lns/rins.cu index e1318edf4d..ef92aa91c6 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::math_optimization::detail { template rins_t::rins_t(mip_solver_context_t& context_, diversity_manager_t& dm_, @@ -234,7 +234,7 @@ 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; + namespace dual_simplex = cuopt::math_optimization::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); @@ -351,4 +351,4 @@ template class rins_t; template class rins_t; #endif -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::math_optimization::detail diff --git a/cpp/src/mip_heuristics/diversity/lns/rins.cuh b/cpp/src/mip_heuristics/diversity/lns/rins.cuh index b1b62bd1ae..57a2748db7 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::math_optimization::detail { // forward declare template @@ -84,4 +84,4 @@ class rins_t { omp_atomic_t launch_new_task{true}; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::math_optimization::detail diff --git a/cpp/src/mip_heuristics/diversity/multi_armed_bandit.cu b/cpp/src/mip_heuristics/diversity/multi_armed_bandit.cu index f5fc88cbc1..6044f38f48 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::math_optimization::detail { 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::math_optimization::detail diff --git a/cpp/src/mip_heuristics/diversity/multi_armed_bandit.cuh b/cpp/src/mip_heuristics/diversity/multi_armed_bandit.cuh index 4571d0d57f..ce67e37e74 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::math_optimization::detail { 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::math_optimization::detail diff --git a/cpp/src/mip_heuristics/diversity/population.cu b/cpp/src/mip_heuristics/diversity/population.cu index a870f654de..58cd8a343d 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::math_optimization::detail { constexpr double weight_increase_ratio = 2.; constexpr double weight_decrease_ratio = 0.9; @@ -901,4 +901,4 @@ template class population_t; template class population_t; #endif -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::math_optimization::detail diff --git a/cpp/src/mip_heuristics/diversity/population.cuh b/cpp/src/mip_heuristics/diversity/population.cuh index c83a4bfb83..95e618d802 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::math_optimization::detail { // forward declare template @@ -214,4 +214,4 @@ class population_t { cuopt::timer_t timer; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::math_optimization::detail 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..0420a66f86 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::math_optimization::detail { 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::math_optimization::detail diff --git a/cpp/src/mip_heuristics/diversity/recombiners/fp_recombiner.cuh b/cpp/src/mip_heuristics/diversity/recombiners/fp_recombiner.cuh index 1cca1ba371..8dd495de62 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::math_optimization::detail { 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::math_optimization::detail 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..1304da2a79 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::math_optimization::detail { 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::math_optimization::detail diff --git a/cpp/src/mip_heuristics/diversity/recombiners/recombiner.cuh b/cpp/src/mip_heuristics/diversity/recombiners/recombiner.cuh index 4782e9612b..cdfa32d144 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::math_optimization::detail { // 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::math_optimization::detail diff --git a/cpp/src/mip_heuristics/diversity/recombiners/recombiner_configs.hpp b/cpp/src/mip_heuristics/diversity/recombiners/recombiner_configs.hpp index 04d3332947..6687072029 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::math_optimization::detail { 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::math_optimization::detail diff --git a/cpp/src/mip_heuristics/diversity/recombiners/recombiner_stats.hpp b/cpp/src/mip_heuristics/diversity/recombiners/recombiner_stats.hpp index 044e313284..c16723d9f6 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::math_optimization::detail { 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::math_optimization::detail diff --git a/cpp/src/mip_heuristics/diversity/recombiners/sub_mip.cuh b/cpp/src/mip_heuristics/diversity/recombiners/sub_mip.cuh index 1d0b9245d7..dc9ad1571c 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/math_optimization/mip/solver_settings.hpp" #include "recombiner.cuh" #include @@ -16,7 +16,7 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::math_optimization::detail { template class sub_mip_recombiner_t : public recombiner_t { @@ -96,7 +96,7 @@ class sub_mip_recombiner_t : public recombiner_t { dual_simplex::mip_solution_t branch_and_bound_solution(1); if (run_sub_mip) { // run sub-mip - namespace dual_simplex = cuopt::linear_programming::dual_simplex; + namespace dual_simplex = cuopt::math_optimization::dual_simplex; dual_simplex::user_problem_t branch_and_bound_problem(offspring.handle_ptr); dual_simplex::simplex_solver_settings_t branch_and_bound_settings; fixed_problem.get_host_user_problem(branch_and_bound_problem); @@ -206,4 +206,4 @@ class sub_mip_recombiner_t : public recombiner_t { population_t& population; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::math_optimization::detail diff --git a/cpp/src/mip_heuristics/diversity/weights.cuh b/cpp/src/mip_heuristics/diversity/weights.cuh index 7502ae9210..c0de35453a 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::math_optimization::detail { template struct weight_t { @@ -29,4 +29,4 @@ struct weight_t { rmm::device_scalar objective_weight; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::math_optimization::detail diff --git a/cpp/src/mip_heuristics/early_heuristic.cuh b/cpp/src/mip_heuristics/early_heuristic.cuh index 090cfd4901..5d4fa624f8 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::math_optimization::detail { template using early_incumbent_callback_t = std::function #include -namespace cuopt::linear_programming::detail { +namespace cuopt::math_optimization::detail { template struct fj_cpu_climber_t; @@ -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::math_optimization::detail diff --git a/cpp/src/mip_heuristics/feasibility_jump/early_cpufj.cu b/cpp/src/mip_heuristics/feasibility_jump/early_cpufj.cu index 46ffde6089..e2b612007e 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::math_optimization::detail { 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::math_optimization::detail diff --git a/cpp/src/mip_heuristics/feasibility_jump/early_cpufj.cuh b/cpp/src/mip_heuristics/feasibility_jump/early_cpufj.cuh index fd85e4b9f3..a482abddf2 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::math_optimization::detail { 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::math_optimization::detail diff --git a/cpp/src/mip_heuristics/feasibility_jump/early_gpufj.cu b/cpp/src/mip_heuristics/feasibility_jump/early_gpufj.cu index eac901151b..f0620db6f2 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::math_optimization::detail { 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::math_optimization::detail diff --git a/cpp/src/mip_heuristics/feasibility_jump/early_gpufj.cuh b/cpp/src/mip_heuristics/feasibility_jump/early_gpufj.cuh index e5ceaaeb61..56958a7a8e 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::math_optimization::detail { 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::math_optimization::detail diff --git a/cpp/src/mip_heuristics/feasibility_jump/feasibility_jump.cu b/cpp/src/mip_heuristics/feasibility_jump/feasibility_jump.cu index 21e2bf0783..979077d57c 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::math_optimization::detail { #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::math_optimization::detail diff --git a/cpp/src/mip_heuristics/feasibility_jump/feasibility_jump.cuh b/cpp/src/mip_heuristics/feasibility_jump/feasibility_jump.cuh index 4cc411abf9..7dd9f7ce40 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::math_optimization::detail { 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::math_optimization::detail 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..82bfc97465 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::math_optimization::detail { 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::math_optimization::detail 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..4e17da07bd 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::math_optimization::detail { template DI thrust::pair move_objective_score( @@ -1803,4 +1803,4 @@ CUOPT_INSTANTIATE(double) #undef CUOPT_INSTANTIATE -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::math_optimization::detail 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..62f6801cf5 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::math_optimization::detail { 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::math_optimization::detail diff --git a/cpp/src/mip_heuristics/feasibility_jump/fj_cpu.cu b/cpp/src/mip_heuristics/feasibility_jump/fj_cpu.cu index a537426457..0e9d96a1fa 100644 --- a/cpp/src/mip_heuristics/feasibility_jump/fj_cpu.cu +++ b/cpp/src/mip_heuristics/feasibility_jump/fj_cpu.cu @@ -46,7 +46,7 @@ #define CPUFJ_NVTX_RANGE(name) ((void)0) #endif -namespace cuopt::linear_programming::detail { +namespace cuopt::math_optimization::detail { template void finalize_fj_cpu_host_initialization( @@ -1893,4 +1893,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::math_optimization::detail diff --git a/cpp/src/mip_heuristics/feasibility_jump/fj_cpu.cuh b/cpp/src/mip_heuristics/feasibility_jump/fj_cpu.cuh index cdf3a2f58a..7d8b4dbfb2 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::math_optimization::detail { // 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::math_optimization::detail diff --git a/cpp/src/mip_heuristics/feasibility_jump/utils.cuh b/cpp/src/mip_heuristics/feasibility_jump/utils.cuh index d98686bcc6..2910710cf8 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::math_optimization::detail { 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::math_optimization::detail 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..0dfe38bdbf 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::math_optimization::detail { 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::math_optimization::detail 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..4690653215 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::math_optimization::detail { 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::math_optimization::detail diff --git a/cpp/src/mip_heuristics/local_search/lagrangian.cuh b/cpp/src/mip_heuristics/local_search/lagrangian.cuh index 3ad176a4f8..0123c22f90 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::math_optimization::detail { // 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::math_optimization::detail 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..cb0604285f 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::math_optimization::detail { 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::math_optimization::detail 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..f506d71b97 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::math_optimization::detail { 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::math_optimization::detail diff --git a/cpp/src/mip_heuristics/local_search/local_search.cu b/cpp/src/mip_heuristics/local_search/local_search.cu index 8a288b2da8..725d538b3a 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::math_optimization::detail { template local_search_t::local_search_t(mip_solver_context_t& context_, @@ -903,4 +903,4 @@ template class local_search_t; template class local_search_t; #endif -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::math_optimization::detail diff --git a/cpp/src/mip_heuristics/local_search/local_search.cuh b/cpp/src/mip_heuristics/local_search/local_search.cuh index 9befd34ab5..b1ae4a3a14 100644 --- a/cpp/src/mip_heuristics/local_search/local_search.cuh +++ b/cpp/src/mip_heuristics/local_search/local_search.cuh @@ -15,12 +15,12 @@ #include #include -namespace cuopt::linear_programming::dual_simplex { +namespace cuopt::math_optimization::dual_simplex { template class branch_and_bound_t; } -namespace cuopt::linear_programming::detail { +namespace cuopt::math_optimization::detail { // make sure RANDOM is always the last enum class ls_method_t : int { @@ -131,4 +131,4 @@ class local_search_t { population_t* pop_ptr{nullptr}; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::math_optimization::detail 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..28685f7982 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::math_optimization::detail { 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::math_optimization::detail 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..62183830a8 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::math_optimization::detail { 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::math_optimization::detail 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..f08347f3ff 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::math_optimization::detail { // 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::math_optimization::detail 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..e8954743a0 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::math_optimization::detail { 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::math_optimization::detail 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..d0b88d088e 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::math_optimization::detail { 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::math_optimization::detail 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..888029a099 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::math_optimization::detail { 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::math_optimization::detail 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..b87f9221f4 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::math_optimization::detail { 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::math_optimization::detail 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..985e7060f4 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::math_optimization::detail { 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::math_optimization::detail 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..3edc563713 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::math_optimization::detail { 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::math_optimization::detail 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..30a40ac5c4 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::math_optimization::detail { template bool check_brute_force_rounding(solution_t& solution) @@ -189,4 +189,4 @@ INSTANTIATE(double) #undef INSTANTIATE -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::math_optimization::detail 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..b598043afc 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::math_optimization::detail { 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::math_optimization::detail 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..f96a81d824 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::math_optimization::detail { 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::math_optimization::detail diff --git a/cpp/src/mip_heuristics/logger.cuh b/cpp/src/mip_heuristics/logger.cuh index 479ce128bc..e129498942 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::math_optimization::detail { // 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::math_optimization::detail diff --git a/cpp/src/mip_heuristics/mip_constants.hpp b/cpp/src/mip_heuristics/mip_constants.hpp index 7d28048ba9..22e507d107 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..31ec985b27 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::math_optimization::detail { 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::math_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::math_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::math_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::math_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::math_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::math_optimization::optimization_problem_t& op_problem, rmm::device_uvector& temp_storage, size_t temp_storage_bytes, const rmm::device_uvector& pre_scaling_gcd, @@ -408,7 +408,7 @@ mip_scaling_strategy_t::mip_scaling_strategy_t( } template -size_t dry_run_cub(const cuopt::linear_programming::optimization_problem_t& op_problem, +size_t dry_run_cub(const cuopt::math_optimization::optimization_problem_t& op_problem, i_t n_rows, rmm::device_uvector& row_inf_norm, rmm::device_uvector& row_min_nonzero, @@ -879,4 +879,4 @@ INSTANTIATE(float) INSTANTIATE(double) #endif -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::math_optimization::detail diff --git a/cpp/src/mip_heuristics/mip_scaling_strategy.cuh b/cpp/src/mip_heuristics/mip_scaling_strategy.cuh index 63d88dbec6..a141ac1011 100644 --- a/cpp/src/mip_heuristics/mip_scaling_strategy.cuh +++ b/cpp/src/mip_heuristics/mip_scaling_strategy.cuh @@ -7,18 +7,18 @@ #pragma once -#include +#include #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::math_optimization::detail { template class mip_scaling_strategy_t { public: - using optimization_problem_type_t = cuopt::linear_programming::optimization_problem_t; + using optimization_problem_type_t = cuopt::math_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 +29,4 @@ class mip_scaling_strategy_t { optimization_problem_type_t& op_problem_scaled_; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::math_optimization::detail diff --git a/cpp/src/mip_heuristics/presolve/bounds_presolve.cu b/cpp/src/mip_heuristics/presolve/bounds_presolve.cu index 81717dbecf..9e06373dc8 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::math_optimization::detail { // 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::math_optimization::detail diff --git a/cpp/src/mip_heuristics/presolve/bounds_presolve.cuh b/cpp/src/mip_heuristics/presolve/bounds_presolve.cuh index ed0b91466d..eb84f1ea18 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::math_optimization::detail { template class probing_cache_t; @@ -84,4 +84,4 @@ class bound_presolve_t { i_t solve_iter; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::math_optimization::detail diff --git a/cpp/src/mip_heuristics/presolve/bounds_presolve_helpers.cuh b/cpp/src/mip_heuristics/presolve/bounds_presolve_helpers.cuh index 0804f68a70..093b281add 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::math_optimization::detail { template struct tuple_plus_t { @@ -35,4 +35,4 @@ struct tuple_plus_t { } }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::math_optimization::detail diff --git a/cpp/src/mip_heuristics/presolve/bounds_update_data.cu b/cpp/src/mip_heuristics/presolve/bounds_update_data.cu index 7314cd5c23..39cfb91313 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::math_optimization::detail { 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::math_optimization::detail diff --git a/cpp/src/mip_heuristics/presolve/bounds_update_data.cuh b/cpp/src/mip_heuristics/presolve/bounds_update_data.cuh index 8d1eac478b..6348c2e787 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::math_optimization::detail { 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::math_optimization::detail diff --git a/cpp/src/mip_heuristics/presolve/bounds_update_helpers.cuh b/cpp/src/mip_heuristics/presolve/bounds_update_helpers.cuh index 074cd17a60..060b8da6bd 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::math_optimization::detail { // Activity calculation @@ -398,4 +398,4 @@ __global__ void update_bounds_kernel(typename problem_t::view_t pb, } } -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::math_optimization::detail diff --git a/cpp/src/mip_heuristics/presolve/conditional_bound_strengthening.cu b/cpp/src/mip_heuristics/presolve/conditional_bound_strengthening.cu index 43c58ff1d7..9764e292d7 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::math_optimization::detail { 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::math_optimization::detail diff --git a/cpp/src/mip_heuristics/presolve/conditional_bound_strengthening.cuh b/cpp/src/mip_heuristics/presolve/conditional_bound_strengthening.cuh index 50b11e8e63..5d0b48a117 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::math_optimization::detail { 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::math_optimization::detail 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..4509f8f04b 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,7 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::math_optimization::detail { // do constraints with only binary variables. template @@ -785,4 +785,4 @@ INSTANTIATE(double) #endif #undef INSTANTIATE -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::math_optimization::detail 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..8fe55aae16 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::math_optimization::detail { struct clique_config_t { int min_clique_size = 512; @@ -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::math_optimization::detail // 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..a6dbd4b75b 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::math_optimization::detail { 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::math_optimization::detail diff --git a/cpp/src/mip_heuristics/presolve/gf2_presolve.hpp b/cpp/src/mip_heuristics/presolve/gf2_presolve.hpp index 9c90fe4fa0..495f46bdde 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::math_optimization::detail { template class GF2Presolve : public papilo::PresolveMethod { @@ -66,4 +66,4 @@ class GF2Presolve : public papilo::PresolveMethod { } }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::math_optimization::detail diff --git a/cpp/src/mip_heuristics/presolve/lb_probing_cache.cu b/cpp/src/mip_heuristics/presolve/lb_probing_cache.cu index bbb58c0164..f7c8acf99f 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::math_optimization::detail { 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::math_optimization::detail 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..b3734c10fb 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::math_optimization::detail { // 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::math_optimization::detail 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..b90eed6635 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::math_optimization::detail { 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::math_optimization::detail 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..b414ab2dcf 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::math_optimization::detail { #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::math_optimization::detail 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..1cf4923f57 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::math_optimization::detail { 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::math_optimization::detail 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..3ced570f59 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::math_optimization::detail { 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::math_optimization::detail diff --git a/cpp/src/mip_heuristics/presolve/multi_probe.cu b/cpp/src/mip_heuristics/presolve/multi_probe.cu index 9ffed054eb..36142c9437 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::math_optimization::detail { // 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::math_optimization::detail diff --git a/cpp/src/mip_heuristics/presolve/multi_probe.cuh b/cpp/src/mip_heuristics/presolve/multi_probe.cuh index a043770789..4affd97e77 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::math_optimization::detail { 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::math_optimization::detail diff --git a/cpp/src/mip_heuristics/presolve/probing_cache.cu b/cpp/src/mip_heuristics/presolve/probing_cache.cu index 3767e0f2d0..9621929cf4 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::math_optimization::detail { 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::math_optimization::detail diff --git a/cpp/src/mip_heuristics/presolve/probing_cache.cuh b/cpp/src/mip_heuristics/presolve/probing_cache.cuh index 91da6a15c8..d8cbe37891 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::math_optimization::detail { 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::math_optimization::detail diff --git a/cpp/src/mip_heuristics/presolve/semi_continuous.cu b/cpp/src/mip_heuristics/presolve/semi_continuous.cu index 812b14f5da..c7773f5db1 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::math_optimization::detail { namespace { @@ -416,4 +416,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::math_optimization::detail diff --git a/cpp/src/mip_heuristics/presolve/semi_continuous.cuh b/cpp/src/mip_heuristics/presolve/semi_continuous.cuh index 6d37c62b4d..68b8142157 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::math_optimization::detail { /** * @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::math_optimization::detail diff --git a/cpp/src/mip_heuristics/presolve/third_party_presolve.cpp b/cpp/src/mip_heuristics/presolve/third_party_presolve.cpp index d94cf5aa67..71329d08a8 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::math_optimization::detail { template papilo::Problem build_papilo_problem(const optimization_problem_t& op_problem, @@ -550,7 +550,7 @@ 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::math_optimization::detail::GF2Presolve())); } // fast presolvers presolver.addPresolveMethod(uptr(new papilo::SingletonCols())); @@ -661,7 +661,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::math_optimization::presolver_t presolver, bool dual_postsolve, f_t absolute_tolerance, f_t relative_tolerance, @@ -671,12 +671,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::math_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::math_optimization::presolver_t::PSLP) { return apply_pslp(op_problem, time_limit); } @@ -775,7 +775,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::math_optimization::presolver_t::PSLP) { undo_pslp(primal_solution, dual_solution, reduced_costs, stream_view); return; } @@ -856,7 +856,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::math_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 +899,4 @@ template struct papilo_postsolve_deleter; template class third_party_presolve_t; #endif -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::math_optimization::detail diff --git a/cpp/src/mip_heuristics/presolve/third_party_presolve.hpp b/cpp/src/mip_heuristics/presolve/third_party_presolve.hpp index a067f604e7..d8a430be0e 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::math_optimization::detail { template struct papilo_postsolve_deleter { @@ -60,7 +60,7 @@ class third_party_presolve_t { third_party_presolve_result_t apply(optimization_problem_t const& op_problem, problem_category_t category, - cuopt::linear_programming::presolver_t presolver, + cuopt::math_optimization::presolver_t presolver, bool dual_postsolve, f_t absolute_tolerance, f_t relative_tolerance, @@ -91,8 +91,8 @@ 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::math_optimization::presolver_t presolver_ = cuopt::math_optimization::presolver_t::PSLP; // PSLP settings Settings* pslp_stgs_{nullptr}; Presolver* pslp_presolver_{nullptr}; @@ -107,4 +107,4 @@ class third_party_presolve_t { std::vector original_to_reduced_map_{}; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::math_optimization::detail diff --git a/cpp/src/mip_heuristics/presolve/trivial_presolve.cu b/cpp/src/mip_heuristics/presolve/trivial_presolve.cu index 283998f142..14263b1709 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::math_optimization::detail { #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::math_optimization::detail diff --git a/cpp/src/mip_heuristics/presolve/trivial_presolve.cuh b/cpp/src/mip_heuristics/presolve/trivial_presolve.cuh index 28162d7482..96bbaa51c0 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::math_optimization::detail { template void test_renumbered_coo(raft::device_span coo_major, const problem_t& pb) @@ -371,4 +371,4 @@ void trivial_presolve(problem_t& problem, bool remap_cache_ids = false problem.check_problem_representation(true); } -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::math_optimization::detail diff --git a/cpp/src/mip_heuristics/presolve/trivial_presolve_helpers.cuh b/cpp/src/mip_heuristics/presolve/trivial_presolve_helpers.cuh index 95471d325d..e8c9ba4f8a 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::math_optimization::detail { 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::math_optimization::detail diff --git a/cpp/src/mip_heuristics/presolve/utils.cuh b/cpp/src/mip_heuristics/presolve/utils.cuh index 4870b3180c..257d99e501 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::math_optimization::detail { 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::math_optimization::detail diff --git a/cpp/src/mip_heuristics/problem/host_helper.cuh b/cpp/src/mip_heuristics/problem/host_helper.cuh index 00015282e9..dea0ae6d5a 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::math_optimization::detail { template struct constraints_delta_t { @@ -65,4 +65,4 @@ struct variables_delta_t { } }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::math_optimization::detail diff --git a/cpp/src/mip_heuristics/problem/load_balanced_problem.cu b/cpp/src/mip_heuristics/problem/load_balanced_problem.cu index 585cd1068f..0e542f85a5 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::math_optimization::detail { 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::math_optimization::detail diff --git a/cpp/src/mip_heuristics/problem/load_balanced_problem.cuh b/cpp/src/mip_heuristics/problem/load_balanced_problem.cuh index 85c54a622e..7528dc658d 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::math_optimization::detail { 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::math_optimization::detail diff --git a/cpp/src/mip_heuristics/problem/presolve_data.cu b/cpp/src/mip_heuristics/problem/presolve_data.cu index 884b5f9069..49d4d4b370 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 math_optimization::detail { 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::math_optimization::detail::has_nans(problem.handle_ptr, assignment); if (has_nans) { CUOPT_LOG_DEBUG("Solution discarded due to nans"); return false; @@ -80,7 +80,7 @@ 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( + auto has_integrality_discrepancy = cuopt::math_optimization::detail::has_integrality_discrepancy( problem.handle_ptr, problem.integer_indices, assignment, @@ -91,7 +91,7 @@ bool presolve_data_t::pre_process_assignment(problem_t& prob } auto has_variable_bounds_violation = - cuopt::linear_programming::detail::has_variable_bounds_violation( + cuopt::math_optimization::detail::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 +250,5 @@ template class presolve_data_t; template class presolve_data_t; #endif -} // namespace linear_programming::detail +} // namespace math_optimization::detail } // namespace cuopt diff --git a/cpp/src/mip_heuristics/problem/presolve_data.cuh b/cpp/src/mip_heuristics/problem/presolve_data.cuh index cac3e71650..dcd432fdd8 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 math_optimization::detail { template class problem_t; @@ -133,5 +133,5 @@ class presolve_data_t { std::vector> variable_substitutions; }; -} // namespace linear_programming::detail +} // namespace math_optimization::detail } // namespace cuopt diff --git a/cpp/src/mip_heuristics/problem/problem.cu b/cpp/src/mip_heuristics/problem/problem.cu index 70007803d6..45e6cd4daf 100644 --- a/cpp/src/mip_heuristics/problem/problem.cu +++ b/cpp/src/mip_heuristics/problem/problem.cu @@ -48,7 +48,7 @@ #include -namespace cuopt::linear_programming::detail { +namespace cuopt::math_optimization::detail { template void problem_t::op_problem_cstr_body(const optimization_problem_t& problem_) @@ -1363,7 +1363,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::math_optimization::detail::is_integer; objective_is_integral = thrust::all_of(handle_ptr->get_thrust_policy(), @@ -2153,7 +2153,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 cuopt::math_optimization::dual_simplex::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"); @@ -2274,7 +2274,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 + cuopt::math_optimization::dual_simplex::user_problem_t& user_problem) const { raft::common::nvtx::range fun_scope("get_host_user_problem"); // std::lock_guard lock(problem_mutex); @@ -2363,8 +2363,8 @@ void problem_t::get_host_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::math_optimization::dual_simplex::variable_type_t::CONTINUOUS + : cuopt::math_optimization::dual_simplex::variable_type_t::INTEGER; } } @@ -2496,4 +2496,4 @@ template class problem_t; template class problem_t; #endif -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::math_optimization::detail diff --git a/cpp/src/mip_heuristics/problem/problem.cuh b/cpp/src/mip_heuristics/problem/problem.cuh index bcc0454b24..4008077472 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 math_optimization::detail { 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::math_optimization::dual_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::math_optimization::dual_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::math_optimization::dual_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::math_optimization::dual_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 math_optimization::detail } // namespace cuopt diff --git a/cpp/src/mip_heuristics/problem/problem_fixing.cuh b/cpp/src/mip_heuristics/problem/problem_fixing.cuh index 820b74e329..3632259108 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 math_optimization::detail { 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 math_optimization::detail } // namespace cuopt diff --git a/cpp/src/mip_heuristics/problem/problem_helpers.cuh b/cpp/src/mip_heuristics/problem/problem_helpers.cuh index 77cc973aa0..c756c8857b 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::math_optimization::detail { template struct transform_bounds_functor { __device__ thrust::tuple operator()(const thrust::tuple& input) const @@ -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::math_optimization::detail diff --git a/cpp/src/mip_heuristics/problem/problem_kernels.cuh b/cpp/src/mip_heuristics/problem/problem_kernels.cuh index 249b073724..e485f192ce 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::math_optimization::detail { 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::math_optimization::detail diff --git a/cpp/src/mip_heuristics/problem/write_mps.cu b/cpp/src/mip_heuristics/problem/write_mps.cu index 55d96c07e0..eb8c53e035 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::math_optimization::detail { 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::math_optimization::detail diff --git a/cpp/src/mip_heuristics/relaxed_lp/lp_state.cuh b/cpp/src/mip_heuristics/relaxed_lp/lp_state.cuh index 3820758dc0..49f632ff0c 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::math_optimization::detail { template class problem_t; @@ -68,4 +68,4 @@ class lp_state_t { rmm::device_uvector prev_dual; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::math_optimization::detail diff --git a/cpp/src/mip_heuristics/relaxed_lp/relaxed_lp.cu b/cpp/src/mip_heuristics/relaxed_lp/relaxed_lp.cu index 84415f5372..c8b0e783bf 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::math_optimization::detail { template optimization_problem_solution_t get_relaxed_lp_solution( @@ -228,4 +228,4 @@ INSTANTIATE(double) #undef INSTANTIATE -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::math_optimization::detail diff --git a/cpp/src/mip_heuristics/relaxed_lp/relaxed_lp.cuh b/cpp/src/mip_heuristics/relaxed_lp/relaxed_lp.cuh index 9fe5fb9071..52251465e7 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::math_optimization::detail { 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::math_optimization::detail diff --git a/cpp/src/mip_heuristics/solution/feasibility_test.cuh b/cpp/src/mip_heuristics/solution/feasibility_test.cuh index 0fc7a3d119..69cfee23ae 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::math_optimization::detail { 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::math_optimization::detail diff --git a/cpp/src/mip_heuristics/solution/solution.cu b/cpp/src/mip_heuristics/solution/solution.cu index 2a05a1ca56..a31dadd2d1 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::math_optimization::detail { template rmm::device_uvector get_lower_bounds( @@ -651,4 +651,4 @@ template class solution_t; template class solution_t; #endif -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::math_optimization::detail diff --git a/cpp/src/mip_heuristics/solution/solution.cuh b/cpp/src/mip_heuristics/solution/solution.cuh index 9de10ed980..914ec9d63b 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::math_optimization::detail { template class solution_t { @@ -154,4 +154,4 @@ class solution_t { void test_variable_bounds(bool check_integer = true, i_t* is_feasible = nullptr); }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::math_optimization::detail diff --git a/cpp/src/mip_heuristics/solution/solution_kernels.cuh b/cpp/src/mip_heuristics/solution/solution_kernels.cuh index 1383569bcd..4ef5f56d7e 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::math_optimization::detail { 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::math_optimization::detail diff --git a/cpp/src/mip_heuristics/solve.cu b/cpp/src/mip_heuristics/solve.cu index ef474e7c12..91b2cf41b1 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,7 @@ #include #include -namespace cuopt::linear_programming { +namespace cuopt::math_optimization { // 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) @@ -553,7 +553,7 @@ mip_solution_t solve_mip_helper(optimization_problem_t& op_p } presolver = std::make_unique>(); auto result = presolver->apply(op_problem, - cuopt::linear_programming::problem_category_t::MIP, + cuopt::math_optimization::problem_category_t::MIP, settings.presolver, dual_postsolve, settings.tolerances.absolute_tolerance, @@ -642,7 +642,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::math_optimization::problem_category_t::MIP, status_to_skip, dual_postsolve, op_problem.get_handle_ptr()->get_stream()); @@ -916,7 +916,7 @@ std::unique_ptr> 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::math_optimization::io::mps_data_model_t& mps_data_model, \ mip_solver_settings_t const& settings); \ \ template std::unique_ptr> solve_mip( \ @@ -933,4 +933,4 @@ INSTANTIATE(float) INSTANTIATE(double) #endif -} // namespace cuopt::linear_programming +} // namespace cuopt::math_optimization diff --git a/cpp/src/mip_heuristics/solver.cu b/cpp/src/mip_heuristics/solver.cu index 858e865bc3..578c1cd708 100644 --- a/cpp/src/mip_heuristics/solver.cu +++ b/cpp/src/mip_heuristics/solver.cu @@ -33,7 +33,7 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::math_optimization::detail { // 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) @@ -296,19 +296,19 @@ 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; + cuopt::math_optimization::dual_simplex::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::math_optimization::dual_simplex::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::math_optimization::dual_simplex::detect_symmetry( post_presolve_problem, simplex_settings, has_symmetry_post); } #endif - namespace dual_simplex = cuopt::linear_programming::dual_simplex; + namespace dual_simplex = cuopt::math_optimization::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); context.problem_ptr->recompute_objective_integrality(); @@ -541,4 +541,4 @@ template class mip_solver_t; template class mip_solver_t; #endif -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::math_optimization::detail diff --git a/cpp/src/mip_heuristics/solver.cuh b/cpp/src/mip_heuristics/solver.cuh index 9b9024a1dc..8deb0867be 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::math_optimization::detail { template class mip_solver_t { @@ -32,4 +32,4 @@ class mip_solver_t { timer_t timer_; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::math_optimization::detail diff --git a/cpp/src/mip_heuristics/solver_context.cuh b/cpp/src/mip_heuristics/solver_context.cuh index 739f7d130a..4014133a82 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::math_optimization::dual_simplex { template class branch_and_bound_t; } #include -namespace cuopt::linear_programming::detail { +namespace cuopt::math_optimization::detail { template class diversity_manager_t; @@ -79,4 +79,4 @@ struct mip_solver_context_t { std::unique_ptr> symmetry; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::math_optimization::detail diff --git a/cpp/src/mip_heuristics/solver_settings.cu b/cpp/src/mip_heuristics/solver_settings.cu index dededa2f91..f051f71520 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::math_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::math_optimization diff --git a/cpp/src/mip_heuristics/solver_solution.cu b/cpp/src/mip_heuristics/solver_solution.cu index 8f6f8de05f..540c5edd7a 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::math_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::math_optimization diff --git a/cpp/src/mip_heuristics/utilities/sort_csr.cuh b/cpp/src/mip_heuristics/utilities/sort_csr.cuh index 92e560dbb9..8d66f24b05 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 math_optimization::detail { 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 math_optimization::detail } // namespace cuopt diff --git a/cpp/src/mip_heuristics/utils.cuh b/cpp/src/mip_heuristics/utils.cuh index ffadc1f510..3b8cbe5dd1 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::math_optimization::detail { // TODO templatize as needed constexpr double default_cont_upper = std::numeric_limits::infinity(); @@ -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::math_optimization::detail diff --git a/cpp/src/pdlp/backend_selection.cpp b/cpp/src/pdlp/backend_selection.cpp index 4f2dc62bcf..aa79915e7d 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::math_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::math_optimization diff --git a/cpp/src/pdlp/cpu_optimization_problem.cpp b/cpp/src/pdlp/cpu_optimization_problem.cpp index 5bb3e25cad..5ee0544cad 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::math_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::math_optimization::io::data_model_view_t data_model_view; // Set optimization sense data_model_view.set_maximize(maximize_); @@ -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::math_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::math_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..fdde802405 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::math_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::math_optimization diff --git a/cpp/src/pdlp/cuopt_c.cpp b/cpp/src/pdlp/cuopt_c.cpp index bf3f6f7433..6f3bd0790f 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,8 @@ #include #include -using namespace cuopt::linear_programming::io; -using namespace cuopt::linear_programming; +using namespace cuopt::math_optimization::io; +using namespace cuopt::math_optimization; class c_get_solution_callback_t : public cuopt::internals::get_solution_callback_t { public: @@ -828,7 +828,7 @@ 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); diff --git a/cpp/src/pdlp/cuopt_c_internal.hpp b/cpp/src/pdlp/cuopt_c_internal.hpp index f10b1d023e..ebfcbb8f45 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::math_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::math_optimization diff --git a/cpp/src/pdlp/cusparse_view.cu b/cpp/src/pdlp/cusparse_view.cu index 736aa4628a..7aaf61de10 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::math_optimization::detail { // cusparse_sp_mat_descr_wrapper_t implementation template @@ -1542,4 +1542,4 @@ template void my_cusparsespmm_preprocess(cusparseHandle_t, #endif #endif -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::math_optimization::detail diff --git a/cpp/src/pdlp/cusparse_view.hpp b/cpp/src/pdlp/cusparse_view.hpp index 67dbb5a570..231ad35ba3 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::math_optimization::detail { template class cusparse_sp_mat_descr_wrapper_t { @@ -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::math_optimization::detail diff --git a/cpp/src/pdlp/initial_scaling_strategy/initial_scaling.cu b/cpp/src/pdlp/initial_scaling_strategy/initial_scaling.cu index c79249c45d..fe7ae841fa 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::math_optimization::detail { template struct weighted_square_op { @@ -972,4 +972,4 @@ INSTANTIATE(float) INSTANTIATE(double) #endif -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::math_optimization::detail diff --git a/cpp/src/pdlp/initial_scaling_strategy/initial_scaling.cuh b/cpp/src/pdlp/initial_scaling_strategy/initial_scaling.cuh index 99d1472b6f..0c7d69233c 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::math_optimization::detail { template class pdlp_initial_scaling_strategy_t { @@ -125,4 +125,4 @@ class pdlp_initial_scaling_strategy_t { const pdlp_hyper_params::pdlp_hyper_params_t& hyper_params_; bool running_mip_; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::math_optimization::detail 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..d18126b207 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::math_optimization::detail { template struct SpMM_benchmarks_context_t { @@ -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::math_optimization::detail 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..0eebea53f0 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::math_optimization::detail { 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..7015ca1e53 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::math_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::math_optimization::io::data_model_view_t data_model_view; // Set optimization sense data_model_view.set_maximize(get_sense()); @@ -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::math_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::math_optimization diff --git a/cpp/src/pdlp/pdhg.cu b/cpp/src/pdlp/pdhg.cu index e88366a295..fd4a88ae5f 100644 --- a/cpp/src/pdlp/pdhg.cu +++ b/cpp/src/pdlp/pdhg.cu @@ -38,7 +38,7 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::math_optimization::detail { template pdhg_solver_t::pdhg_solver_t( @@ -1502,4 +1502,4 @@ template class pdhg_solver_t; template class pdhg_solver_t; #endif -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::math_optimization::detail diff --git a/cpp/src/pdlp/pdhg.hpp b/cpp/src/pdlp/pdhg.hpp index 01eabe967a..196676a9c4 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,7 +23,7 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::math_optimization::detail { template class pdhg_solver_t { public: @@ -152,4 +152,4 @@ class pdhg_solver_t { cuda::fast_mod_div batch_size_divisor_; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::math_optimization::detail diff --git a/cpp/src/pdlp/pdlp.cu b/cpp/src/pdlp/pdlp.cu index dadc54cc08..dcbc629dbc 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/math_optimization/pdlp/solver_solution.hpp" #include #include @@ -45,7 +45,7 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::math_optimization::detail { // Templated wrapper for cuBLAS geam function // cublasSgeam for float, cublasDgeam for double @@ -3226,4 +3226,4 @@ template __global__ void compute_weights_initial_primal_weight_from_squared_norm const pdlp_hyper_params::pdlp_hyper_params_t hyper_params); #endif -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::math_optimization::detail diff --git a/cpp/src/pdlp/pdlp.cuh b/cpp/src/pdlp/pdlp.cuh index 9447eaeaf3..47f2c9c2f2 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::math_optimization::detail { /** * @brief Solver for an optimization problem (Currently only linear program) to be solved, * pdlp_parameters and pdlp_internal_state @@ -249,4 +249,4 @@ class pdlp_solver_t { bool inside_mip_{false}; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::math_optimization::detail diff --git a/cpp/src/pdlp/pdlp_constants.hpp b/cpp/src/pdlp/pdlp_constants.hpp index 568d7d00b0..f3bcf9731d 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::math_optimization::detail { 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::math_optimization::detail diff --git a/cpp/src/pdlp/pdlp_warm_start_data.cu b/cpp/src/pdlp/pdlp_warm_start_data.cu index 80abf015d8..1711105f56 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::math_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::math_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..fb3bd70e96 100644 --- a/cpp/src/pdlp/restart_strategy/localized_duality_gap_container.cu +++ b/cpp/src/pdlp/restart_strategy/localized_duality_gap_container.cu @@ -13,9 +13,9 @@ #include -#include +#include -namespace cuopt::linear_programming::detail { +namespace cuopt::math_optimization::detail { template localized_duality_gap_container_t::localized_duality_gap_container_t( raft::handle_t const* handle_ptr, @@ -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::math_optimization::detail 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..8767d302a9 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::math_optimization::detail { template struct localized_duality_gap_container_t { public: @@ -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::math_optimization::detail diff --git a/cpp/src/pdlp/restart_strategy/pdlp_restart_strategy.cu b/cpp/src/pdlp/restart_strategy/pdlp_restart_strategy.cu index 17c7abcac5..b365addfe0 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,7 +50,7 @@ namespace cg = cooperative_groups; -namespace cuopt::linear_programming::detail { +namespace cuopt::math_optimization::detail { template __global__ void solve_bound_constrained_trust_region_kernel( @@ -2539,4 +2539,4 @@ INSTANTIATE(float) INSTANTIATE(double) #endif -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::math_optimization::detail diff --git a/cpp/src/pdlp/restart_strategy/pdlp_restart_strategy.cuh b/cpp/src/pdlp/restart_strategy/pdlp_restart_strategy.cuh index 0c00e50240..a9c2586d1e 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::math_optimization::detail { template class pdlp_restart_strategy_t { public: @@ -411,4 +411,4 @@ bool is_cupdlpx_restart(const pdlp_hyper_params::pdlp_hyper_params_t& hyper_para static_cast(pdlp_restart_strategy_t::restart_strategy_t::CUPDLPX_RESTART); } -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::math_optimization::detail diff --git a/cpp/src/pdlp/restart_strategy/weighted_average_solution.cu b/cpp/src/pdlp/restart_strategy/weighted_average_solution.cu index 098ad7911b..d19433d445 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::math_optimization::detail { 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::math_optimization::detail diff --git a/cpp/src/pdlp/restart_strategy/weighted_average_solution.hpp b/cpp/src/pdlp/restart_strategy/weighted_average_solution.hpp index c30ec0dceb..5d57de13c8 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::math_optimization::detail { 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::math_optimization::detail diff --git a/cpp/src/pdlp/saddle_point.cu b/cpp/src/pdlp/saddle_point.cu index f740176a3c..2c233d86ea 100644 --- a/cpp/src/pdlp/saddle_point.cu +++ b/cpp/src/pdlp/saddle_point.cu @@ -15,7 +15,7 @@ #include -namespace cuopt::linear_programming::detail { +namespace cuopt::math_optimization::detail { template saddle_point_state_t::saddle_point_state_t( @@ -179,4 +179,4 @@ template class saddle_point_state_t; template class saddle_point_state_t; #endif -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::math_optimization::detail diff --git a/cpp/src/pdlp/saddle_point.hpp b/cpp/src/pdlp/saddle_point.hpp index eb6b8025cf..4192d3f2b9 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::math_optimization::detail { /** * @brief Structure to hold the current solution to the saddle point problem * @@ -115,4 +115,4 @@ class saddle_point_state_t { rmm::device_uvector next_AtY_; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::math_optimization::detail diff --git a/cpp/src/pdlp/solution_conversion.cu b/cpp/src/pdlp/solution_conversion.cu index 8ec3c20b27..e0127c9490 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::math_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::math_optimization diff --git a/cpp/src/pdlp/solve.cu b/cpp/src/pdlp/solve.cu index 5d29e97fa0..9f95ab54a1 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::math_optimization { template extern rmm::device_uvector gpu_cast(const rmm::device_uvector& src, @@ -1016,7 +1016,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::math_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; @@ -1458,7 +1458,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::math_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) @@ -1965,7 +1965,7 @@ optimization_problem_solution_t solve_lp( std::max(1.0, std::min(0.1 * lp_timer.remaining_time(), 60.0)); presolver = std::make_unique>(); result = presolver->apply(op_problem, - cuopt::linear_programming::problem_category_t::LP, + cuopt::math_optimization::problem_category_t::LP, settings.presolver, settings.dual_postsolve, settings.tolerances.absolute_primal_tolerance, @@ -2004,7 +2004,7 @@ optimization_problem_solution_t solve_lp( presolver->undo(empty_primal, empty_dual, empty_reduced_costs, - cuopt::linear_programming::problem_category_t::LP, + cuopt::math_optimization::problem_category_t::LP, false, // status_to_skip settings.dual_postsolve, op_problem.get_handle_ptr()->get_stream()); @@ -2075,7 +2075,7 @@ optimization_problem_solution_t solve_lp( presolver->undo(primal_solution, dual_solution, reduced_costs, - cuopt::linear_programming::problem_category_t::LP, + cuopt::math_optimization::problem_category_t::LP, status_to_skip, settings.dual_postsolve, op_problem.get_handle_ptr()->get_stream()); @@ -2116,14 +2116,14 @@ optimization_problem_solution_t solve_lp( } template -cuopt::linear_programming::optimization_problem_t mps_data_model_to_optimization_problem( +cuopt::math_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::math_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::math_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) { @@ -2208,7 +2208,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::math_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 +2313,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::math_optimization::io::mps_data_model_t& mps_data_model, \ pdlp_solver_settings_t const& settings, \ bool problem_checking, \ bool use_pdlp_solver_mode); \ @@ -2340,7 +2340,7 @@ std::unique_ptr> 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::math_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 +2356,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::math_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 +2367,4 @@ INSTANTIATE(float) INSTANTIATE(double) #endif -} // namespace cuopt::linear_programming +} // namespace cuopt::math_optimization diff --git a/cpp/src/pdlp/solve.cuh b/cpp/src/pdlp/solve.cuh index 90e5e4fe95..0447e8bfee 100644 --- a/cpp/src/pdlp/solve.cuh +++ b/cpp/src/pdlp/solve.cuh @@ -7,13 +7,13 @@ #pragma once -#include +#include -#include +#include #include -namespace cuopt::linear_programming { +namespace cuopt::math_optimization { namespace detail { template @@ -21,12 +21,12 @@ class problem_t; } // namespace detail template -cuopt::linear_programming::optimization_problem_t mps_data_model_to_optimization_problem( +cuopt::math_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::math_optimization::io::mps_data_model_t& data_model); template -cuopt::linear_programming::optimization_problem_solution_t solve_lp_with_method( +cuopt::math_optimization::optimization_problem_solution_t solve_lp_with_method( detail::problem_t& problem, pdlp_solver_settings_t const& settings, const timer_t& timer, @@ -82,8 +82,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::math_optimization::optimization_problem_solution_t run_batch_pdlp( + cuopt::math_optimization::optimization_problem_t& problem, pdlp_solver_settings_t const& settings); /** @@ -101,7 +101,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::math_optimization::optimization_problem_t& problem, bool per_climber_objectives, bool per_climber_constraint_bounds, bool collect_solutions = false); // Only for testing @@ -109,4 +109,4 @@ size_t compute_optimal_batch_size( template void set_pdlp_solver_mode(pdlp_solver_settings_t& settings); -} // namespace cuopt::linear_programming +} // namespace cuopt::math_optimization diff --git a/cpp/src/pdlp/solver_settings.cu b/cpp/src/pdlp/solver_settings.cu index 28e7428fac..78b45ef46a 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::math_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::math_optimization diff --git a/cpp/src/pdlp/solver_solution.cu b/cpp/src/pdlp/solver_solution.cu index ec0492dac3..559a1604e3 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::math_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::math_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..55b23fb30f 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::math_optimization::detail { template adaptive_step_size_strategy_t::adaptive_step_size_strategy_t( @@ -585,4 +585,4 @@ INSTANTIATE(float) INSTANTIATE(double) #endif -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::math_optimization::detail 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..709d386738 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::math_optimization::detail { template class adaptive_step_size_strategy_t { public: @@ -120,4 +120,4 @@ class adaptive_step_size_strategy_t { const std::vector& climber_strategies_; const pdlp_hyper_params::pdlp_hyper_params_t& hyper_params_; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::math_optimization::detail diff --git a/cpp/src/pdlp/swap_and_resize_helper.cuh b/cpp/src/pdlp/swap_and_resize_helper.cuh index 6ed05df241..9b2695ff64 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::math_optimization::detail { 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::math_optimization::detail diff --git a/cpp/src/pdlp/termination_strategy/convergence_information.cu b/cpp/src/pdlp/termination_strategy/convergence_information.cu index a6d6d14d96..d70e56768a 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,7 +33,7 @@ #include -namespace cuopt::linear_programming::detail { +namespace cuopt::math_optimization::detail { template convergence_information_t::convergence_information_t( raft::handle_t const* handle_ptr, @@ -1027,4 +1027,4 @@ template __global__ void compute_remaining_stats_kernel( int batch_size); #endif -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::math_optimization::detail diff --git a/cpp/src/pdlp/termination_strategy/convergence_information.hpp b/cpp/src/pdlp/termination_strategy/convergence_information.hpp index 2389a60fae..8ea8da6a39 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,7 +25,7 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::math_optimization::detail { template class convergence_information_t { public: @@ -209,4 +209,4 @@ class convergence_information_t { const std::vector& climber_strategies_; const pdlp_hyper_params::pdlp_hyper_params_t& hyper_params_; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::math_optimization::detail diff --git a/cpp/src/pdlp/termination_strategy/infeasibility_information.cu b/cpp/src/pdlp/termination_strategy/infeasibility_information.cu index 9268e17910..15e4111172 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,7 +34,7 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::math_optimization::detail { template infeasibility_information_t::infeasibility_information_t( raft::handle_t const* handle_ptr, @@ -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::math_optimization::detail diff --git a/cpp/src/pdlp/termination_strategy/infeasibility_information.hpp b/cpp/src/pdlp/termination_strategy/infeasibility_information.hpp index df746e8541..55cd790608 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,7 +23,7 @@ #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::math_optimization::detail { template class infeasibility_information_t { public: @@ -136,4 +136,4 @@ class infeasibility_information_t { const std::vector& climber_strategies_; const pdlp_hyper_params::pdlp_hyper_params_t& hyper_params_; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::math_optimization::detail diff --git a/cpp/src/pdlp/termination_strategy/termination_strategy.cu b/cpp/src/pdlp/termination_strategy/termination_strategy.cu index d1a88799d6..78eb71f11a 100644 --- a/cpp/src/pdlp/termination_strategy/termination_strategy.cu +++ b/cpp/src/pdlp/termination_strategy/termination_strategy.cu @@ -12,15 +12,15 @@ #include -#include -#include -#include +#include +#include +#include #include #include #include -namespace cuopt::linear_programming::detail { +namespace cuopt::math_optimization::detail { template pdlp_termination_strategy_t::pdlp_termination_strategy_t( raft::handle_t const* handle_ptr, @@ -710,4 +710,4 @@ INSTANTIATE(double) #undef INSTANTIATE -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::math_optimization::detail diff --git a/cpp/src/pdlp/termination_strategy/termination_strategy.hpp b/cpp/src/pdlp/termination_strategy/termination_strategy.hpp index 5cd43d7be7..dc0d4ce080 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,7 +27,7 @@ #include -namespace cuopt::linear_programming::detail { +namespace cuopt::math_optimization::detail { template class pdlp_termination_strategy_t { public: @@ -235,4 +235,4 @@ class pdlp_termination_strategy_t { const std::vector& climber_strategies_; }; -} // namespace cuopt::linear_programming::detail +} // namespace cuopt::math_optimization::detail diff --git a/cpp/src/pdlp/translate.hpp b/cpp/src/pdlp/translate.hpp index be832e082d..6d4cf8b638 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,7 +23,7 @@ #include #include -namespace cuopt::linear_programming { +namespace cuopt::math_optimization { template static dual_simplex::user_problem_t cuopt_problem_to_user_problem( @@ -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::math_optimization::dual_simplex::variable_type_t::CONTINUOUS + : cuopt::math_optimization::dual_simplex::variable_type_t::INTEGER; } user_problem.Q_offsets = problem.get_quadratic_objective_offsets(); @@ -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::math_optimization::dual_simplex::variable_type_t::CONTINUOUS + : cuopt::math_optimization::dual_simplex::variable_type_t::INTEGER; } user_problem.Q_offsets = model.Q_offsets; @@ -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::math_optimization::dual_simplex::variable_type_t::CONTINUOUS + : cuopt::math_optimization::dual_simplex::variable_type_t::INTEGER; } user_problem.Q_offsets = model.get_quadratic_objective_offsets(); @@ -415,4 +415,4 @@ void translate_to_crossover_problem(const detail::problem_t& problem, CUOPT_LOG_DEBUG("Finished translating"); } -} // namespace cuopt::linear_programming +} // namespace cuopt::math_optimization diff --git a/cpp/src/pdlp/utilities/cython_solve.cu b/cpp/src/pdlp/utilities/cython_solve.cu index ec3cc2862f..cb7e72606d 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,21 @@ 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::math_optimization::lp_solution_interface_t* call_solve_lp( + cuopt::math_optimization::optimization_problem_interface_t* problem_interface, + cuopt::math_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, + problem_interface->get_problem_category() == cuopt::math_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::math_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 +70,57 @@ 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::math_optimization::mip_solution_interface_t* call_solve_mip( + cuopt::math_optimization::optimization_problem_interface_t* problem_interface, + cuopt::math_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::math_optimization::problem_category_t::MIP) or (problem_interface->get_problem_category() == - cuopt::linear_programming::problem_category_t::IP), + cuopt::math_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); + auto solution_interface = cuopt::math_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::math_optimization::io::data_model_view_t* data_model, + cuopt::math_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::math_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::math_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::math_optimization::optimization_problem_t(&handle_); + cuopt::math_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() == math_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 = math_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 +142,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 = math_optimization::problem_category_t::MIP; // Same stream reassociation as the LP path above. auto& gpu_sol = std::get(response.mip_ret.solution_); @@ -175,26 +174,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::math_optimization::cpu_optimization_problem_t(); + cuopt::math_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() == math_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 = math_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 = math_optimization::problem_category_t::MIP; } } @@ -202,7 +201,7 @@ 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 +237,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::math_optimization::solver_settings_t* solver_settings) { cuopt_expects( false, @@ -250,12 +249,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::math_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::math_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..d0944d27a3 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::math_optimization::detail { 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::math_optimization::detail diff --git a/cpp/src/pdlp/utilities/ping_pong_graph.cuh b/cpp/src/pdlp/utilities/ping_pong_graph.cuh index dbc8fe5828..232e6c1f99 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::math_optimization::detail { // 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::math_optimization::detail diff --git a/cpp/src/pdlp/utilities/problem_checking.cu b/cpp/src/pdlp/utilities/problem_checking.cu index 35483c9c8e..028882fd7d 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::math_optimization { template void problem_checking_t::check_csr_representation( @@ -386,4 +386,4 @@ INSTANTIATE(double) #undef INSTANTIATE -} // namespace cuopt::linear_programming +} // namespace cuopt::math_optimization diff --git a/cpp/src/pdlp/utilities/problem_checking.cuh b/cpp/src/pdlp/utilities/problem_checking.cuh index 72f4b876b9..708622037a 100644 --- a/cpp/src/pdlp/utilities/problem_checking.cuh +++ b/cpp/src/pdlp/utilities/problem_checking.cuh @@ -1,21 +1,21 @@ /* 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::math_optimization { namespace detail { template @@ -48,4 +48,4 @@ class problem_checking_t { const mip_solver_settings_t& settings); }; -} // namespace cuopt::linear_programming +} // namespace cuopt::math_optimization diff --git a/cpp/src/pdlp/utils.cuh b/cpp/src/pdlp/utils.cuh index 3f589da470..a2e667720c 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::math_optimization::detail { template DI f_t deterministic_block_reduce(raft::device_span shared, f_t val) @@ -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::math_optimization::detail diff --git a/cpp/src/utilities/device_utils.cuh b/cpp/src/utilities/device_utils.cuh index 073b3e35a5..462134a0b6 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::math_optimization::detail { #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::math_optimization::detail diff --git a/cpp/src/utilities/double_buffer.hpp b/cpp/src/utilities/double_buffer.hpp index c940b91f52..6351bebefb 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::math_optimization::detail { 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::math_optimization::detail diff --git a/cpp/src/utilities/hashing.hpp b/cpp/src/utilities/hashing.hpp index 9e8dc09e12..9c42f37a7c 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::math_optimization::detail { 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::math_optimization::detail 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..3bf50e6d54 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::math_optimization::dual_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::math_optimization::dual_simplex::test diff --git a/cpp/tests/dual_simplex/unit_tests/solve.cpp b/cpp/tests/dual_simplex/unit_tests/solve.cpp index 9bf8360ed1..a21d211e5e 100644 --- a/cpp/tests/dual_simplex/unit_tests/solve.cpp +++ b/cpp/tests/dual_simplex/unit_tests/solve.cpp @@ -16,15 +16,15 @@ #include #include -#include +#include #include -namespace cuopt::linear_programming::dual_simplex::test { +namespace cuopt::math_optimization::dual_simplex::test { TEST(dual_simplex, chess_set) { cuopt::init_logger_t log("", true); - namespace dual_simplex = cuopt::linear_programming::dual_simplex; + namespace dual_simplex = cuopt::math_optimization::dual_simplex; raft::handle_t handle{}; dual_simplex::user_problem_t user_problem(&handle); // maximize 5*xs + 20*xl @@ -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::math_optimization::dual_simplex::user_problem_t user_problem(&handle); constexpr int m = 1; constexpr int n = num_items; constexpr int nz = num_items; @@ -152,12 +152,12 @@ 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::math_optimization::dual_simplex::variable_type_t::INTEGER; } - cuopt::linear_programming::dual_simplex::simplex_solver_settings_t settings; + cuopt::math_optimization::dual_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::math_optimization::dual_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 +185,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::math_optimization::dual_simplex::user_problem_t user_problem(&handle); constexpr int m = 1; constexpr int n = num_items; constexpr int nz = num_items - 1; @@ -232,17 +232,16 @@ TEST(dual_simplex, empty_columns) 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::CONTINUOUS; + user_problem.var_types[j] = cuopt::math_optimization::dual_simplex::variable_type_t::CONTINUOUS; } - cuopt::linear_programming::dual_simplex::simplex_solver_settings_t settings; + cuopt::math_optimization::dual_simplex::simplex_solver_settings_t settings; - cuopt::linear_programming::dual_simplex::lp_solution_t solution( + cuopt::math_optimization::dual_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::math_optimization::dual_simplex::solve_linear_program( user_problem, settings, solution)), - cuopt::linear_programming::dual_simplex::lp_status_t::OPTIMAL); + cuopt::math_optimization::dual_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 +267,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::math_optimization::dual_simplex::user_problem_t user_problem(&handle); constexpr int m = 2; constexpr int n = 2; constexpr int nz = 4; @@ -331,4 +330,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::math_optimization::dual_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..1022dd4995 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::math_optimization::dual_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,7 +42,7 @@ 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 dual_simplex = cuopt::math_optimization::dual_simplex; raft::handle_t handle{}; init_handler(&handle); dual_simplex::user_problem_t user_problem(&handle); @@ -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::math_optimization::dual_simplex::user_problem_t user_problem(&handle); constexpr int m = 2; constexpr int n = 2; constexpr int nz = 4; @@ -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::math_optimization::io::read_mps(path); - auto settings = cuopt::linear_programming::pdlp_solver_settings_t{}; + auto settings = cuopt::math_optimization::pdlp_solver_settings_t{}; - auto solution = cuopt::linear_programming::solve_lp(&handle, mps_data, settings); + auto solution = cuopt::math_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::math_optimization::dual_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..60fa09bf84 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..cdcf391eb0 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::math_optimization::detail { 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::math_optimization::problem_and_stream_view_t; cuOptOptimizationProblem original_handle = nullptr; cuOptOptimizationProblem reread_handle = nullptr; @@ -406,7 +406,7 @@ TEST(c_api, pdlp_precision_single) TEST(c_api, pdlp_precision_mixed) { - using namespace cuopt::linear_programming::detail; + using namespace cuopt::math_optimization::detail; 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; 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..80ae599ae5 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..a2a2f5e2d5 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::math_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..e4738e5c44 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::math_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::math_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..cf7970b692 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::math_optimization; +using cuopt::math_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::math_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..f82545883d 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::math_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..ea38de6016 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::math_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::math_optimization::testing diff --git a/cpp/tests/linear_programming/parser_test.cpp b/cpp/tests/linear_programming/parser_test.cpp index af1368865d..c57a34715c 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::math_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::math_optimization::io diff --git a/cpp/tests/linear_programming/pdlp_test.cu b/cpp/tests/linear_programming/pdlp_test.cu index e4c8bc6767..ca43dafbdd 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::math_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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_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::math_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::math_optimization::detail; 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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_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::math_optimization::method_t::PDLP; + settings.pdlp_precision = cuopt::math_optimization::pdlp_precision_t::MixedPrecision; optimization_problem_solution_t solution = solve_lp(&handle_, op_problem, settings); @@ -114,12 +114,12 @@ 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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_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; + settings_mixed.method = cuopt::math_optimization::method_t::PDLP; + settings_mixed.pdlp_precision = cuopt::math_optimization::pdlp_precision_t::MixedPrecision; optimization_problem_solution_t solution_mixed = solve_lp(&handle_, op_problem, settings_mixed); @@ -129,8 +129,8 @@ TEST(pdlp_class, precision_mixed) 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; + settings_full.method = cuopt::math_optimization::method_t::PDLP; + settings_full.pdlp_precision = cuopt::math_optimization::pdlp_precision_t::DefaultPrecision; optimization_problem_solution_t solution_full = solve_lp(&handle_, op_problem, settings_full); @@ -149,12 +149,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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_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::math_optimization::method_t::Concurrent; + settings.presolver = cuopt::math_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 +173,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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_optimization::io::read_mps(path, true); - cuopt::linear_programming::pdlp_solver_settings_t settings = - cuopt::linear_programming::pdlp_solver_settings_t{}; + cuopt::math_optimization::pdlp_solver_settings_t settings = + cuopt::math_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 +186,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::math_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 +199,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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_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::math_optimization::method_t::PDLP; optimization_problem_solution_t solution = solve_lp(&handle_, op_problem, solver_settings); @@ -221,16 +221,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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_optimization::io::read_mps(path, true); - cuopt::linear_programming::pdlp_solver_settings_t settings = - cuopt::linear_programming::pdlp_solver_settings_t{}; + cuopt::math_optimization::pdlp_solver_settings_t settings = + cuopt::math_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::math_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 +246,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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_optimization::io::read_mps(path, true); auto settings = pdlp_solver_settings_t{}; settings.iteration_limit = 10; @@ -279,8 +279,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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_optimization::io::read_mps(path, true); constexpr int batch_size = 2; constexpr double tighter_tolerance = 1e-6; @@ -363,17 +363,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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_optimization::io::read_mps(path); - cuopt::linear_programming::pdlp_solver_settings_t settings = - cuopt::linear_programming::pdlp_solver_settings_t{}; + cuopt::math_optimization::pdlp_solver_settings_t settings = + cuopt::math_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::math_optimization::method_t::PDLP; optimization_problem_solution_t solution = solve_lp(&handle_, op_problem, settings); @@ -408,17 +408,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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_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::math_optimization::pdlp_solver_mode_t::Stable3, + cuopt::math_optimization::pdlp_solver_mode_t::Stable2, + cuopt::math_optimization::pdlp_solver_mode_t::Stable1, + cuopt::math_optimization::pdlp_solver_mode_t::Methodical1, + cuopt::math_optimization::pdlp_solver_mode_t::Fast1, }; for (auto solver_mode : solver_mode_list) { auto settings = pdlp_solver_settings_t{}; @@ -427,7 +427,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::math_optimization::method_t::PDLP; const raft::handle_t handle_{}; optimization_problem_solution_t solution = solve_lp(&handle_, op_problem, settings); @@ -466,20 +466,20 @@ 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::math_optimization::io::mps_data_model_t mps_data_model = + cuopt::math_optimization::io::read_mps(path); - auto op_problem = cuopt::linear_programming::mps_data_model_to_optimization_problem( + auto op_problem = cuopt::math_optimization::mps_data_model_to_optimization_problem( &handle_, mps_data_model); - cuopt::linear_programming::detail::problem_t problem(op_problem); + cuopt::math_optimization::detail::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::math_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::math_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 +491,7 @@ 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::math_optimization::detail::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 +502,7 @@ 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::math_optimization::detail::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 +513,7 @@ 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::math_optimization::detail::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 +524,7 @@ 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::math_optimization::detail::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 +540,7 @@ 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::math_optimization::detail::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 +550,7 @@ 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::math_optimization::detail::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 +560,7 @@ 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::math_optimization::detail::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 +576,7 @@ 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::math_optimization::detail::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 +589,7 @@ 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::math_optimization::detail::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 +605,7 @@ 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::math_optimization::detail::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 +617,7 @@ 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::math_optimization::detail::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 +632,7 @@ 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::math_optimization::detail::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 +650,7 @@ 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::math_optimization::detail::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 +662,7 @@ 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::math_optimization::detail::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 +674,7 @@ 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::math_optimization::detail::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 +692,7 @@ 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::math_optimization::detail::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 +707,7 @@ 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::math_optimization::detail::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 +723,7 @@ 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::math_optimization::detail::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 +744,26 @@ 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::math_optimization::io::mps_data_model_t mps_data_model = + cuopt::math_optimization::io::read_mps(path); - auto op_problem = cuopt::linear_programming::mps_data_model_to_optimization_problem( + auto op_problem = cuopt::math_optimization::mps_data_model_to_optimization_problem( &handle_, mps_data_model); - cuopt::linear_programming::detail::problem_t problem(op_problem); + cuopt::math_optimization::detail::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::math_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::math_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::math_optimization::detail::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 +781,7 @@ 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::math_optimization::detail::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 +794,7 @@ 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::math_optimization::detail::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 +810,7 @@ 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::math_optimization::detail::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 +853,20 @@ 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::math_optimization::detail::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::math_optimization::method_t::PDLP; + solver_settings.pdlp_solver_mode = cuopt::math_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::math_optimization::detail::pdlp_solver_t solver(problem, solver_settings); raft::copy(solver.pdhg_solver_.get_primal_solution().data(), d_initial_primal.data(), @@ -890,7 +890,7 @@ End } { solver_settings.per_constraint_residual = true; - cuopt::linear_programming::detail::pdlp_solver_t solver(problem, solver_settings); + cuopt::math_optimization::detail::pdlp_solver_t solver(problem, solver_settings); raft::copy(solver.pdhg_solver_.get_primal_solution().data(), d_initial_primal.data(), @@ -925,12 +925,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::math_optimization::method_t::PDLP; + solver_settings.pdlp_solver_mode = cuopt::math_optimization::pdlp_solver_mode_t::Stable2; + cuopt::math_optimization::io::mps_data_model_t op_problem1 = + cuopt::math_optimization::io::read_mps(path); + cuopt::math_optimization::io::mps_data_model_t op_problem2 = + cuopt::math_optimization::io::read_mps(path); optimization_problem_solution_t solution1 = solve_lp(&handle1, op_problem1, solver_settings); @@ -954,13 +954,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::math_optimization::pdlp_solver_mode_t::Stable1; + solver_settings.method = cuopt::math_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::math_optimization::io::mps_data_model_t op_problem1 = + cuopt::math_optimization::io::read_mps(path); + cuopt::math_optimization::io::mps_data_model_t op_problem2 = + cuopt::math_optimization::io::read_mps(path); optimization_problem_solution_t solution1 = solve_lp(&handle1, op_problem1, solver_settings); @@ -985,12 +985,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::math_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::math_optimization::io::mps_data_model_t op_problem1 = + cuopt::math_optimization::io::read_mps(path); + cuopt::math_optimization::io::mps_data_model_t op_problem2 = + cuopt::math_optimization::io::read_mps(path); optimization_problem_solution_t solution1 = solve_lp(&handle1, op_problem1, solver_settings); @@ -1015,10 +1015,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::math_optimization::method_t::PDLP; - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path); + cuopt::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_optimization::io::read_mps(path); auto sol = solve_lp(&handle, op_problem, solver_settings); RAFT_CUDA_TRY(cudaDeviceSynchronize()); @@ -1039,10 +1039,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::math_optimization::method_t::PDLP; - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path); + cuopt::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_optimization::io::read_mps(path); constexpr int batch_size = 2; @@ -1086,10 +1086,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::math_optimization::method_t::PDLP; - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path); + cuopt::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_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 +1134,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::math_optimization::io::read_mps(path); + auto climber1_problem = cuopt::math_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 +1168,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::math_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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_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 +1200,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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_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::math_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 +1247,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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_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::math_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 +1311,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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_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::math_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 +1383,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::math_optimization::method_t::PDLP; - cuopt::linear_programming::io::mps_data_model_t op_problem = - cuopt::linear_programming::io::read_mps(path); + cuopt::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_optimization::io::read_mps(path); auto sol = solve_lp(&handle, op_problem, solver_settings); RAFT_CUDA_TRY(cudaDeviceSynchronize()); @@ -1408,11 +1408,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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_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::math_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 +1455,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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_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::math_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 +1522,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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_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::math_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 +1589,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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_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::math_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 +1620,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 +1700,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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_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::math_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 +1731,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 +1810,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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_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::math_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 +1827,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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_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::math_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; @@ -1859,17 +1859,17 @@ 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; + solver_settings.pdlp_solver_mode = cuopt::math_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::math_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::math_optimization::io::mps_data_model_t mps_data_model = + cuopt::math_optimization::io::read_mps(path); auto op_problem1 = - cuopt::linear_programming::mps_data_model_to_optimization_problem( - &handle, mps_data_model); + cuopt::math_optimization::mps_data_model_to_optimization_problem(&handle, + mps_data_model); // Solving from scratch until 1e-2 optimization_problem_solution_t solution1 = solve_lp(op_problem1, solver_settings); @@ -1877,15 +1877,15 @@ 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( - &handle, mps_data_model); + cuopt::math_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( - &handle, mps_data_model); + cuopt::math_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,15 +1901,15 @@ 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::math_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::math_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( + cuopt::math_optimization::io::mps_data_model_t mps_data_model = + cuopt::math_optimization::io::read_mps(path); + auto op_problem = cuopt::math_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); @@ -1923,11 +1923,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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_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::math_optimization::method_t::PDLP; solver_settings.presolver = presolver_t::Papilo; { @@ -1949,16 +1949,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::math_optimization::pdlp_solver_settings_t settings = + cuopt::math_optimization::pdlp_solver_settings_t{}; + settings.method = cuopt::math_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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_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 +1972,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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_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::math_optimization::method_t::PDLP; solver_settings.presolver = presolver_t::None; optimization_problem_solution_t solution = @@ -1990,11 +1990,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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_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::math_optimization::method_t::Concurrent; solver_settings.presolver = presolver_t::None; optimization_problem_solution_t solution = @@ -2008,12 +2008,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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_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::math_optimization::method_t::PDLP; + solver_settings.pdlp_solver_mode = cuopt::math_optimization::pdlp_solver_mode_t::Stable2; solver_settings.presolver = presolver_t::None; optimization_problem_solution_t solution = @@ -2028,11 +2028,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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_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::math_optimization::method_t::PDLP; solver_settings.presolver = presolver_t::None; optimization_problem_solution_t solution = @@ -2047,8 +2047,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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_optimization::io::read_mps(path); auto solver_settings = pdlp_solver_settings_t{}; solver_settings.presolver = presolver_t::None; @@ -2074,11 +2074,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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_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::math_optimization::method_t::PDLP; solver_settings.presolver = presolver_t::None; constexpr int batch_size = 5; @@ -2156,11 +2156,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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_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::math_optimization::method_t::PDLP; solver_settings.presolver = presolver_t::None; const std::vector& variable_lower_bounds = op_problem.get_variable_lower_bounds(); @@ -2212,11 +2212,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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_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::math_optimization::method_t::PDLP; solver_settings.presolver = presolver_t::None; constexpr int batch_size = 5; @@ -2305,11 +2305,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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_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::math_optimization::method_t::PDLP; solver_settings.presolver = presolver_t::None; const int n_vars = op_problem.get_n_variables(); @@ -2373,11 +2373,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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_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::math_optimization::method_t::PDLP; solver_settings.presolver = presolver_t::None; // Solve sequentially with different offsets @@ -2413,11 +2413,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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_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::math_optimization::method_t::PDLP; solver_settings.presolver = presolver_t::None; const int n_vars = op_problem.get_n_variables(); @@ -2471,11 +2471,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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_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::math_optimization::method_t::PDLP; solver_settings.presolver = presolver_t::None; const int n_constrs = op_problem.get_n_constraints(); @@ -2539,11 +2539,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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_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::math_optimization::method_t::PDLP; solver_settings.presolver = presolver_t::None; const int n_vars = op_problem.get_n_variables(); @@ -2600,7 +2600,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 +2659,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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_optimization::io::read_mps(path, true); constexpr int batch_size = 3; const auto n_vars = static_cast(op_problem.get_n_variables()); @@ -2669,7 +2669,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::math_optimization::method_t::PDLP; s.presolver = presolver_t::None; s.fixed_batch_size = batch_size; s.generate_batch_primal_dual_solution = true; @@ -2687,53 +2687,53 @@ 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( + auto gpu_op = cuopt::math_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::math_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( + auto gpu_op = cuopt::math_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::math_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( + auto gpu_op = cuopt::math_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::math_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( + auto gpu_op = cuopt::math_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::math_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( + auto gpu_op = cuopt::math_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::math_optimization::run_batch_pdlp(gpu_op, settings); }); } } @@ -2741,14 +2741,14 @@ 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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_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( + auto gpu_op = cuopt::math_optimization::mps_data_model_to_optimization_problem( &handle_, op_problem); try { - cuopt::linear_programming::run_batch_pdlp(gpu_op, settings); + cuopt::math_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 +2757,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::math_optimization::method_t::PDLP; settings.presolver = presolver_t::None; settings.generate_batch_primal_dual_solution = true; return settings; @@ -2849,16 +2849,16 @@ 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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_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( + auto gpu_op = cuopt::math_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::math_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 +2872,23 @@ 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::math_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( + auto gpu_op = cuopt::math_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::math_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::math_optimization::run_batch_pdlp(gpu_op, settings); EXPECT_EQ(sol.get_error_status().get_error_type(), cuopt::error_type_t::ValidationError); } } @@ -2898,12 +2898,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::math_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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_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 +2925,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::math_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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_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 +2967,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::math_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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_optimization::io::read_mps(path, true); // Use a ref problem that is infeasible auto op_problem_ref = op_problem; @@ -3015,11 +3015,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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_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::math_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 +3060,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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_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::math_optimization::method_t::PDLP; solver_settings.presolver = presolver_t::None; constexpr int batch_size = 1000; @@ -3148,11 +3148,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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_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::math_optimization::method_t::PDLP; solver_settings.detect_infeasibility = true; solver_settings.presolver = presolver_t::None; @@ -3180,11 +3180,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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_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::math_optimization::method_t::PDLP; solver_settings.detect_infeasibility = true; const std::vector& variable_lower_bounds = op_problem.get_variable_lower_bounds(); @@ -3226,16 +3226,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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_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.pdlp_solver_mode = pdlp_solver_mode_t::Stable3; - solver_settings.presolver = cuopt::linear_programming::presolver_t::None; + auto solver_settings = pdlp_solver_settings_t{}; + solver_settings.method = cuopt::math_optimization::method_t::PDLP; + solver_settings.pdlp_solver_mode = pdlp_solver_mode_t::Stable3; + solver_settings.presolver = cuopt::math_optimization::presolver_t::None; solver_settings.generate_batch_primal_dual_solution = true; const int n_fractional = fractional.size(); @@ -3243,7 +3243,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 +3333,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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_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.pdlp_solver_mode = pdlp_solver_mode_t::Stable3; - solver_settings.presolver = cuopt::linear_programming::presolver_t::None; + auto solver_settings = pdlp_solver_settings_t{}; + solver_settings.method = cuopt::math_optimization::method_t::PDLP; + solver_settings.pdlp_solver_mode = pdlp_solver_mode_t::Stable3; + solver_settings.presolver = cuopt::math_optimization::presolver_t::None; solver_settings.generate_batch_primal_dual_solution = true; const int n_fractional = fractional.size(); @@ -3350,7 +3350,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 +3391,9 @@ 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( + auto gpu_op = cuopt::math_optimization::mps_data_model_to_optimization_problem( &handle_, op_problem); - auto batch_sol = cuopt::linear_programming::run_batch_pdlp(gpu_op, solver_settings); + auto batch_sol = cuopt::math_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 +3421,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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_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_solver_mode = pdlp_solver_mode_t::Stable3; - solver_settings.presolver = cuopt::linear_programming::presolver_t::None; + auto solver_settings = pdlp_solver_settings_t{}; + solver_settings.method = cuopt::math_optimization::method_t::PDLP; + solver_settings.pdlp_solver_mode = pdlp_solver_mode_t::Stable3; + solver_settings.presolver = cuopt::math_optimization::presolver_t::None; solver_settings.generate_batch_primal_dual_solution = true; auto root_solution = solve_lp(&handle_, op_problem, solver_settings); @@ -3454,7 +3454,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 +3500,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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_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::math_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 +3553,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 +3614,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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_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 +3641,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::math_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 +3712,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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_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 +3731,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::math_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 +3766,9 @@ 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( + auto gpu_op = cuopt::math_optimization::mps_data_model_to_optimization_problem( &handle_, op_problem); - auto batch_solution = cuopt::linear_programming::run_batch_pdlp(gpu_op, batch_settings); + auto batch_solution = cuopt::math_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 +3804,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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_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 +3828,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::math_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 +3849,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::math_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 +3897,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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_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 +3910,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::math_optimization::method_t::PDLP; solver_settings.iteration_limit = 500; solver_settings.presolver = presolver_t::None; auto ref_prob = op_problem; @@ -3932,7 +3932,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::math_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 +3979,12 @@ 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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_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.method = cuopt::math_optimization::method_t::PDLP; + solver_settings.pdlp_precision = cuopt::math_optimization::pdlp_precision_t::SinglePrecision; optimization_problem_solution_t solution = solve_lp(&handle_, op_problem, solver_settings); @@ -3999,12 +3999,12 @@ 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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_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.method = cuopt::math_optimization::method_t::PDLP; + solver_settings.pdlp_precision = cuopt::math_optimization::pdlp_precision_t::SinglePrecision; solver_settings.crossover = true; optimization_problem_solution_t solution = @@ -4020,12 +4020,12 @@ 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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_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; + solver_settings.method = cuopt::math_optimization::method_t::Concurrent; + solver_settings.pdlp_precision = cuopt::math_optimization::pdlp_precision_t::SinglePrecision; optimization_problem_solution_t solution = solve_lp(&handle_, op_problem, solver_settings); @@ -4040,13 +4040,13 @@ 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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_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; + solver_settings.method = cuopt::math_optimization::method_t::PDLP; + solver_settings.pdlp_precision = cuopt::math_optimization::pdlp_precision_t::SinglePrecision; + solver_settings.presolver = cuopt::math_optimization::presolver_t::Papilo; optimization_problem_solution_t solution = solve_lp(&handle_, op_problem, solver_settings); @@ -4060,13 +4060,13 @@ 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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_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; + solver_settings.method = cuopt::math_optimization::method_t::PDLP; + solver_settings.pdlp_precision = cuopt::math_optimization::pdlp_precision_t::SinglePrecision; + solver_settings.presolver = cuopt::math_optimization::presolver_t::PSLP; optimization_problem_solution_t solution = solve_lp(&handle_, op_problem, solver_settings); @@ -4081,7 +4081,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::math_optimization::dual_simplex; constexpr int N = 10; shared_strong_branching_context_t ctx(N); @@ -4128,12 +4128,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::math_optimization::dual_simplex; 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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_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 +4141,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::math_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::math_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 +4188,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::math_optimization::dual_simplex; 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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_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 +4201,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::math_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::math_optimization::presolver_t::None; solver_settings.iteration_limit = 1000000; for (int i = 0; i < n_fractional; ++i) @@ -4246,7 +4246,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::math_optimization::optimization_problem_solution_t:: get_termination_status_string(status); } @@ -4260,12 +4260,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::math_optimization::dual_simplex; 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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_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 +4273,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::math_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::math_optimization::presolver_t::None; solver_settings.iteration_limit = 1000000; for (int i = 0; i < n_fractional; ++i) @@ -4311,7 +4311,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::math_optimization::optimization_problem_solution_t:: get_termination_status_string(status); } @@ -4331,11 +4331,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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_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::math_optimization::method_t::PDLP; solver_settings.presolver = presolver_t::None; const int n_vars = op_problem.get_n_variables(); @@ -4349,10 +4349,10 @@ 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( + auto gpu_op = cuopt::math_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::math_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 +4384,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::math_optimization::run_batch_pdlp(gpu_op, solver_settings); // All should be optimal for (size_t i = 0; i < batch_size; ++i) { @@ -4449,8 +4449,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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_optimization::io::read_mps(path, true); constexpr int batch_size = 3; const int n_vars = op_problem.get_n_variables(); @@ -4462,7 +4462,7 @@ 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( + auto gpu_op = cuopt::math_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); @@ -4474,8 +4474,8 @@ TEST(pdlp_class, batch_bound_objective_rescaling_factors_match_input_expansion) 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::math_optimization::detail::problem_t problem(gpu_op); + cuopt::math_optimization::detail::pdlp_initial_scaling_strategy_t scaling( &handle_, problem, hyper_params.default_l_inf_ruiz_iterations, @@ -4593,11 +4593,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::math_optimization::io::mps_data_model_t op_problem = + cuopt::math_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::math_optimization::method_t::PDLP; solver_settings.presolver = presolver_t::None; const int n_vars = op_problem.get_n_variables(); @@ -4610,10 +4610,10 @@ 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( + auto gpu_op = cuopt::math_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::math_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 +4662,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 +4691,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::math_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 +4709,6 @@ TEST(pdlp_class, batch_with_optimal_size_query) } } -} // namespace cuopt::linear_programming::test +} // namespace cuopt::math_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..a6321f3445 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::math_optimization { -cuopt::linear_programming::io::mps_data_model_t read_from_mps( +cuopt::math_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::math_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::math_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..b1a96655eb 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::math_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::math_optimization::io::read_mps(path, true); // Store original problem data for later verification const auto& orig_coefficients = mps_data_model.get_constraint_matrix_values(); @@ -125,7 +125,7 @@ TEST(pslp_presolve, postsolve_accuracy_afiro) // Solve with PSLP presolve enabled auto solver_settings = pdlp_solver_settings_t{}; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; + solver_settings.method = cuopt::math_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::math_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::math_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::math_optimization::io::read_mps(path, false); // Store original problem dimensions const auto& orig_coefficients = mps_data_model.get_constraint_matrix_values(); @@ -219,7 +219,7 @@ TEST(pslp_presolve, postsolve_accuracy_larger_problem) // Solve with PSLP presolve auto solver_settings = pdlp_solver_settings_t{}; - solver_settings.method = cuopt::linear_programming::method_t::PDLP; + solver_settings.method = cuopt::math_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; @@ -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::math_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::math_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; @@ -272,7 +272,7 @@ TEST(pslp_presolve, compare_with_no_presolve) // Solve with PSLP presolve auto settings_pslp = pdlp_solver_settings_t{}; - settings_pslp.method = cuopt::linear_programming::method_t::PDLP; + settings_pslp.method = cuopt::math_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; @@ -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::math_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::math_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::math_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::math_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::math_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..57e1741cb7 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::math_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::math_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::math_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..4f75f53302 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::math_optimization { TEST(SolverSettingsTest, TestSetGet) { - cuopt::linear_programming::pdlp_solver_settings_t solver_settings = - cuopt::linear_programming::pdlp_solver_settings_t{}; + cuopt::math_optimization::pdlp_solver_settings_t solver_settings = + cuopt::math_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::math_optimization::pdlp_solver_mode_t::Stable3; + auto Fast1 = cuopt::math_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::math_optimization::pdlp_solver_settings_t solver_settings = + cuopt::math_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::math_optimization::pdlp_solver_settings_t solver_settings = + cuopt::math_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::math_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..ba1efe2c72 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::math_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::math_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::math_optimization::io::mps_data_model_t& mps_data_model, + const cuopt::math_optimization::pdlp_solver_settings_t& settings) { - auto gpu_op = cuopt::linear_programming::mps_data_model_to_optimization_problem( + auto gpu_op = cuopt::math_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::math_optimization::run_batch_pdlp(gpu_op, batch_settings); } // Overwrites the device_uvector with the host-side contents, resizing as needed. @@ -70,10 +70,10 @@ 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::math_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::math_optimization::io::mps_data_model_t& mps_data_model, + cuopt::math_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 +81,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::math_optimization::mps_data_model_to_optimization_problem( handle_ptr, mps_data_model); auto stream = handle_ptr->get_stream(); @@ -106,13 +106,13 @@ 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::math_optimization::solve_lp(gpu_op, settings, false); } + return cuopt::math_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::math_optimization::io::mps_data_model_t& op_problem, const rmm::device_uvector& primal_solution, double objective_value, double epsilon = tolerance) @@ -137,7 +137,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::math_optimization::io::mps_data_model_t& op_problem, const std::vector& primal_solution, double objective_value, double epsilon = tolerance) @@ -164,7 +164,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::math_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 +191,7 @@ static void test_constraint_sanity( } } - auto functor = cuopt::linear_programming::detail::violation{}; + auto functor = cuopt::math_optimization::detail::violation{}; // Compute violation to lower/upper bound @@ -217,7 +217,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::math_optimization::detail::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 +247,4 @@ static void test_constraint_sanity( } } -} // namespace cuopt::linear_programming::test +} // namespace cuopt::math_optimization::test diff --git a/cpp/tests/mip/bounds_standardization_test.cu b/cpp/tests/mip/bounds_standardization_test.cu index 059b038f0c..684f2f62ea 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::math_optimization::test { void init_handler(const raft::handle_t* handle_ptr) { @@ -45,8 +45,8 @@ 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::math_optimization::io::mps_data_model_t problem = + cuopt::math_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); @@ -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::math_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::math_optimization::test diff --git a/cpp/tests/mip/cuts_test.cu b/cpp/tests/mip/cuts_test.cu index 1fb0c65a1d..bc2aa398e7 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::math_optimization::test { namespace { @@ -169,7 +169,7 @@ 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::math_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"); @@ -1508,4 +1508,4 @@ TEST(cuts, flow_cover_generates_valid_single_node_flow_cut) EXPECT_GT(generated_cuts, 0); } -} // namespace cuopt::linear_programming::test +} // namespace cuopt::math_optimization::test diff --git a/cpp/tests/mip/determinism_test.cu b/cpp/tests/mip/determinism_test.cu index 0accf2ba67..1dadc9bee1 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::math_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::math_optimization::test diff --git a/cpp/tests/mip/doc_example_test.cu b/cpp/tests/mip/doc_example_test.cu index 04c383b455..d82e48b066 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::math_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::math_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::math_optimization::io::mps_data_model_t problem2 = + cuopt::math_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::math_optimization::test diff --git a/cpp/tests/mip/elim_var_remap_test.cu b/cpp/tests/mip/elim_var_remap_test.cu index 776ebbd310..64019f2359 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::math_optimization::test { void init_handler(const raft::handle_t* handle_ptr) { @@ -60,8 +60,8 @@ 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::math_optimization::io::mps_data_model_t mps_problem = + cuopt::math_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); @@ -128,8 +128,8 @@ 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::math_optimization::io::mps_data_model_t mps_problem = + cuopt::math_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); @@ -212,4 +212,4 @@ TEST(mip_solve, elim_var_remap_solution_test) } } -} // namespace cuopt::linear_programming::test +} // namespace cuopt::math_optimization::test diff --git a/cpp/tests/mip/empty_fixed_problems_test.cu b/cpp/tests/mip/empty_fixed_problems_test.cu index 53acd82b06..3ed12e9b6a 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::math_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::math_optimization::test diff --git a/cpp/tests/mip/feasibility_jump_tests.cu b/cpp/tests/mip/feasibility_jump_tests.cu index 7820f1f6a0..9233106d6a 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::math_optimization::test { void init_handler(const raft::handle_t* handle_ptr) { @@ -68,8 +68,8 @@ 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::math_optimization::io::mps_data_model_t mps_problem = + cuopt::math_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); @@ -259,4 +259,4 @@ TEST(mip_solve, feasibility_jump_obj_runoff_test) } } -} // namespace cuopt::linear_programming::test +} // namespace cuopt::math_optimization::test diff --git a/cpp/tests/mip/heuristics_hyper_params_test.cu b/cpp/tests/mip/heuristics_hyper_params_test.cu index 24b15f8cc8..5a8149d125 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::math_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::math_optimization::test diff --git a/cpp/tests/mip/incumbent_callback_test.cu b/cpp/tests/mip/incumbent_callback_test.cu index 2dce940f73..282ac8788d 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::math_optimization::test { class test_set_solution_callback_t : public cuopt::internals::set_solution_callback_t { public: @@ -90,8 +90,8 @@ class test_get_solution_callback_t : public cuopt::internals::get_solution_callb }; 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) + const cuopt::math_optimization::io::mps_data_model_t& op_problem, + const cuopt::math_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 +112,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::math_optimization::io::mps_data_model_t mps_problem = + cuopt::math_optimization::io::read_mps(path, false); handle_.sync_stream(); auto op_problem = mps_data_model_to_optimization_problem(&handle_, mps_problem); @@ -164,8 +164,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::math_optimization::io::mps_data_model_t mps_problem = + cuopt::math_optimization::io::read_mps(path, false); handle_.sync_stream(); auto op_problem = mps_data_model_to_optimization_problem(&handle_, mps_problem); @@ -194,4 +194,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::math_optimization::test diff --git a/cpp/tests/mip/integer_with_real_bounds.cu b/cpp/tests/mip/integer_with_real_bounds.cu index 2e526f7801..bef7702584 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::math_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::math_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::math_optimization::test diff --git a/cpp/tests/mip/load_balancing_test.cu b/cpp/tests/mip/load_balancing_test.cu index afdc275e15..4aae391570 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::math_optimization::test { inline auto make_async() { return rmm::mr::cuda_async_memory_resource(); } @@ -121,8 +121,8 @@ 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::math_optimization::io::mps_data_model_t mps_problem = + cuopt::math_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); @@ -168,4 +168,4 @@ TEST(presolve, multi_probe) } } -} // namespace cuopt::linear_programming::test +} // namespace cuopt::math_optimization::test diff --git a/cpp/tests/mip/mip_utils.cuh b/cpp/tests/mip/mip_utils.cuh index 057047cefd..1ee9803ae9 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::math_optimization::test { static void test_variable_bounds( - const cuopt::linear_programming::io::mps_data_model_t& problem, + const cuopt::math_optimization::io::mps_data_model_t& problem, const rmm::device_uvector& solution, - const cuopt::linear_programming::mip_solver_settings_t settings) + const cuopt::math_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::math_optimization::io::mps_data_model_t& problem, const std::vector& solution, - const cuopt::linear_programming::mip_solver_settings_t settings) + const cuopt::math_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::math_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::math_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::math_optimization::io::mps_data_model_t problem = + cuopt::math_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::math_optimization::test diff --git a/cpp/tests/mip/miplib_test.cu b/cpp/tests/mip/miplib_test.cu index 0e255d35a9..510076004f 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/math_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::math_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::math_optimization::io::mps_data_model_t problem = + cuopt::math_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::math_optimization::io::mps_data_model_t problem = + cuopt::math_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::math_optimization::io::mps_data_model_t problem = + cuopt::math_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::math_optimization::test diff --git a/cpp/tests/mip/multi_probe_test.cu b/cpp/tests/mip/multi_probe_test.cu index b6ffb1e592..1094c62186 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::math_optimization::test { inline auto make_async() { return rmm::mr::cuda_async_memory_resource(); } @@ -143,8 +143,8 @@ 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::math_optimization::io::mps_data_model_t mps_problem = + cuopt::math_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); @@ -200,4 +200,4 @@ TEST(presolve, multi_probe) } } -} // namespace cuopt::linear_programming::test +} // namespace cuopt::math_optimization::test diff --git a/cpp/tests/mip/presolve_test.cu b/cpp/tests/mip/presolve_test.cu index a400d04854..12ecec3736 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,19 +27,19 @@ #include #include -namespace cuopt::linear_programming::test { +namespace cuopt::math_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::math_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 result = presolver->apply(op_problem, - cuopt::linear_programming::problem_category_t::MIP, - cuopt::linear_programming::presolver_t::Papilo, + cuopt::math_optimization::problem_category_t::MIP, + cuopt::math_optimization::presolver_t::Papilo, false, 1e-6, 1e-12, @@ -63,4 +63,4 @@ TEST(problem, find_implied_integers) ((int)detail::problem_t::var_flags_t::VAR_IMPLIED_INTEGER)); } -} // namespace cuopt::linear_programming::test +} // namespace cuopt::math_optimization::test diff --git a/cpp/tests/mip/problem_test.cu b/cpp/tests/mip/problem_test.cu index ef488eadba..2970d7f6b7 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::math_optimization::test { -namespace lp = cuopt::linear_programming; -namespace dtl = cuopt::linear_programming::detail; +namespace lp = cuopt::math_optimization; +namespace dtl = cuopt::math_optimization::detail; template thrust::host_vector rand_vec(i_t size, T dist_beg, T dist_end) @@ -205,7 +205,7 @@ TEST(problem, run_small_tests) } } -namespace ds = cuopt::linear_programming::dual_simplex; +namespace ds = cuopt::math_optimization::dual_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::math_optimization::detail::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::math_optimization::detail::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::math_optimization::detail::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::math_optimization::detail::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::math_optimization::test diff --git a/cpp/tests/mip/semi_continuous_test.cu b/cpp/tests/mip/semi_continuous_test.cu index ee88eafcbb..a7e6650730 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/math_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::math_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::math_optimization::test diff --git a/cpp/tests/mip/server_test.cu b/cpp/tests/mip/server_test.cu index 83cac7e11e..898d42a4fc 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::math_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::math_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::math_optimization::solve_lp(&handle, problem, settings); EXPECT_EQ(result.get_termination_status(), - cuopt::linear_programming::pdlp_termination_status_t::Optimal); + cuopt::math_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::math_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::math_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::math_optimization::mip_termination_status_t::FeasibleFound), std::make_tuple(false, CUOPT_MIP_SCALING_ON, false, - cuopt::linear_programming::mip_termination_status_t::Optimal), + cuopt::math_optimization::mip_termination_status_t::Optimal), std::make_tuple(true, CUOPT_MIP_SCALING_OFF, true, - cuopt::linear_programming::mip_termination_status_t::FeasibleFound), + cuopt::math_optimization::mip_termination_status_t::FeasibleFound), std::make_tuple(false, CUOPT_MIP_SCALING_OFF, false, - cuopt::linear_programming::mip_termination_status_t::Optimal))); + cuopt::math_optimization::mip_termination_status_t::Optimal))); -} // namespace cuopt::linear_programming::test +} // namespace cuopt::math_optimization::test diff --git a/cpp/tests/mip/termination_test.cu b/cpp/tests/mip/termination_test.cu index 4874ccfd5d..d7d18cae43 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::math_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::math_optimization::test diff --git a/cpp/tests/mip/unit_test.cu b/cpp/tests/mip/unit_test.cu index 9eae3455bb..b180a9cd76 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::math_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::math_optimization::pdlp_solver_settings_t settings{}; settings.set_optimality_tolerance(1e-2); - settings.method = cuopt::linear_programming::method_t::PDLP; + settings.method = cuopt::math_optimization::method_t::PDLP; settings.time_limit = 5; // Solve - auto result = cuopt::linear_programming::solve_lp(&handle, problem, settings); + auto result = cuopt::math_optimization::solve_lp(&handle, problem, settings); // Check results EXPECT_EQ(result.get_termination_status(), - cuopt::linear_programming::pdlp_termination_status_t::Optimal); + cuopt::math_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::math_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::math_optimization::presolver_t::None; - auto result = cuopt::linear_programming::solve_lp(&handle, problem, settings); + auto result = cuopt::math_optimization::solve_lp(&handle, problem, settings); EXPECT_EQ(result.get_termination_status(), - cuopt::linear_programming::pdlp_termination_status_t::Optimal); + cuopt::math_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::math_optimization::mip_solver_settings_t settings{}; settings.time_limit = 5; - settings.presolver = cuopt::linear_programming::presolver_t::None; + settings.presolver = cuopt::math_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::math_optimization::solve_mip(&handle, problem, settings); EXPECT_EQ(result.get_termination_status(), - cuopt::linear_programming::mip_termination_status_t::NoTermination); + cuopt::math_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::math_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::math_optimization::presolver_t::None; - auto result = cuopt::linear_programming::solve_mip(&handle, problem, settings); + auto result = cuopt::math_optimization::solve_mip(&handle, problem, settings); EXPECT_EQ(result.get_termination_status(), expected_termination_status); } @@ -175,16 +175,16 @@ 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::math_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::math_optimization::presolver_t::None; - auto result = cuopt::linear_programming::solve_mip(&handle, problem, settings); + auto result = cuopt::math_optimization::solve_mip(&handle, problem, settings); EXPECT_EQ(result.get_termination_status(), - cuopt::linear_programming::mip_termination_status_t::Optimal); + cuopt::math_optimization::mip_termination_status_t::Optimal); } INSTANTIATE_TEST_SUITE_P( @@ -193,19 +193,19 @@ INSTANTIATE_TEST_SUITE_P( testing::Values(std::make_tuple(true, CUOPT_MIP_SCALING_ON, true, - cuopt::linear_programming::mip_termination_status_t::Optimal), + cuopt::math_optimization::mip_termination_status_t::Optimal), std::make_tuple(false, CUOPT_MIP_SCALING_ON, false, - cuopt::linear_programming::mip_termination_status_t::Optimal), + cuopt::math_optimization::mip_termination_status_t::Optimal), std::make_tuple(true, CUOPT_MIP_SCALING_OFF, true, - cuopt::linear_programming::mip_termination_status_t::Optimal), + cuopt::math_optimization::mip_termination_status_t::Optimal), std::make_tuple(false, CUOPT_MIP_SCALING_OFF, false, - cuopt::linear_programming::mip_termination_status_t::Optimal))); + cuopt::math_optimization::mip_termination_status_t::Optimal))); // --------------------------------------------------------------------------- // Scaling integrality preservation test @@ -337,4 +337,4 @@ TEST(ScalingIntegrity, NoObjectiveScalingPreservesIntegerCoefficients) << " integer coefficients lost integrality after scaling (no-obj mode)"; } -} // namespace cuopt::linear_programming::test +} // namespace cuopt::math_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..b21cb37761 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::math_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::math_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..31618a8394 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,8 @@ 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::math_optimization::var_t const var_types_host[] = { + cuopt::math_optimization::var_t::CONTINUOUS, cuopt::math_optimization::var_t::CONTINUOUS}; op.set_variable_types(var_types_host, 2); double c_host[] = {0.0, 0.0}; @@ -160,10 +160,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::math_optimization::var_t const var_types_host[] = { + cuopt::math_optimization::var_t::CONTINUOUS, + cuopt::math_optimization::var_t::CONTINUOUS, + cuopt::math_optimization::var_t::CONTINUOUS}; op.set_variable_types(var_types_host, 3); double c_host[] = {0.0, 0.0, 0.0}; @@ -172,7 +172,7 @@ void setup_three_var_unconstrained_qp(Op& op) } // namespace -namespace cuopt::linear_programming { +namespace cuopt::math_optimization { TEST(mps_writer_op, write_to_mps_diagonal_qp_quadobj_matches_symmetrized_hessian) { @@ -257,4 +257,4 @@ TEST(mps_writer_op, write_to_mps_nonsymmetric_Q_quadobj_matches_Q_plus_Q_transpo } } -} // namespace cuopt::linear_programming +} // namespace cuopt::math_optimization diff --git a/cpp/tests/qp/unit_tests/no_constraints.cu b/cpp/tests/qp/unit_tests/no_constraints.cu index b2c494e963..1dec3aa956 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::math_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::math_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..8d6b4de9da 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::math_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::math_optimization diff --git a/cpp/tests/socp/general_quadratic_test.cu b/cpp/tests/socp/general_quadratic_test.cu index 2918d80a7d..caf8479f4c 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,7 @@ #include #include -namespace cuopt::linear_programming::detail::test { +namespace cuopt::math_optimization::detail::test { using i_t = int; using f_t = double; @@ -46,7 +46,7 @@ TEST(general_quadratic, dense_pd_2x2_solve) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::linear_programming::dual_simplex; + using namespace cuopt::math_optimization::dual_simplex; user_problem_t user_problem(&handle); // Need at least one linear constraint for the barrier solver. @@ -159,7 +159,7 @@ TEST(general_quadratic, rejects_non_convex) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::linear_programming::dual_simplex; + using namespace cuopt::math_optimization::dual_simplex; user_problem_t user_problem(&handle); constexpr int m = 0; @@ -217,7 +217,7 @@ TEST(general_quadratic, rank_deficient_psd_solve) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::linear_programming::dual_simplex; + using namespace cuopt::math_optimization::dual_simplex; user_problem_t user_problem(&handle); constexpr int m = 1; @@ -302,7 +302,7 @@ TEST(general_quadratic, with_inequality_constraint) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::linear_programming::dual_simplex; + using namespace cuopt::math_optimization::dual_simplex; user_problem_t user_problem(&handle); // 2 constraints: one equality, one inequality @@ -400,7 +400,7 @@ TEST(general_quadratic, least_squares_b_in_range) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::linear_programming::dual_simplex; + using namespace cuopt::math_optimization::dual_simplex; user_problem_t user_problem(&handle); // Variables: x0, x1, u (u = t - b^T*b = t - 5). @@ -519,7 +519,7 @@ TEST(general_quadratic, least_squares_b_not_in_range) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::linear_programming::dual_simplex; + using namespace cuopt::math_optimization::dual_simplex; user_problem_t user_problem(&handle); constexpr int m = 1; @@ -592,7 +592,7 @@ TEST(general_quadratic, soc_head_nonneg_accepted) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::linear_programming::dual_simplex; + using namespace cuopt::math_optimization::dual_simplex; user_problem_t user_problem(&handle); // Variables: x0, x1, t. Constraint: x0^2 + x1^2 - t^2 <= 0 @@ -659,7 +659,7 @@ TEST(general_quadratic, soc_head_free_rejected) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::linear_programming::dual_simplex; + using namespace cuopt::math_optimization::dual_simplex; user_problem_t user_problem(&handle); constexpr int m = 1; @@ -715,7 +715,7 @@ TEST(general_quadratic, rotated_soc_heads_nonneg_accepted) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::linear_programming::dual_simplex; + using namespace cuopt::math_optimization::dual_simplex; user_problem_t user_problem(&handle); // Variables: x0, x1, y, z. Constraint: x0^2 + x1^2 - 2*y*z <= 0 @@ -774,7 +774,7 @@ TEST(general_quadratic, rotated_soc_heads_free_rejected) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::linear_programming::dual_simplex; + using namespace cuopt::math_optimization::dual_simplex; user_problem_t user_problem(&handle); constexpr int m = 1; @@ -824,4 +824,4 @@ TEST(general_quadratic, rotated_soc_heads_free_rejected) cuopt::logic_error); } -} // namespace cuopt::linear_programming::detail::test +} // namespace cuopt::math_optimization::detail::test diff --git a/cpp/tests/socp/second_order_cone_kernels.cu b/cpp/tests/socp/second_order_cone_kernels.cu index 49126ee335..709e785b4e 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::math_optimization::dual_simplex::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::math_optimization::dual_simplex::test diff --git a/cpp/tests/socp/solve_barrier_socp.cu b/cpp/tests/socp/solve_barrier_socp.cu index f960c3dc3a..f2f7cc88bb 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::math_optimization::dual_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,7 @@ 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; + using namespace cuopt::math_optimization::dual_simplex; user_problem_t user_problem(&handle); constexpr int m = 1; @@ -98,7 +98,7 @@ TEST(barrier, presolve_reindexes_cone_start_after_empty_column_removal) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::linear_programming::dual_simplex; + using namespace cuopt::math_optimization::dual_simplex; user_problem_t user_problem(&handle); constexpr int m = 1; @@ -167,7 +167,7 @@ TEST(barrier, presolve_keeps_direct_free_variables_before_cones) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::linear_programming::dual_simplex; + using namespace cuopt::math_optimization::dual_simplex; user_problem_t user_problem(&handle); constexpr int m = 1; @@ -230,7 +230,7 @@ TEST(barrier, rejects_middle_cone_input_before_barrier) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::linear_programming::dual_simplex; + using namespace cuopt::math_optimization::dual_simplex; user_problem_t user_problem(&handle); constexpr int m = 3; @@ -282,7 +282,7 @@ TEST(barrier, socp_min_x0_subject_to_norm_constraint) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::linear_programming::dual_simplex; + using namespace cuopt::math_optimization::dual_simplex; user_problem_t user_problem(&handle); constexpr int m = 1; @@ -343,7 +343,7 @@ TEST(barrier, mixed_linear_and_soc_block) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::linear_programming::dual_simplex; + using namespace cuopt::math_optimization::dual_simplex; user_problem_t user_problem(&handle); constexpr int m = 2; @@ -409,7 +409,7 @@ TEST(barrier, mixed_linear_and_soc_tail_coupling) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::linear_programming::dual_simplex; + using namespace cuopt::math_optimization::dual_simplex; user_problem_t user_problem(&handle); constexpr int m = 2; @@ -476,7 +476,7 @@ TEST(barrier, mixed_linear_and_soc_tail_coupling_with_inequality) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::linear_programming::dual_simplex; + using namespace cuopt::math_optimization::dual_simplex; user_problem_t user_problem(&handle); constexpr int m = 2; @@ -546,7 +546,7 @@ TEST(barrier, mixed_linear_and_two_soc_blocks) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::linear_programming::dual_simplex; + using namespace cuopt::math_optimization::dual_simplex; user_problem_t user_problem(&handle); constexpr int m = 4; @@ -627,7 +627,7 @@ TEST(barrier, mixed_linear_and_two_soc_blocks_with_inequality) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::linear_programming::dual_simplex; + using namespace cuopt::math_optimization::dual_simplex; user_problem_t user_problem(&handle); constexpr int m = 4; @@ -707,7 +707,7 @@ 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; + using namespace cuopt::math_optimization::dual_simplex; user_problem_t user_problem(&handle); constexpr int m = 2; @@ -771,7 +771,7 @@ TEST(barrier, qp_with_soc_block) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::linear_programming::dual_simplex; + using namespace cuopt::math_optimization::dual_simplex; user_problem_t user_problem(&handle); constexpr int m = 1; @@ -824,4 +824,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::math_optimization::dual_simplex::test diff --git a/cpp/tests/utilities/inline_lp_test_utils.hpp b/cpp/tests/utilities/inline_lp_test_utils.hpp index c0149dc11b..e28d3aec0c 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::math_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::math_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..d76d621262 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::math_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::math_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..aa5cd203fc 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/math_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..55bbfefaa1 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..701c824dda 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..529c78278c 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..18ca3a9a6a 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..3e4d5f704d 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..0df0f09813 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..d3c1bc4f82 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..57efa553be 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..522902d7ad 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..9c7a538329 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/math_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..847882936f 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/math_optimization/io/mps_data_model.hpp" namespace "cuopt::math_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/math_optimization/io/data_model_view.hpp" namespace "cuopt::math_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/math_optimization/io/writer.hpp" namespace "cuopt::math_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..02f5b614e7 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/math_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..3d7430e24c 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/math_optimization/io/mps_data_model.hpp" namespace "cuopt::math_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/math_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..10f38d498c 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/math_optimization/optimization_problem.hpp" namespace "cuopt::math_optimization": # noqa + ctypedef enum problem_category_t "cuopt::math_optimization::problem_category_t": # noqa + LP "cuopt::math_optimization::problem_category_t::LP" + MIP "cuopt::math_optimization::problem_category_t::MIP" + IP "cuopt::math_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/math_optimization/mip/solver_solution.hpp" namespace "cuopt::math_optimization": # noqa + ctypedef enum mip_termination_status_t "cuopt::math_optimization::mip_termination_status_t": # noqa + NoTermination "cuopt::math_optimization::mip_termination_status_t::NoTermination" # noqa + Optimal "cuopt::math_optimization::mip_termination_status_t::Optimal" + FeasibleFound "cuopt::math_optimization::mip_termination_status_t::FeasibleFound" # noqa + Infeasible "cuopt::math_optimization::mip_termination_status_t::Infeasible" # noqa + Unbounded "cuopt::math_optimization::mip_termination_status_t::Unbounded" # noqa + TimeLimit "cuopt::math_optimization::mip_termination_status_t::TimeLimit" # noqa + WorkLimit "cuopt::math_optimization::mip_termination_status_t::WorkLimit" # noqa + UnboundedOrInfeasible "cuopt::math_optimization::mip_termination_status_t::UnboundedOrInfeasible" # noqa + + +cdef extern from "cuopt/math_optimization/pdlp/solver_solution.hpp" namespace "cuopt::math_optimization": # noqa + ctypedef enum pdlp_termination_status_t "cuopt::math_optimization::pdlp_termination_status_t": # noqa + NoTermination "cuopt::math_optimization::pdlp_termination_status_t::NoTermination" # noqa + NumericalError "cuopt::math_optimization::pdlp_termination_status_t::NumericalError" # noqa + Optimal "cuopt::math_optimization::pdlp_termination_status_t::Optimal" # noqa + PrimalInfeasible "cuopt::math_optimization::pdlp_termination_status_t::PrimalInfeasible" # noqa + DualInfeasible "cuopt::math_optimization::pdlp_termination_status_t::DualInfeasible" # noqa + IterationLimit "cuopt::math_optimization::pdlp_termination_status_t::IterationLimit" # noqa + TimeLimit "cuopt::math_optimization::pdlp_termination_status_t::TimeLimit" # noqa + ConcurrentLimit "cuopt::math_optimization::pdlp_termination_status_t::ConcurrentLimit" # noqa + PrimalFeasible "cuopt::math_optimization::pdlp_termination_status_t::PrimalFeasible" # noqa + UnboundedOrInfeasible "cuopt::math_optimization::pdlp_termination_status_t::UnboundedOrInfeasible" # noqa + + +cdef extern from "cuopt/math_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/math_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..17ad7ca45f 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/math_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..90780bfb0b 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/math_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/math_optimization/pdlp/solver_settings.hpp" namespace "cuopt::math_optimization": # noqa + ctypedef enum pdlp_solver_mode_t "cuopt::math_optimization::pdlp_solver_mode_t": # noqa + Stable1 "cuopt::math_optimization::pdlp_solver_mode_t::Stable1" # noqa + Stable2 "cuopt::math_optimization::pdlp_solver_mode_t::Stable2" # noqa + Methodical1 "cuopt::math_optimization::pdlp_solver_mode_t::Methodical1" # noqa + Fast1 "cuopt::math_optimization::pdlp_solver_mode_t::Fast1" # noqa + Stable3 "cuopt::math_optimization::pdlp_solver_mode_t::Stable3" # noqa + + ctypedef enum method_t "cuopt::math_optimization::method_t": # noqa + Concurrent "cuopt::math_optimization::method_t::Concurrent" # noqa + PDLP "cuopt::math_optimization::method_t::PDLP" # noqa + DualSimplex "cuopt::math_optimization::method_t::DualSimplex" # noqa + Barrier "cuopt::math_optimization::method_t::Barrier" # noqa + Unset "cuopt::math_optimization::method_t::Unset" # noqa + +cdef extern from "cuopt/math_optimization/solver_settings.hpp" namespace "cuopt::math_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..df2b700926 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/math_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/math_optimization/solver_settings.hpp" namespace "cuopt::math_optimization": + ctypedef enum pdlp_solver_mode_t "cuopt::math_optimization::pdlp_solver_mode_t": + Stable1 "cuopt::math_optimization::pdlp_solver_mode_t::Stable1" + Stable2 "cuopt::math_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..8a2879d3ef 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..c8bc1330c2 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/math_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..525ac95fcd 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..d1e30a677a 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..8b4219057a 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..007ce2089d 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..ea4f689cb5 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..729f5cacd0 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/math_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..0e992aec8e 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/math_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/math_optimization/constants.h` | +| C API Header | `cpp/include/cuopt/math_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` | From dae7dbad5ebe4e3b709ad7a363cc318b27b4d02b Mon Sep 17 00:00:00 2001 From: Miles Lubin Date: Sat, 20 Jun 2026 20:28:24 +0000 Subject: [PATCH 02/17] refactor: move PDLP solver into cuopt::math_optimization::pdlp Out of the overloaded ::detail namespace; folds pdlp_hyper_params in. Co-Authored-By: Claude Opus 4.8 (1M context) Signed-off-by: Miles Lubin --- .../cuopt/benchmark_helper.hpp | 5 +- .../math_optimization/mip/solver_settings.hpp | 2 +- .../pdlp/pdlp_hyper_params.cuh | 4 +- .../pdlp/solver_settings.hpp | 2 +- cpp/src/barrier/barrier.cu | 32 +++++------ cpp/src/barrier/cusparse_view.cu | 25 +++++---- cpp/src/barrier/cusparse_view.hpp | 10 ++-- .../mip_heuristics/diversity/population.cu | 4 +- .../diversity/recombiners/sub_mip.cuh | 2 +- .../presolve/trivial_presolve.cuh | 2 +- cpp/src/mip_heuristics/problem/problem.cu | 12 ++--- .../mip_heuristics/relaxed_lp/relaxed_lp.cu | 2 +- cpp/src/mip_heuristics/solution/solution.cu | 2 +- cpp/src/mip_heuristics/utils.cuh | 2 +- cpp/src/pdlp/cusparse_view.cu | 16 +++--- cpp/src/pdlp/cusparse_view.hpp | 17 +++--- .../initial_scaling.cu | 31 +++++------ .../initial_scaling.cuh | 16 +++--- .../optimal_batch_size_handler.cu | 4 +- .../optimal_batch_size_handler.hpp | 2 +- cpp/src/pdlp/pdhg.cu | 8 +-- cpp/src/pdlp/pdhg.hpp | 12 ++--- cpp/src/pdlp/pdlp.cu | 43 ++++++++------- cpp/src/pdlp/pdlp.cuh | 36 ++++++------- cpp/src/pdlp/pdlp_constants.hpp | 4 +- .../localized_duality_gap_container.cu | 6 +-- .../localized_duality_gap_container.hpp | 8 +-- .../restart_strategy/pdlp_restart_strategy.cu | 20 +++---- .../pdlp_restart_strategy.cuh | 22 ++++---- .../weighted_average_solution.cu | 4 +- .../weighted_average_solution.hpp | 4 +- cpp/src/pdlp/saddle_point.cu | 15 +++--- cpp/src/pdlp/saddle_point.hpp | 6 +-- cpp/src/pdlp/solve.cu | 20 +++---- .../adaptive_step_size_strategy.cu | 6 +-- .../adaptive_step_size_strategy.hpp | 10 ++-- cpp/src/pdlp/swap_and_resize_helper.cuh | 4 +- .../convergence_information.cu | 6 +-- .../convergence_information.hpp | 12 ++--- .../infeasibility_information.cu | 10 ++-- .../infeasibility_information.hpp | 38 ++++++------- .../termination_strategy.cu | 8 +-- .../termination_strategy.hpp | 10 ++-- cpp/src/pdlp/utilities/ping_pong_graph.cu | 4 +- cpp/src/pdlp/utilities/ping_pong_graph.cuh | 4 +- cpp/src/pdlp/utils.cuh | 6 +-- .../c_api_tests/c_api_tests.cpp | 6 +-- cpp/tests/linear_programming/pdlp_test.cu | 53 ++++++++++--------- .../utilities/pdlp_test_utilities.cuh | 4 +- 49 files changed, 290 insertions(+), 291 deletions(-) diff --git a/benchmarks/linear_programming/cuopt/benchmark_helper.hpp b/benchmarks/linear_programming/cuopt/benchmark_helper.hpp index af6cc1deb7..84b0f57797 100644 --- a/benchmarks/linear_programming/cuopt/benchmark_helper.hpp +++ b/benchmarks/linear_programming/cuopt/benchmark_helper.hpp @@ -57,9 +57,8 @@ void parse_value(std::istringstream& iss, bool& value) iss >> std::boolalpha >> value; } -void fill_pdlp_hyper_params( - const std::string& pdlp_hyper_params_path, - cuopt::math_optimization::pdlp_hyper_params::pdlp_hyper_params_t& params) +void fill_pdlp_hyper_params(const std::string& pdlp_hyper_params_path, + cuopt::math_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; diff --git a/cpp/include/cuopt/math_optimization/mip/solver_settings.hpp b/cpp/include/cuopt/math_optimization/mip/solver_settings.hpp index 215952d643..abab298e72 100644 --- a/cpp/include/cuopt/math_optimization/mip/solver_settings.hpp +++ b/cpp/include/cuopt/math_optimization/mip/solver_settings.hpp @@ -182,7 +182,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; diff --git a/cpp/include/cuopt/math_optimization/pdlp/pdlp_hyper_params.cuh b/cpp/include/cuopt/math_optimization/pdlp/pdlp_hyper_params.cuh index 12263193a0..322a69a1bd 100644 --- a/cpp/include/cuopt/math_optimization/pdlp/pdlp_hyper_params.cuh +++ b/cpp/include/cuopt/math_optimization/pdlp/pdlp_hyper_params.cuh @@ -7,7 +7,7 @@ #pragma once -namespace cuopt::math_optimization::pdlp_hyper_params { +namespace cuopt::math_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::math_optimization::pdlp_hyper_params +} // namespace cuopt::math_optimization::pdlp diff --git a/cpp/include/cuopt/math_optimization/pdlp/solver_settings.hpp b/cpp/include/cuopt/math_optimization/pdlp/solver_settings.hpp index fb84701acf..ca00b17393 100644 --- a/cpp/include/cuopt/math_optimization/pdlp/solver_settings.hpp +++ b/cpp/include/cuopt/math_optimization/pdlp/solver_settings.hpp @@ -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 diff --git a/cpp/src/barrier/barrier.cu b/cpp/src/barrier/barrier.cu index dca93174e2..4eaf16c7bc 100644 --- a/cpp/src/barrier/barrier.cu +++ b/cpp/src/barrier/barrier.cu @@ -1723,13 +1723,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 { @@ -1968,20 +1968,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 diff --git a/cpp/src/barrier/cusparse_view.cu b/cpp/src/barrier/cusparse_view.cu index 6b88982e3c..211f585301 100644 --- a/cpp/src/barrier/cusparse_view.cu +++ b/cpp/src/barrier/cusparse_view.cu @@ -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 diff --git a/cpp/src/barrier/cusparse_view.hpp b/cpp/src/barrier/cusparse_view.hpp index 19e147dade..0b9059ff8b 100644 --- a/cpp/src/barrier/cusparse_view.hpp +++ b/cpp/src/barrier/cusparse_view.hpp @@ -29,7 +29,7 @@ class cusparse_view_t { cusparse_view_t(raft::handle_t const* handle_ptr, const 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 +38,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 +51,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}; diff --git a/cpp/src/mip_heuristics/diversity/population.cu b/cpp/src/mip_heuristics/diversity/population.cu index 58cd8a343d..329f8ba3ab 100644 --- a/cpp/src/mip_heuristics/diversity/population.cu +++ b/cpp/src/mip_heuristics/diversity/population.cu @@ -514,7 +514,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 +558,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!"); diff --git a/cpp/src/mip_heuristics/diversity/recombiners/sub_mip.cuh b/cpp/src/mip_heuristics/diversity/recombiners/sub_mip.cuh index dc9ad1571c..8d0ed44683 100644 --- a/cpp/src/mip_heuristics/diversity/recombiners/sub_mip.cuh +++ b/cpp/src/mip_heuristics/diversity/recombiners/sub_mip.cuh @@ -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, diff --git a/cpp/src/mip_heuristics/presolve/trivial_presolve.cuh b/cpp/src/mip_heuristics/presolve/trivial_presolve.cuh index 96bbaa51c0..5b80ea61a4 100644 --- a/cpp/src/mip_heuristics/presolve/trivial_presolve.cuh +++ b/cpp/src/mip_heuristics/presolve/trivial_presolve.cuh @@ -365,7 +365,7 @@ 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); diff --git a/cpp/src/mip_heuristics/problem/problem.cu b/cpp/src/mip_heuristics/problem/problem.cu index 45e6cd4daf..ec691ba531 100644 --- a/cpp/src/mip_heuristics/problem/problem.cu +++ b/cpp/src/mip_heuristics/problem/problem.cu @@ -102,7 +102,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 +1223,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. @@ -1911,7 +1911,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 +1982,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)); } @@ -2229,7 +2229,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 diff --git a/cpp/src/mip_heuristics/relaxed_lp/relaxed_lp.cu b/cpp/src/mip_heuristics/relaxed_lp/relaxed_lp.cu index c8b0e783bf..a4da98de3d 100644 --- a/cpp/src/mip_heuristics/relaxed_lp/relaxed_lp.cu +++ b/cpp/src/mip_heuristics/relaxed_lp/relaxed_lp.cu @@ -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( diff --git a/cpp/src/mip_heuristics/solution/solution.cu b/cpp/src/mip_heuristics/solution/solution.cu index a31dadd2d1..fca84db321 100644 --- a/cpp/src/mip_heuristics/solution/solution.cu +++ b/cpp/src/mip_heuristics/solution/solution.cu @@ -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()); } diff --git a/cpp/src/mip_heuristics/utils.cuh b/cpp/src/mip_heuristics/utils.cuh index 3b8cbe5dd1..39a3940536 100644 --- a/cpp/src/mip_heuristics/utils.cuh +++ b/cpp/src/mip_heuristics/utils.cuh @@ -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; diff --git a/cpp/src/pdlp/cusparse_view.cu b/cpp/src/pdlp/cusparse_view.cu index 7aaf61de10..720760ee1f 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::math_optimization::detail { +namespace cuopt::math_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 detail::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 detail::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 detail::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 detail::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::math_optimization::detail +} // namespace cuopt::math_optimization::pdlp diff --git a/cpp/src/pdlp/cusparse_view.hpp b/cpp/src/pdlp/cusparse_view.hpp index 231ad35ba3..9043aa1530 100644 --- a/cpp/src/pdlp/cusparse_view.hpp +++ b/cpp/src/pdlp/cusparse_view.hpp @@ -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::math_optimization::detail { +namespace cuopt::math_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 detail::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 detail::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 detail::problem_t& op_problem, const cusparse_view_t& existing_cusparse_view, f_t* _primal_solution, f_t* _dual_solution, @@ -297,7 +297,8 @@ 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 detail::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 +374,4 @@ void cusparse_spmvop_run(cusparseHandle_t handle, cudaStream_t stream); #endif // CUOPT_CUSPARSE_VER_12_7_UP -} // namespace cuopt::math_optimization::detail +} // namespace cuopt::math_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 fe7ae841fa..1da3848a2f 100644 --- a/cpp/src/pdlp/initial_scaling_strategy/initial_scaling.cu +++ b/cpp/src/pdlp/initial_scaling_strategy/initial_scaling.cu @@ -29,7 +29,7 @@ #include #include -namespace cuopt::math_optimization::detail { +namespace cuopt::math_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, + detail::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_); + detail::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 detail::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 detail::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 detail::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 detail::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 + detail::solution_t& solution) const { auto& primal_solution = solution.assignment; rmm::device_uvector dummy(0, solution.handle_ptr->get_stream()); @@ -894,7 +894,8 @@ void pdlp_initial_scaling_strategy_t::unscale_solutions( } template -const problem_t& pdlp_initial_scaling_strategy_t::get_scaled_op_problem() +const detail::problem_t& +pdlp_initial_scaling_strategy_t::get_scaled_op_problem() { return op_problem_scaled_; } @@ -938,11 +939,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 detail::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 detail::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 +951,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 detail::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 detail::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 +973,4 @@ INSTANTIATE(float) INSTANTIATE(double) #endif -} // namespace cuopt::math_optimization::detail +} // namespace cuopt::math_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 0c7d69233c..5b063b4592 100644 --- a/cpp/src/pdlp/initial_scaling_strategy/initial_scaling.cuh +++ b/cpp/src/pdlp/initial_scaling_strategy/initial_scaling.cuh @@ -21,7 +21,7 @@ #include #include -namespace cuopt::math_optimization::detail { +namespace cuopt::math_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, + detail::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(detail::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 detail::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_; + detail::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::math_optimization::detail +} // namespace cuopt::math_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 d18126b207..bd65e8d3db 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::math_optimization::detail { +namespace cuopt::math_optimization::pdlp { template struct SpMM_benchmarks_context_t { @@ -443,4 +443,4 @@ template int optimal_batch_size_handler( const optimization_problem_t& op_problem, int max_batch_size); #endif -} // namespace cuopt::math_optimization::detail +} // namespace cuopt::math_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 0eebea53f0..53b2a2ff69 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 @@ -7,7 +7,7 @@ #pragma once #include -namespace cuopt::math_optimization::detail { +namespace cuopt::math_optimization::pdlp { template int optimal_batch_size_handler(const optimization_problem_t& op_problem, diff --git a/cpp/src/pdlp/pdhg.cu b/cpp/src/pdlp/pdhg.cu index fd4a88ae5f..f00b3eb521 100644 --- a/cpp/src/pdlp/pdhg.cu +++ b/cpp/src/pdlp/pdhg.cu @@ -38,15 +38,15 @@ #include #include -namespace cuopt::math_optimization::detail { +namespace cuopt::math_optimization::pdlp { template pdhg_solver_t::pdhg_solver_t( raft::handle_t const* handle_ptr, - problem_t& op_problem_scaled, + detail::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::math_optimization::detail +} // namespace cuopt::math_optimization::pdlp diff --git a/cpp/src/pdlp/pdhg.hpp b/cpp/src/pdlp/pdhg.hpp index 196676a9c4..88c90753b0 100644 --- a/cpp/src/pdlp/pdhg.hpp +++ b/cpp/src/pdlp/pdhg.hpp @@ -23,15 +23,15 @@ #include #include -namespace cuopt::math_optimization::detail { +namespace cuopt::math_optimization::pdlp { template class pdhg_solver_t { public: pdhg_solver_t(raft::handle_t const* handle_ptr, - problem_t& op_problem, + detail::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; + detail::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::math_optimization::detail +} // namespace cuopt::math_optimization::pdlp diff --git a/cpp/src/pdlp/pdlp.cu b/cpp/src/pdlp/pdlp.cu index dcbc629dbc..7f27a90cef 100644 --- a/cpp/src/pdlp/pdlp.cu +++ b/cpp/src/pdlp/pdlp.cu @@ -45,7 +45,7 @@ #include #include -namespace cuopt::math_optimization::detail { +namespace cuopt::math_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(detail::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::math_optimization::detail +} // namespace cuopt::math_optimization::pdlp diff --git a/cpp/src/pdlp/pdlp.cuh b/cpp/src/pdlp/pdlp.cuh index 47f2c9c2f2..1d84ad97ef 100644 --- a/cpp/src/pdlp/pdlp.cuh +++ b/cpp/src/pdlp/pdlp.cuh @@ -33,7 +33,7 @@ #include #include -namespace cuopt::math_optimization::detail { +namespace cuopt::math_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 detail::problem_t object with a * representation of a linear program */ - pdlp_solver_t(problem_t& op_problem, + pdlp_solver_t(detail::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(detail::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); @@ -151,10 +151,10 @@ class pdlp_solver_t { dual_simplex::shared_strong_branching_context_view_t sb_view_{ settings_.shared_sb_solved}; - problem_t* problem_ptr; + detail::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_; + detail::problem_t op_problem_scaled_; rmm::device_uvector unscaled_primal_avg_solution_; rmm::device_uvector unscaled_dual_avg_solution_; @@ -182,11 +182,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 +203,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 +249,4 @@ class pdlp_solver_t { bool inside_mip_{false}; }; -} // namespace cuopt::math_optimization::detail +} // namespace cuopt::math_optimization::pdlp diff --git a/cpp/src/pdlp/pdlp_constants.hpp b/cpp/src/pdlp/pdlp_constants.hpp index f3bcf9731d..fe1c5d90d0 100644 --- a/cpp/src/pdlp/pdlp_constants.hpp +++ b/cpp/src/pdlp/pdlp_constants.hpp @@ -9,7 +9,7 @@ #include -namespace cuopt::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_optimization::pdlp 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 fb3bd70e96..332afdc8e3 100644 --- a/cpp/src/pdlp/restart_strategy/localized_duality_gap_container.cu +++ b/cpp/src/pdlp/restart_strategy/localized_duality_gap_container.cu @@ -15,14 +15,14 @@ #include -namespace cuopt::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_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 8767d302a9..38f24deee9 100644 --- a/cpp/src/pdlp/restart_strategy/localized_duality_gap_container.hpp +++ b/cpp/src/pdlp/restart_strategy/localized_duality_gap_container.hpp @@ -17,7 +17,7 @@ #include #include -namespace cuopt::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_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 b365addfe0..d6706a08fb 100644 --- a/cpp/src/pdlp/restart_strategy/pdlp_restart_strategy.cu +++ b/cpp/src/pdlp/restart_strategy/pdlp_restart_strategy.cu @@ -50,12 +50,12 @@ namespace cg = cooperative_groups; -namespace cuopt::math_optimization::detail { +namespace cuopt::math_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 detail::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, + detail::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 detail::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 detail::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 detail::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 detail::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 detail::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::math_optimization::detail +} // namespace cuopt::math_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 a9c2586d1e..d71807abfb 100644 --- a/cpp/src/pdlp/restart_strategy/pdlp_restart_strategy.cuh +++ b/cpp/src/pdlp/restart_strategy/pdlp_restart_strategy.cuh @@ -28,7 +28,7 @@ #include -namespace cuopt::math_optimization::detail { +namespace cuopt::math_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, + detail::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; + detail::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::math_optimization::detail +} // namespace cuopt::math_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 d19433d445..c3aff1ebc4 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::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_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 5d57de13c8..51faa57f35 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::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_optimization::pdlp diff --git a/cpp/src/pdlp/saddle_point.cu b/cpp/src/pdlp/saddle_point.cu index 2c233d86ea..601777c6bb 100644 --- a/cpp/src/pdlp/saddle_point.cu +++ b/cpp/src/pdlp/saddle_point.cu @@ -15,15 +15,14 @@ #include -namespace cuopt::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_optimization::pdlp diff --git a/cpp/src/pdlp/saddle_point.hpp b/cpp/src/pdlp/saddle_point.hpp index 4192d3f2b9..99977f5718 100644 --- a/cpp/src/pdlp/saddle_point.hpp +++ b/cpp/src/pdlp/saddle_point.hpp @@ -17,7 +17,7 @@ #include -namespace cuopt::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_optimization::pdlp diff --git a/cpp/src/pdlp/solve.cu b/cpp/src/pdlp/solve.cu index 9f95ab54a1..480dcc508f 100644 --- a/cpp/src/pdlp/solve.cu +++ b/cpp/src/pdlp/solve.cu @@ -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; @@ -706,7 +706,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); @@ -775,7 +775,7 @@ 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); } @@ -792,7 +792,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( @@ -1327,7 +1327,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 +1448,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 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 55b23fb30f..802cf7bb7f 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 @@ -33,7 +33,7 @@ #include -namespace cuopt::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_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 709d386738..b163a86088 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 @@ -24,7 +24,7 @@ #include -namespace cuopt::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_optimization::pdlp diff --git a/cpp/src/pdlp/swap_and_resize_helper.cuh b/cpp/src/pdlp/swap_and_resize_helper.cuh index 9b2695ff64..fa484a79c5 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::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_optimization::pdlp diff --git a/cpp/src/pdlp/termination_strategy/convergence_information.cu b/cpp/src/pdlp/termination_strategy/convergence_information.cu index d70e56768a..7f31189eaf 100644 --- a/cpp/src/pdlp/termination_strategy/convergence_information.cu +++ b/cpp/src/pdlp/termination_strategy/convergence_information.cu @@ -33,11 +33,11 @@ #include -namespace cuopt::math_optimization::detail { +namespace cuopt::math_optimization::pdlp { template convergence_information_t::convergence_information_t( raft::handle_t const* handle_ptr, - problem_t& op_problem, + detail::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::math_optimization::detail +} // namespace cuopt::math_optimization::pdlp diff --git a/cpp/src/pdlp/termination_strategy/convergence_information.hpp b/cpp/src/pdlp/termination_strategy/convergence_information.hpp index 8ea8da6a39..da3c6de213 100644 --- a/cpp/src/pdlp/termination_strategy/convergence_information.hpp +++ b/cpp/src/pdlp/termination_strategy/convergence_information.hpp @@ -25,12 +25,12 @@ #include #include -namespace cuopt::math_optimization::detail { +namespace cuopt::math_optimization::pdlp { template class convergence_information_t { public: convergence_information_t(raft::handle_t const* handle_ptr, - problem_t& op_problem, + detail::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; + detail::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_; + detail::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::math_optimization::detail +} // namespace cuopt::math_optimization::pdlp diff --git a/cpp/src/pdlp/termination_strategy/infeasibility_information.cu b/cpp/src/pdlp/termination_strategy/infeasibility_information.cu index 15e4111172..b7a6e80a9f 100644 --- a/cpp/src/pdlp/termination_strategy/infeasibility_information.cu +++ b/cpp/src/pdlp/termination_strategy/infeasibility_information.cu @@ -34,12 +34,12 @@ #include #include -namespace cuopt::math_optimization::detail { +namespace cuopt::math_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, + detail::problem_t& op_problem, + const detail::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::math_optimization::detail +} // namespace cuopt::math_optimization::pdlp diff --git a/cpp/src/pdlp/termination_strategy/infeasibility_information.hpp b/cpp/src/pdlp/termination_strategy/infeasibility_information.hpp index 55cd790608..f0ade6ad0a 100644 --- a/cpp/src/pdlp/termination_strategy/infeasibility_information.hpp +++ b/cpp/src/pdlp/termination_strategy/infeasibility_information.hpp @@ -23,23 +23,23 @@ #include #include -namespace cuopt::math_optimization::detail { +namespace cuopt::math_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, + detail::problem_t& op_problem, + const detail::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; + detail::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 detail::problem_t& op_problem_scaled_; - segmented_sum_handler_t segmented_sum_handler_; + detail::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::math_optimization::detail +} // namespace cuopt::math_optimization::pdlp diff --git a/cpp/src/pdlp/termination_strategy/termination_strategy.cu b/cpp/src/pdlp/termination_strategy/termination_strategy.cu index 78eb71f11a..0e6f91aa84 100644 --- a/cpp/src/pdlp/termination_strategy/termination_strategy.cu +++ b/cpp/src/pdlp/termination_strategy/termination_strategy.cu @@ -20,12 +20,12 @@ #include #include -namespace cuopt::math_optimization::detail { +namespace cuopt::math_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, + detail::problem_t& op_problem, + const detail::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::math_optimization::detail +} // namespace cuopt::math_optimization::pdlp diff --git a/cpp/src/pdlp/termination_strategy/termination_strategy.hpp b/cpp/src/pdlp/termination_strategy/termination_strategy.hpp index dc0d4ce080..3a783d949d 100644 --- a/cpp/src/pdlp/termination_strategy/termination_strategy.hpp +++ b/cpp/src/pdlp/termination_strategy/termination_strategy.hpp @@ -27,13 +27,13 @@ #include -namespace cuopt::math_optimization::detail { +namespace cuopt::math_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, + detail::problem_t& op_problem, + const detail::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; + detail::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::math_optimization::detail +} // namespace cuopt::math_optimization::pdlp diff --git a/cpp/src/pdlp/utilities/ping_pong_graph.cu b/cpp/src/pdlp/utilities/ping_pong_graph.cu index d0944d27a3..a8399084c3 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::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_optimization::pdlp diff --git a/cpp/src/pdlp/utilities/ping_pong_graph.cuh b/cpp/src/pdlp/utilities/ping_pong_graph.cuh index 232e6c1f99..be9d2252ea 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::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_optimization::pdlp diff --git a/cpp/src/pdlp/utils.cuh b/cpp/src/pdlp/utils.cuh index a2e667720c..20028e0565 100644 --- a/cpp/src/pdlp/utils.cuh +++ b/cpp/src/pdlp/utils.cuh @@ -30,7 +30,7 @@ #include #include -namespace cuopt::math_optimization::detail { +namespace cuopt::math_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 detail::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::math_optimization::detail +} // namespace cuopt::math_optimization::pdlp 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 cdcf391eb0..808353023f 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 @@ -19,7 +19,7 @@ #include #include -namespace cuopt::math_optimization::detail { +namespace cuopt::math_optimization::pdlp { bool is_cusparse_runtime_mixed_precision_supported(); } @@ -406,12 +406,12 @@ TEST(c_api, pdlp_precision_single) TEST(c_api, pdlp_precision_mixed) { - using namespace cuopt::math_optimization::detail; + using namespace cuopt::math_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::math_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/pdlp_test.cu b/cpp/tests/linear_programming/pdlp_test.cu index ca43dafbdd..6086cf98a3 100644 --- a/cpp/tests/linear_programming/pdlp_test.cu +++ b/cpp/tests/linear_programming/pdlp_test.cu @@ -95,6 +95,7 @@ TEST(pdlp_class, run_double) TEST(pdlp_class, precision_mixed) { using namespace cuopt::math_optimization::detail; + using namespace cuopt::math_optimization::pdlp; if (!is_cusparse_runtime_mixed_precision_supported()) { const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/afiro_original.mps"); @@ -491,7 +492,7 @@ TEST(pdlp_class, initial_solution_test) EXPECT_FALSE(solver_settings.hyper_params.update_primal_weight_on_initial_solution); { - cuopt::math_optimization::detail::pdlp_solver_t solver(problem, solver_settings); + cuopt::math_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 +503,7 @@ 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::math_optimization::detail::pdlp_solver_t solver(problem, solver_settings); + cuopt::math_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 +514,7 @@ TEST(pdlp_class, initial_solution_test) EXPECT_NEAR(initial_primal_weight_afiro, solver.get_primal_weight_h(0), factor_tolerance); } { - cuopt::math_optimization::detail::pdlp_solver_t solver(problem, solver_settings); + cuopt::math_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 +525,7 @@ TEST(pdlp_class, initial_solution_test) EXPECT_NEAR(initial_primal_weight_afiro, solver.get_primal_weight_h(0), factor_tolerance); } { - cuopt::math_optimization::detail::pdlp_solver_t solver(problem, solver_settings); + cuopt::math_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 +541,7 @@ TEST(pdlp_class, initial_solution_test) // Toggle the scale on initial solution while not providing should yield the same { - cuopt::math_optimization::detail::pdlp_solver_t solver(problem, solver_settings); + cuopt::math_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 +551,7 @@ TEST(pdlp_class, initial_solution_test) solver_settings.hyper_params.update_step_size_on_initial_solution = false; } { - cuopt::math_optimization::detail::pdlp_solver_t solver(problem, solver_settings); + cuopt::math_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 +561,7 @@ TEST(pdlp_class, initial_solution_test) solver_settings.hyper_params.update_primal_weight_on_initial_solution = false; } { - cuopt::math_optimization::detail::pdlp_solver_t solver(problem, solver_settings); + cuopt::math_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 +577,7 @@ 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::math_optimization::detail::pdlp_solver_t solver(problem, solver_settings); + cuopt::math_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 +590,7 @@ TEST(pdlp_class, initial_solution_test) } { solver_settings.hyper_params.update_step_size_on_initial_solution = true; - cuopt::math_optimization::detail::pdlp_solver_t solver(problem, solver_settings); + cuopt::math_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 +606,7 @@ 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::math_optimization::detail::pdlp_solver_t solver(problem, solver_settings); + cuopt::math_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 +618,7 @@ TEST(pdlp_class, initial_solution_test) } { solver_settings.hyper_params.update_primal_weight_on_initial_solution = true; - cuopt::math_optimization::detail::pdlp_solver_t solver(problem, solver_settings); + cuopt::math_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 +633,7 @@ 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::math_optimization::detail::pdlp_solver_t solver(problem, solver_settings); + cuopt::math_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 +651,7 @@ 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::math_optimization::detail::pdlp_solver_t solver(problem, solver_settings); + cuopt::math_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 +663,7 @@ TEST(pdlp_class, initial_solution_test) } { solver_settings.hyper_params.update_primal_weight_on_initial_solution = true; - cuopt::math_optimization::detail::pdlp_solver_t solver(problem, solver_settings); + cuopt::math_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 +675,7 @@ TEST(pdlp_class, initial_solution_test) } { solver_settings.hyper_params.update_primal_weight_on_initial_solution = true; - cuopt::math_optimization::detail::pdlp_solver_t solver(problem, solver_settings); + cuopt::math_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 +693,7 @@ TEST(pdlp_class, initial_solution_test) // weight and step size { solver_settings.hyper_params.update_primal_weight_on_initial_solution = true; - cuopt::math_optimization::detail::pdlp_solver_t solver(problem, solver_settings); + cuopt::math_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 +708,7 @@ TEST(pdlp_class, initial_solution_test) } { solver_settings.hyper_params.update_step_size_on_initial_solution = true; - cuopt::math_optimization::detail::pdlp_solver_t solver(problem, solver_settings); + cuopt::math_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 +724,7 @@ 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::math_optimization::detail::pdlp_solver_t solver(problem, solver_settings); + cuopt::math_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()); @@ -763,7 +764,7 @@ TEST(pdlp_class, initial_primal_weight_step_size_test) // Check setting an initial primal weight and step size { - cuopt::math_optimization::detail::pdlp_solver_t solver(problem, solver_settings); + cuopt::math_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 +782,7 @@ 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::math_optimization::detail::pdlp_solver_t solver(problem, solver_settings); + cuopt::math_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 +795,7 @@ 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::math_optimization::detail::pdlp_solver_t solver2(problem, solver_settings); + cuopt::math_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 +811,7 @@ 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::math_optimization::detail::pdlp_solver_t solver3(problem, solver_settings); + cuopt::math_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); @@ -866,7 +867,7 @@ End // First solve without the per constraint and it should break { - cuopt::math_optimization::detail::pdlp_solver_t solver(problem, solver_settings); + cuopt::math_optimization::pdlp::pdlp_solver_t solver(problem, solver_settings); raft::copy(solver.pdhg_solver_.get_primal_solution().data(), d_initial_primal.data(), @@ -890,7 +891,7 @@ End } { solver_settings.per_constraint_residual = true; - cuopt::math_optimization::detail::pdlp_solver_t solver(problem, solver_settings); + cuopt::math_optimization::pdlp::pdlp_solver_t solver(problem, solver_settings); raft::copy(solver.pdhg_solver_.get_primal_solution().data(), d_initial_primal.data(), @@ -4469,13 +4470,13 @@ TEST(pdlp_class, batch_bound_objective_rescaling_factors_match_input_expansion) 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::math_optimization::detail::problem_t problem(gpu_op); - cuopt::math_optimization::detail::pdlp_initial_scaling_strategy_t scaling( + cuopt::math_optimization::pdlp::pdlp_initial_scaling_strategy_t scaling( &handle_, problem, hyper_params.default_l_inf_ruiz_iterations, diff --git a/cpp/tests/linear_programming/utilities/pdlp_test_utilities.cuh b/cpp/tests/linear_programming/utilities/pdlp_test_utilities.cuh index ba1efe2c72..dffc0dbff7 100644 --- a/cpp/tests/linear_programming/utilities/pdlp_test_utilities.cuh +++ b/cpp/tests/linear_programming/utilities/pdlp_test_utilities.cuh @@ -191,7 +191,7 @@ static void test_constraint_sanity( } } - auto functor = cuopt::math_optimization::detail::violation{}; + auto functor = cuopt::math_optimization::pdlp::violation{}; // Compute violation to lower/upper bound @@ -217,7 +217,7 @@ static void test_constraint_sanity( constraint_lower_bounds.cend(), constraint_upper_bounds.cbegin(), combined_bounds.begin(), - cuopt::math_optimization::detail::combine_finite_abs_bounds{}); + cuopt::math_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) { From fedf6ad0b7b36487a4d51385acedb1806d846668 Mon Sep 17 00:00:00 2001 From: Miles Lubin Date: Sat, 20 Jun 2026 21:41:36 +0000 Subject: [PATCH 03/17] refactor: move barrier solver into cuopt::math_optimization::barrier Out of dual_simplex; barrier now owns its own cusparse_view_t cleanly. Co-Authored-By: Claude Opus 4.8 (1M context) Signed-off-by: Miles Lubin --- cpp/src/barrier/barrier.cu | 84 +++++++++++-------- cpp/src/barrier/barrier.hpp | 7 +- cpp/src/barrier/conjugate_gradient.hpp | 19 +++-- cpp/src/barrier/cusparse_info.hpp | 4 +- cpp/src/barrier/cusparse_view.cu | 7 +- cpp/src/barrier/cusparse_view.hpp | 7 +- cpp/src/barrier/dense_matrix.hpp | 7 +- cpp/src/barrier/dense_vector.hpp | 7 +- cpp/src/barrier/device_sparse_matrix.cu | 7 ++ cpp/src/barrier/device_sparse_matrix.cuh | 7 +- cpp/src/barrier/iterative_refinement.hpp | 7 +- cpp/src/barrier/pinned_host_allocator.cu | 19 ++++- cpp/src/barrier/pinned_host_allocator.hpp | 4 +- cpp/src/barrier/second_order_cone_kernels.cuh | 4 +- .../barrier/second_order_cone_reduction.cuh | 4 +- cpp/src/barrier/sparse_cholesky.cuh | 11 ++- cpp/src/barrier/sparse_matrix_kernels.cuh | 4 +- cpp/src/cuts/cuts.cpp | 8 +- cpp/src/dual_simplex/solve.cpp | 4 +- cpp/src/dual_simplex/vector_math.cpp | 8 +- cpp/tests/socp/second_order_cone_kernels.cu | 4 +- 21 files changed, 148 insertions(+), 85 deletions(-) diff --git a/cpp/src/barrier/barrier.cu b/cpp/src/barrier/barrier.cu index 4eaf16c7bc..995261e9a7 100644 --- a/cpp/src/barrier/barrier.cu +++ b/cpp/src/barrier/barrier.cu @@ -50,7 +50,10 @@ #include #include -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_optimization::barrier { + +using namespace cuopt::math_optimization::dual_simplex; // shared simplex types (lp_problem_t, inf, + // etc.) template bool validate_barrier_cone_layout(const lp_problem_t& problem, @@ -1008,9 +1011,13 @@ 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", dual_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", dual_simplex::vector_norm2(x)); + } return solve_status; } else { // Use Sherman Morrison followed by PCG @@ -1046,9 +1053,13 @@ 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", dual_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", dual_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 +1097,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)); + dual_simplex::vector_norm2(M_residual)); } } // A_sparse * D_sparse * A_sparse^T * M = U = AD_dense @@ -1138,7 +1149,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", + dual_simplex::vector_norm2(H_residual)); } // x = (A_sparse * D_sparse * A_sparse^T)^{-1} * (b - U * y) @@ -1157,14 +1169,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)); + dual_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", + dual_simplex::vector_norm2(residual_2)); } if (debug) { @@ -1173,7 +1186,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)); + dual_simplex::vector_norm2(residual_1)); } if (full_debug && debug) { @@ -1198,7 +1211,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, dual_simplex::vector_norm2(u)); } settings_.log.printf("|| ADAT(e_i) - ADA^T * e_i ||_2 = %e\n", max_error); } @@ -1338,7 +1351,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, dual_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 +1362,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)); + dual_simplex::vector_norm2(total_residual)); } // Now do some rounds of PCG @@ -1418,7 +1431,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 = dual_simplex::vector_norm_inf(dual_res, stream_view_); #ifdef PRINT_INFO settings_.log.printf("Solution Dual residual: %e\n", dual_residual_norm); #endif @@ -1777,19 +1790,19 @@ 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)); } + if (debug) { printf("||u|| = %.16e\n", dual_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", dual_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", dual_simplex::vector_norm2(A.x)); + printf("||w|| = %.16e\n", dual_simplex::vector_norm2(w)); + printf("||v|| = %.16e\n", dual_simplex::vector_norm2(v)); } } @@ -2156,8 +2169,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 = dual_simplex::vector_norm_inf(lp.rhs); + const f_t norm_c = dual_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 +2276,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", dual_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", dual_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", dual_simplex::vector_norm2(q)); #endif // rhs_x <- A*Dinv*A'*q - rhs_x @@ -2283,7 +2296,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)); + dual_simplex::vector_norm2(rhs_x)); #endif // x = Dinv*(F*u - A'*q) @@ -2309,7 +2322,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", + dual_simplex::vector_norm2(init_primal_residual)); #endif if (data.n_upper_bounds > 0) { @@ -2319,7 +2333,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", + dual_simplex::vector_norm2(init_bound_residual)); #endif } @@ -2333,7 +2348,7 @@ int barrier_solver_t::initial_point(iteration_data_t& data) // y = 0 data.y.set_scalar(0.0); - f_t epsilon = 1.0 + vector_norm1(lp.objective); + f_t epsilon = 1.0 + dual_simplex::vector_norm1(lp.objective); // A^T y + z - E^T v - Q x = c // when y = 0, z - E^T v = c + Q x @@ -2433,7 +2448,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)); + dual_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); @@ -3076,8 +3091,9 @@ i_t barrier_solver_t::gpu_compute_search_direction(iteration_data_t(dx_residual_4, stream_view_); - max_residual = std::max(max_residual, dx_residual_4_norm); + const f_t dx_residual_4_norm = + dual_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 +4123,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 = dual_simplex::vector_norm_inf(data.b, stream_view_); + f_t norm_c = dual_simplex::vector_norm_inf(data.c, stream_view_); f_t quad_objective = 0.0; if (data.Q.n > 0) { @@ -4448,4 +4464,4 @@ template class sparse_cholesky_cudss_t; template class iteration_data_t; #endif -} // namespace cuopt::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::barrier diff --git a/cpp/src/barrier/barrier.hpp b/cpp/src/barrier/barrier.hpp index e5cae7181b..73b70f03c8 100644 --- a/cpp/src/barrier/barrier.hpp +++ b/cpp/src/barrier/barrier.hpp @@ -16,7 +16,10 @@ #include #include -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_optimization::barrier { + +using namespace cuopt::math_optimization::dual_simplex; // shared simplex types (lp_problem_t, inf, + // etc.) /** Validates SOC layout on an lp_problem_t before barrier presolve/solve. */ template @@ -116,4 +119,4 @@ class barrier_solver_t { rmm::cuda_stream_view stream_view_; }; -} // namespace cuopt::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::barrier diff --git a/cpp/src/barrier/conjugate_gradient.hpp b/cpp/src/barrier/conjugate_gradient.hpp index ba2f0fffbc..bd61327d54 100644 --- a/cpp/src/barrier/conjugate_gradient.hpp +++ b/cpp/src/barrier/conjugate_gradient.hpp @@ -16,7 +16,10 @@ #include #include -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_optimization::barrier { + +using namespace cuopt::math_optimization::dual_simplex; // shared simplex types (lp_problem_t, inf, + // etc.) template i_t preconditioned_conjugate_gradient(const T& op, @@ -42,12 +45,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 = dual_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)); + dual_simplex::vector_norm_inf(residual)); } f_t rTy = residual.inner_product(y); @@ -62,7 +65,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 = dual_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 +81,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 = dual_simplex::vector_norm2(residual); // Solve M y = r for y op.m_solve(residual, y); @@ -98,13 +101,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)); + dual_simplex::vector_norm_inf(residual)); } } residual = b; op.a_multiply(1.0, x, -1.0, residual); - norm_residual = vector_norm2(residual); + norm_residual = dual_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 +123,4 @@ i_t preconditioned_conjugate_gradient(const T& op, return iter; } -} // namespace cuopt::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::barrier diff --git a/cpp/src/barrier/cusparse_info.hpp b/cpp/src/barrier/cusparse_info.hpp index 64977d5971..109dc2e3b8 100644 --- a/cpp/src/barrier/cusparse_info.hpp +++ b/cpp/src/barrier/cusparse_info.hpp @@ -17,7 +17,7 @@ #include -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_optimization::barrier { template struct cusparse_info_t { @@ -67,4 +67,4 @@ struct cusparse_info_t { size_t buffer_size_5_size; }; -} // namespace cuopt::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::barrier diff --git a/cpp/src/barrier/cusparse_view.cu b/cpp/src/barrier/cusparse_view.cu index 211f585301..fbee992faf 100644 --- a/cpp/src/barrier/cusparse_view.cu +++ b/cpp/src/barrier/cusparse_view.cu @@ -22,7 +22,10 @@ #include -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_optimization::barrier { + +using namespace cuopt::math_optimization::dual_simplex; // shared simplex types (lp_problem_t, inf, + // etc.) #define CUDA_VER_12_4_UP (CUDART_VERSION >= 12040) @@ -423,4 +426,4 @@ cusparse_view_t::transpose_spmv, std::alloca double beta, std::vector>& y); -} // namespace cuopt::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::barrier diff --git a/cpp/src/barrier/cusparse_view.hpp b/cpp/src/barrier/cusparse_view.hpp index 0b9059ff8b..39db2c74d2 100644 --- a/cpp/src/barrier/cusparse_view.hpp +++ b/cpp/src/barrier/cusparse_view.hpp @@ -21,7 +21,10 @@ // 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::math_optimization::dual_simplex { +namespace cuopt::math_optimization::barrier { + +using namespace cuopt::math_optimization::dual_simplex; // shared simplex types (lp_problem_t, inf, + // etc.) template class cusparse_view_t { public: @@ -72,4 +75,4 @@ class cusparse_view_t { rmm::device_scalar d_minus_one_; rmm::device_scalar d_zero_; }; -} // namespace cuopt::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::barrier diff --git a/cpp/src/barrier/dense_matrix.hpp b/cpp/src/barrier/dense_matrix.hpp index 2f6b5d38fa..badb30c6f0 100644 --- a/cpp/src/barrier/dense_matrix.hpp +++ b/cpp/src/barrier/dense_matrix.hpp @@ -12,7 +12,10 @@ #pragma once -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_optimization::barrier { + +using namespace cuopt::math_optimization::dual_simplex; // shared simplex types (lp_problem_t, inf, + // etc.) template class dense_matrix_t { @@ -242,4 +245,4 @@ class dense_matrix_t { std::vector values; }; -} // namespace cuopt::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::barrier diff --git a/cpp/src/barrier/dense_vector.hpp b/cpp/src/barrier/dense_vector.hpp index 70a25b48d7..94e0fdd0cd 100644 --- a/cpp/src/barrier/dense_vector.hpp +++ b/cpp/src/barrier/dense_vector.hpp @@ -12,7 +12,10 @@ #include #include -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_optimization::barrier { + +using namespace cuopt::math_optimization::dual_simplex; // shared simplex types (lp_problem_t, inf, + // etc.) template > class dense_vector_t : public std::vector { @@ -246,4 +249,4 @@ std::vector copy(const std::vector& src) return std::vector(src.begin(), src.end()); } -} // namespace cuopt::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::barrier diff --git a/cpp/src/barrier/device_sparse_matrix.cu b/cpp/src/barrier/device_sparse_matrix.cu index e488a06e6b..954f99e35f 100644 --- a/cpp/src/barrier/device_sparse_matrix.cu +++ b/cpp/src/barrier/device_sparse_matrix.cu @@ -10,8 +10,15 @@ #include +// This translation unit provides out-of-line definitions and explicit +// instantiations of shared dual_simplex sparse-matrix templates (csc_matrix_t, +// matrix_transpose_vector_multiply) specialized with barrier's +// PinnedHostAllocator. They must live in the dual_simplex namespace (where the +// templates are declared), even though the file resides under barrier/. namespace cuopt::math_optimization::dual_simplex { +using cuopt::math_optimization::barrier::PinnedHostAllocator; + template template void csc_matrix_t::scale_columns(const std::vector& scale) diff --git a/cpp/src/barrier/device_sparse_matrix.cuh b/cpp/src/barrier/device_sparse_matrix.cuh index cd13267890..9cac8f6e5e 100644 --- a/cpp/src/barrier/device_sparse_matrix.cuh +++ b/cpp/src/barrier/device_sparse_matrix.cuh @@ -23,7 +23,10 @@ #include #include -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_optimization::barrier { + +using namespace cuopt::math_optimization::dual_simplex; // shared simplex types (lp_problem_t, inf, + // etc.) template class device_csr_matrix_t; @@ -388,4 +391,4 @@ void device_csc_matrix_t::to_compressed_row(device_csr_matrix_t #include -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_optimization::barrier { + +using namespace cuopt::math_optimization::dual_simplex; // shared simplex types (lp_problem_t, inf, + // etc.) // Functors for device operations (defined at namespace scope to avoid CUDA lambda restrictions) template @@ -413,4 +416,4 @@ f_t iterative_refinement(T& op, const rmm::device_uvector& b, rmm::device_u return iterative_refinement_gmres(op, b, x); } -} // namespace cuopt::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::barrier diff --git a/cpp/src/barrier/pinned_host_allocator.cu b/cpp/src/barrier/pinned_host_allocator.cu index 4a651fa6c4..bc628b29de 100644 --- a/cpp/src/barrier/pinned_host_allocator.cu +++ b/cpp/src/barrier/pinned_host_allocator.cu @@ -10,7 +10,10 @@ #include #include -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_optimization::barrier { + +using namespace cuopt::math_optimization::dual_simplex; // shared simplex types (lp_problem_t, inf, + // etc.) template struct PinnedHostAllocator { @@ -45,8 +48,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 +56,16 @@ template bool operator!=(const PinnedHostAllocator&, #endif template class PinnedHostAllocator; +} // namespace cuopt::math_optimization::barrier + +namespace cuopt::math_optimization::dual_simplex { + +// Explicit instantiation of the shared dual_simplex vector_math template with +// barrier's PinnedHostAllocator must live in dual_simplex (the template's namespace). +#ifdef DUAL_SIMPLEX_INSTANTIATE_DOUBLE +template double +vector_norm_inf>( + const std::vector>& x); +#endif + } // namespace cuopt::math_optimization::dual_simplex diff --git a/cpp/src/barrier/pinned_host_allocator.hpp b/cpp/src/barrier/pinned_host_allocator.hpp index 27116e2572..d62fabe1f0 100644 --- a/cpp/src/barrier/pinned_host_allocator.hpp +++ b/cpp/src/barrier/pinned_host_allocator.hpp @@ -9,7 +9,7 @@ #include -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_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::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::barrier diff --git a/cpp/src/barrier/second_order_cone_kernels.cuh b/cpp/src/barrier/second_order_cone_kernels.cuh index df41509f24..a9f037a5e0 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::math_optimization::dual_simplex { +namespace cuopt::math_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::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::barrier diff --git a/cpp/src/barrier/second_order_cone_reduction.cuh b/cpp/src/barrier/second_order_cone_reduction.cuh index ad1415d472..328e3fd9c8 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::math_optimization::dual_simplex { +namespace cuopt::math_optimization::barrier { template class sparse_cholesky_base_t { @@ -853,9 +856,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), + dual_simplex::vector_norm2(b_host), compute_hash(b_host), - vector_norm2(x_host), + dual_simplex::vector_norm2(x_host), compute_hash(x_host)); #endif @@ -896,4 +899,4 @@ class sparse_cholesky_cudss_t : public sparse_cholesky_base_t { void* cuGetErrorString_func; }; -} // namespace cuopt::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::barrier diff --git a/cpp/src/barrier/sparse_matrix_kernels.cuh b/cpp/src/barrier/sparse_matrix_kernels.cuh index 6027711b29..5825ebd42b 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::math_optimization::dual_simplex { +namespace cuopt::math_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::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::barrier diff --git a/cpp/src/cuts/cuts.cpp b/cpp/src/cuts/cuts.cpp index 1585c69747..1f392893d0 100644 --- a/cpp/src/cuts/cuts.cpp +++ b/cpp/src/cuts/cuts.cpp @@ -2331,8 +2331,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 +2402,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 diff --git a/cpp/src/dual_simplex/solve.cpp b/cpp/src/dual_simplex/solve.cpp index 1b9025d206..cae0a78518 100644 --- a/cpp/src/dual_simplex/solve.cpp +++ b/cpp/src/dual_simplex/solve.cpp @@ -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 diff --git a/cpp/src/dual_simplex/vector_math.cpp b/cpp/src/dual_simplex/vector_math.cpp index ac5e9f7be7..d12366e563 100644 --- a/cpp/src/dual_simplex/vector_math.cpp +++ b/cpp/src/dual_simplex/vector_math.cpp @@ -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); diff --git a/cpp/tests/socp/second_order_cone_kernels.cu b/cpp/tests/socp/second_order_cone_kernels.cu index 709e785b4e..0111bbef99 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::math_optimization::dual_simplex::test { +namespace cuopt::math_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::math_optimization::dual_simplex::test +} // namespace cuopt::math_optimization::barrier::test From 00120425474cb27d8e2cf0fd55e806f115cc854e Mon Sep 17 00:00:00 2001 From: Miles Lubin Date: Sat, 20 Jun 2026 21:44:17 +0000 Subject: [PATCH 04/17] chore: remove solver-output files accidentally committed in the rename '1' and 'best_results.txt' are solver/benchmark stdout captures that a broad 'git add -A' swept into the umbrella-rename commit. Not source. Co-Authored-By: Claude Opus 4.8 (1M context) Signed-off-by: Miles Lubin --- 1 | 421 ----------------------------------------------- best_results.txt | 0 2 files changed, 421 deletions(-) delete mode 100644 1 delete mode 100644 best_results.txt diff --git a/1 b/1 deleted file mode 100644 index 9549760458..0000000000 --- a/1 +++ /dev/null @@ -1,421 +0,0 @@ -Setting parameter absolute_dual_tolerance to 1.000000e-05 -Setting parameter relative_dual_tolerance to 1.000000e-05 -Setting parameter absolute_primal_tolerance to 1.000000e-05 -Setting parameter relative_primal_tolerance to 1.000000e-05 -Setting parameter absolute_gap_tolerance to 1.000000e-05 -Setting parameter relative_gap_tolerance to 1.000000e-05 -Setting parameter primal_infeasible_tolerance to 1.000000e-05 -Setting parameter dual_infeasible_tolerance to 1.000000e-05 -Setting parameter time_limit to 1.020000e+01 -Setting parameter iteration_limit to 10 -Setting parameter infeasibility_detection to false -Setting parameter mip_relative_tolerance to 1.000000e-02 -Setting parameter mip_cut_min_orthogonality to 0.000000e+00 -Setting parameter mip_absolute_gap to 1.000000e-02 -Setting parameter eliminate_dense_columns to false -Setting parameter mip_clique_cuts to 0 -Setting parameter absolute_primal_tolerance to 0.000000e+00 -Setting parameter node_limit to 2147483646 -Setting parameter mip_objective_step to 0 -Setting parameter mip_hyper_heuristic_presolve_max_time to 6.000000e+01 -Setting parameter mip_hyper_diving_coefficient to -1 -Setting parameter mip_mixed_integer_gomory_cuts to 0 -Setting parameter pdlp_precision to 0 -Setting parameter mip_reliability_branching to 0 -Setting parameter mip_cut_change_threshold to -5.000000e-01 -Setting parameter folding to 0 -Setting parameter pdlp_solver_mode to 3 -Setting parameter mip_implied_bound_cuts to 0 -Setting parameter relative_gap_tolerance to 0.000000e+00 -Setting parameter mip_relative_gap to 2.000000e-04 -Setting parameter mip_hyper_heuristic_cycle_detection_length to 30 -Setting parameter mip_hyper_heuristic_max_iterations_without_improvement to 8 -Setting parameter mip_knapsack_cuts to 0 -Setting parameter presolve to 1 -Setting parameter mip_hyper_heuristic_num_cpufj_threads to 8 -Setting parameter mip_hyper_heuristic_stagnation_trigger to 3 -Setting parameter iteration_limit to 9999999 -Setting parameter strict_infeasibility to true -Setting parameter num_cpu_threads to 0 -Setting parameter mip_hyper_heuristic_related_vars_time_limit to 3.000000e+01 -Setting parameter relative_dual_tolerance to 0.000000e+00 -Setting parameter primal_infeasible_tolerance to 1.000000e-02 -Setting parameter method to 2 -Setting parameter mip_hyper_heuristic_root_lp_time_ratio to 1.000000e-01 -Setting parameter mip_batch_pdlp_reliability_branching to 1 -Setting parameter mip_batch_pdlp_strong_branching to 1 -Setting parameter dual_infeasible_tolerance to 1.000000e-02 -Setting parameter per_constraint_residual to true -Setting parameter mip_determinism_mode to 1 -Setting parameter mip_hyper_heuristic_presolve_time_ratio to 1.000000e-01 -Setting parameter mip_cut_passes to 9 -Setting parameter mip_hyper_diving_node_limit to 500 -Setting parameter mip_hyper_diving_iteration_limit_factor to 5.000000e-02 -Setting parameter mip_hyper_heuristic_population_size to 32 -Setting parameter log_to_console to false -Setting parameter mip_absolute_tolerance to 0.000000e+00 -Setting parameter save_best_primal_so_far to true -Setting parameter mip_mixed_integer_rounding_cuts to 0 -Setting parameter mip_hyper_diving_backtrack_limit to 5 -Setting parameter mip_hyper_diving_show_type to false -Setting parameter relative_primal_tolerance to 0.000000e+00 -Setting parameter crossover to true -Setting parameter mip_scaling to 1 -Setting parameter mip_hyper_diving_pseudocost to -1 -Setting parameter mip_hyper_heuristic_relaxed_lp_time_limit to 1.000000e+00 -Setting parameter random_seed to 0 -Setting parameter work_limit to 7.200000e+03 -Setting parameter augmented to 0 -Setting parameter mip_hyper_diving_farkas to -1 -Setting parameter num_gpus to 2 -Setting parameter mip_flow_cover_cuts to 0 -Setting parameter mip_strong_chvatal_gomory_cuts to 0 -Setting parameter mip_hyper_heuristic_rins_fix_rate to 5.000000e-01 -Setting parameter user_problem_file to -Setting parameter mip_hyper_heuristic_rins_max_time_limit to 2.000000e+01 -Setting parameter absolute_gap_tolerance to 0.000000e+00 -Setting parameter mip_heuristics_only to true -Setting parameter presolve_file to 1 -Setting parameter mip_reduced_cost_strengthening to 0 -Setting parameter first_primal_feasible to true -Setting parameter infeasibility_detection to true -Setting parameter log_file to 1 -Setting parameter mip_hyper_heuristic_enabled_recombiners to 15 -Setting parameter mip_strong_branching_simplex_iteration_limit to 0 -Setting parameter barrier_step_scale to 5.000000e-01 -Setting parameter time_limit to 3.600000e+03 -Setting parameter mip_symmetry to 0 -Setting parameter mip_semi_continuous_big_m to 5.000000e+09 -Setting parameter barrier_iterative_refinement to false -Setting parameter absolute_dual_tolerance to 0.000000e+00 -Setting parameter dual_postsolve to false -Setting parameter mip_hyper_diving_min_node_depth to 10 -Setting parameter mip_hyper_heuristic_root_lp_max_time to 1.500000e+01 -Setting parameter cudss_deterministic to true -Setting parameter mip_integrality_tolerance to 0.000000e+00 -Setting parameter mip_hyper_diving_line_search to -1 -Setting parameter mip_hyper_diving_vector_length to -1 -Setting parameter barrier_dual_initial_point to 0 -Setting parameter mip_hyper_heuristic_n_of_minimums_for_exit to 7000 -Setting parameter mip_hyper_heuristic_rins_time_limit to 3.000000e+00 -Setting parameter mip_hyper_heuristic_initial_infeasibility_weight to 1.000000e+03 -Setting parameter ordering to 0 -Setting parameter mip_probing to false -Setting parameter solution_file to -Setting parameter mip_hyper_diving_guided to -1 -Setting parameter dualize to 0 -Setting parameter iteration_limit to 9999999 -Setting parameter node_limit to 2147483646 -Setting parameter pdlp_solver_mode to 3 -Setting parameter method to 2 -Setting parameter num_cpu_threads to 0 -Setting parameter augmented to 0 -Setting parameter folding to 0 -Setting parameter dualize to 0 -Setting parameter ordering to 0 -Setting parameter barrier_dual_initial_point to 0 -Setting parameter mip_cut_passes to 9 -Setting parameter mip_mixed_integer_rounding_cuts to 0 -Setting parameter mip_mixed_integer_gomory_cuts to 0 -Setting parameter mip_knapsack_cuts to 0 -Setting parameter mip_flow_cover_cuts to 0 -Setting parameter mip_clique_cuts to 0 -Setting parameter mip_implied_bound_cuts to 0 -Setting parameter mip_strong_chvatal_gomory_cuts to 0 -Setting parameter mip_reduced_cost_strengthening to 0 -Setting parameter mip_objective_step to 0 -Setting parameter num_gpus to 2 -Setting parameter num_gpus to 2 -Setting parameter mip_batch_pdlp_strong_branching to 1 -Setting parameter mip_batch_pdlp_reliability_branching to 1 -Setting parameter mip_strong_branching_simplex_iteration_limit to 0 -Setting parameter presolve to 1 -Setting parameter presolve to 1 -Setting parameter mip_determinism_mode to 1 -Setting parameter random_seed to 0 -Setting parameter mip_reliability_branching to 0 -Setting parameter pdlp_precision to 0 -Setting parameter mip_symmetry to 0 -Setting parameter mip_scaling to 1 -Setting parameter mip_hyper_heuristic_population_size to 32 -Setting parameter mip_hyper_heuristic_num_cpufj_threads to 8 -Setting parameter mip_hyper_heuristic_stagnation_trigger to 3 -Setting parameter mip_hyper_heuristic_max_iterations_without_improvement to 8 -Setting parameter mip_hyper_heuristic_n_of_minimums_for_exit to 7000 -Setting parameter mip_hyper_heuristic_enabled_recombiners to 15 -Setting parameter mip_hyper_heuristic_cycle_detection_length to 30 -Setting parameter mip_hyper_diving_line_search to -1 -Setting parameter mip_hyper_diving_pseudocost to -1 -Setting parameter mip_hyper_diving_guided to -1 -Setting parameter mip_hyper_diving_coefficient to -1 -Setting parameter mip_hyper_diving_farkas to -1 -Setting parameter mip_hyper_diving_vector_length to -1 -Setting parameter mip_hyper_diving_min_node_depth to 10 -Setting parameter mip_hyper_diving_node_limit to 500 -Setting parameter mip_hyper_diving_backtrack_limit to 5 -Setting parameter time_limit to 3.600000e+03 -Setting parameter time_limit to 3.600000e+03 -Setting parameter work_limit to 7.200000e+03 -Setting parameter absolute_dual_tolerance to 0.000000e+00 -Setting parameter relative_dual_tolerance to 0.000000e+00 -Setting parameter absolute_primal_tolerance to 0.000000e+00 -Setting parameter relative_primal_tolerance to 0.000000e+00 -Setting parameter absolute_gap_tolerance to 0.000000e+00 -Setting parameter relative_gap_tolerance to 0.000000e+00 -Setting parameter mip_absolute_tolerance to 0.000000e+00 -Setting parameter mip_relative_tolerance to 1.000000e-02 -Setting parameter mip_integrality_tolerance to 0.000000e+00 -Setting parameter mip_absolute_gap to 1.000000e-02 -Setting parameter mip_relative_gap to 2.000000e-04 -Setting parameter primal_infeasible_tolerance to 1.000000e-02 -Setting parameter dual_infeasible_tolerance to 1.000000e-02 -Setting parameter mip_cut_change_threshold to -5.000000e-01 -Setting parameter mip_cut_min_orthogonality to 0.000000e+00 -Setting parameter barrier_step_scale to 5.000000e-01 -Setting parameter mip_hyper_heuristic_presolve_time_ratio to 1.000000e-01 -Setting parameter mip_hyper_heuristic_presolve_max_time to 6.000000e+01 -Setting parameter mip_hyper_heuristic_root_lp_time_ratio to 1.000000e-01 -Setting parameter mip_hyper_heuristic_root_lp_max_time to 1.500000e+01 -Setting parameter mip_hyper_heuristic_rins_time_limit to 3.000000e+00 -Setting parameter mip_hyper_heuristic_rins_max_time_limit to 2.000000e+01 -Setting parameter mip_hyper_heuristic_rins_fix_rate to 5.000000e-01 -Setting parameter mip_hyper_heuristic_initial_infeasibility_weight to 1.000000e+03 -Setting parameter mip_hyper_heuristic_relaxed_lp_time_limit to 1.000000e+00 -Setting parameter mip_hyper_heuristic_related_vars_time_limit to 3.000000e+01 -Setting parameter mip_semi_continuous_big_m to 5.000000e+09 -Setting parameter mip_hyper_diving_iteration_limit_factor to 5.000000e-02 -Setting parameter infeasibility_detection to true -Setting parameter strict_infeasibility to true -Setting parameter per_constraint_residual to true -Setting parameter save_best_primal_so_far to true -Setting parameter first_primal_feasible to true -Setting parameter mip_heuristics_only to true -Setting parameter log_to_console to false -Setting parameter log_to_console to false -Setting parameter crossover to true -Setting parameter eliminate_dense_columns to false -Setting parameter cudss_deterministic to true -Setting parameter dual_postsolve to false -Setting parameter barrier_iterative_refinement to false -Setting parameter mip_probing to false -Setting parameter mip_hyper_diving_show_type to false -Setting parameter log_file to 1 -Setting parameter log_file to 1 -Setting parameter solution_file to -Setting parameter solution_file to -Setting parameter user_problem_file to -Setting parameter user_problem_file to -Setting parameter presolve_file to 1 -Setting parameter presolve_file to 1 -Parameters loaded from: /tmp/pytest-of-horde/pytest-0/test_solver_settings0/solver_settings_load.config -Setting parameter iteration_limit to 9999999 -Setting parameter node_limit to 2147483646 -Setting parameter pdlp_solver_mode to 3 -Setting parameter method to 2 -Setting parameter num_cpu_threads to 0 -Setting parameter augmented to 0 -Setting parameter folding to 0 -Setting parameter dualize to 0 -Setting parameter ordering to 0 -Setting parameter barrier_dual_initial_point to 0 -Setting parameter mip_cut_passes to 9 -Setting parameter mip_mixed_integer_rounding_cuts to 0 -Setting parameter mip_mixed_integer_gomory_cuts to 0 -Setting parameter mip_knapsack_cuts to 0 -Setting parameter mip_flow_cover_cuts to 0 -Setting parameter mip_clique_cuts to 0 -Setting parameter mip_implied_bound_cuts to 0 -Setting parameter mip_strong_chvatal_gomory_cuts to 0 -Setting parameter mip_reduced_cost_strengthening to 0 -Setting parameter mip_objective_step to 0 -Setting parameter num_gpus to 2 -Setting parameter mip_batch_pdlp_strong_branching to 1 -Setting parameter mip_batch_pdlp_reliability_branching to 1 -Setting parameter mip_strong_branching_simplex_iteration_limit to 0 -Setting parameter presolve to 1 -Setting parameter mip_determinism_mode to 1 -Setting parameter random_seed to 0 -Setting parameter mip_reliability_branching to 0 -Setting parameter pdlp_precision to 0 -Setting parameter mip_symmetry to 0 -Setting parameter mip_scaling to 1 -Setting parameter mip_hyper_heuristic_population_size to 32 -Setting parameter mip_hyper_heuristic_num_cpufj_threads to 8 -Setting parameter mip_hyper_heuristic_stagnation_trigger to 3 -Setting parameter mip_hyper_heuristic_max_iterations_without_improvement to 8 -Setting parameter mip_hyper_heuristic_n_of_minimums_for_exit to 7000 -Setting parameter mip_hyper_heuristic_enabled_recombiners to 15 -Setting parameter mip_hyper_heuristic_cycle_detection_length to 30 -Setting parameter mip_hyper_diving_line_search to -1 -Setting parameter mip_hyper_diving_pseudocost to -1 -Setting parameter mip_hyper_diving_guided to -1 -Setting parameter mip_hyper_diving_coefficient to -1 -Setting parameter mip_hyper_diving_farkas to -1 -Setting parameter mip_hyper_diving_vector_length to -1 -Setting parameter mip_hyper_diving_min_node_depth to 10 -Setting parameter mip_hyper_diving_node_limit to 500 -Setting parameter mip_hyper_diving_backtrack_limit to 5 -Setting parameter time_limit to 3.600000e+03 -Setting parameter work_limit to 7.200000e+03 -Setting parameter absolute_dual_tolerance to 0.000000e+00 -Setting parameter relative_dual_tolerance to 0.000000e+00 -Setting parameter absolute_primal_tolerance to 0.000000e+00 -Setting parameter relative_primal_tolerance to 0.000000e+00 -Setting parameter absolute_gap_tolerance to 0.000000e+00 -Setting parameter relative_gap_tolerance to 0.000000e+00 -Setting parameter mip_absolute_tolerance to 0.000000e+00 -Setting parameter mip_relative_tolerance to 1.000000e-02 -Setting parameter mip_integrality_tolerance to 0.000000e+00 -Setting parameter mip_absolute_gap to 1.000000e-02 -Setting parameter mip_relative_gap to 2.000000e-04 -Setting parameter primal_infeasible_tolerance to 1.000000e-02 -Setting parameter dual_infeasible_tolerance to 1.000000e-02 -Setting parameter mip_cut_change_threshold to -5.000000e-01 -Setting parameter mip_cut_min_orthogonality to 0.000000e+00 -Setting parameter barrier_step_scale to 5.000000e-01 -Setting parameter mip_hyper_heuristic_presolve_time_ratio to 1.000000e-01 -Setting parameter mip_hyper_heuristic_presolve_max_time to 6.000000e+01 -Setting parameter mip_hyper_heuristic_root_lp_time_ratio to 1.000000e-01 -Setting parameter mip_hyper_heuristic_root_lp_max_time to 1.500000e+01 -Setting parameter mip_hyper_heuristic_rins_time_limit to 3.000000e+00 -Setting parameter mip_hyper_heuristic_rins_max_time_limit to 2.000000e+01 -Setting parameter mip_hyper_heuristic_rins_fix_rate to 5.000000e-01 -Setting parameter mip_hyper_heuristic_initial_infeasibility_weight to 1.000000e+03 -Setting parameter mip_hyper_heuristic_relaxed_lp_time_limit to 1.000000e+00 -Setting parameter mip_hyper_heuristic_related_vars_time_limit to 3.000000e+01 -Setting parameter mip_semi_continuous_big_m to 5.000000e+09 -Setting parameter mip_hyper_diving_iteration_limit_factor to 5.000000e-02 -Setting parameter infeasibility_detection to true -Setting parameter strict_infeasibility to true -Setting parameter per_constraint_residual to true -Setting parameter save_best_primal_so_far to true -Setting parameter first_primal_feasible to true -Setting parameter mip_heuristics_only to true -Setting parameter log_to_console to false -Setting parameter crossover to true -Setting parameter eliminate_dense_columns to false -Setting parameter cudss_deterministic to true -Setting parameter dual_postsolve to false -Setting parameter barrier_iterative_refinement to false -Setting parameter mip_probing to false -Setting parameter mip_hyper_diving_show_type to false -Setting parameter log_file to 1 -Setting parameter solution_file to -Setting parameter user_problem_file to -Setting parameter presolve_file to 1 -Setting parameter iteration_limit to 9999999 -Setting parameter node_limit to 2147483646 -Setting parameter pdlp_solver_mode to 3 -Setting parameter method to 2 -Setting parameter num_cpu_threads to 0 -Setting parameter augmented to 0 -Setting parameter folding to 0 -Setting parameter dualize to 0 -Setting parameter ordering to 0 -Setting parameter barrier_dual_initial_point to 0 -Setting parameter mip_cut_passes to 9 -Setting parameter mip_mixed_integer_rounding_cuts to 0 -Setting parameter mip_mixed_integer_gomory_cuts to 0 -Setting parameter mip_knapsack_cuts to 0 -Setting parameter mip_flow_cover_cuts to 0 -Setting parameter mip_clique_cuts to 0 -Setting parameter mip_implied_bound_cuts to 0 -Setting parameter mip_strong_chvatal_gomory_cuts to 0 -Setting parameter mip_reduced_cost_strengthening to 0 -Setting parameter mip_objective_step to 0 -Setting parameter num_gpus to 2 -Setting parameter mip_batch_pdlp_strong_branching to 1 -Setting parameter mip_batch_pdlp_reliability_branching to 1 -Setting parameter mip_strong_branching_simplex_iteration_limit to 0 -Setting parameter presolve to 1 -Setting parameter mip_determinism_mode to 1 -Setting parameter random_seed to 0 -Setting parameter mip_reliability_branching to 0 -Setting parameter pdlp_precision to 0 -Setting parameter mip_symmetry to 0 -Setting parameter mip_scaling to 1 -Setting parameter mip_hyper_heuristic_population_size to 32 -Setting parameter mip_hyper_heuristic_num_cpufj_threads to 8 -Setting parameter mip_hyper_heuristic_stagnation_trigger to 3 -Setting parameter mip_hyper_heuristic_max_iterations_without_improvement to 8 -Setting parameter mip_hyper_heuristic_n_of_minimums_for_exit to 7000 -Setting parameter mip_hyper_heuristic_enabled_recombiners to 15 -Setting parameter mip_hyper_heuristic_cycle_detection_length to 30 -Setting parameter mip_hyper_diving_line_search to -1 -Setting parameter mip_hyper_diving_pseudocost to -1 -Setting parameter mip_hyper_diving_guided to -1 -Setting parameter mip_hyper_diving_coefficient to -1 -Setting parameter mip_hyper_diving_farkas to -1 -Setting parameter mip_hyper_diving_vector_length to -1 -Setting parameter mip_hyper_diving_min_node_depth to 10 -Setting parameter mip_hyper_diving_node_limit to 500 -Setting parameter mip_hyper_diving_backtrack_limit to 5 -Setting parameter time_limit to 3.600000e+03 -Setting parameter work_limit to 7.200000e+03 -Setting parameter absolute_dual_tolerance to 0.000000e+00 -Setting parameter relative_dual_tolerance to 0.000000e+00 -Setting parameter absolute_primal_tolerance to 0.000000e+00 -Setting parameter relative_primal_tolerance to 0.000000e+00 -Setting parameter absolute_gap_tolerance to 0.000000e+00 -Setting parameter relative_gap_tolerance to 0.000000e+00 -Setting parameter mip_absolute_tolerance to 0.000000e+00 -Setting parameter mip_relative_tolerance to 1.000000e-02 -Setting parameter mip_integrality_tolerance to 0.000000e+00 -Setting parameter mip_absolute_gap to 1.000000e-02 -Setting parameter mip_relative_gap to 2.000000e-04 -Setting parameter primal_infeasible_tolerance to 1.000000e-02 -Setting parameter dual_infeasible_tolerance to 1.000000e-02 -Setting parameter mip_cut_change_threshold to -5.000000e-01 -Setting parameter mip_cut_min_orthogonality to 0.000000e+00 -Setting parameter barrier_step_scale to 5.000000e-01 -Setting parameter mip_hyper_heuristic_presolve_time_ratio to 1.000000e-01 -Setting parameter mip_hyper_heuristic_presolve_max_time to 6.000000e+01 -Setting parameter mip_hyper_heuristic_root_lp_time_ratio to 1.000000e-01 -Setting parameter mip_hyper_heuristic_root_lp_max_time to 1.500000e+01 -Setting parameter mip_hyper_heuristic_rins_time_limit to 3.000000e+00 -Setting parameter mip_hyper_heuristic_rins_max_time_limit to 2.000000e+01 -Setting parameter mip_hyper_heuristic_rins_fix_rate to 5.000000e-01 -Setting parameter mip_hyper_heuristic_initial_infeasibility_weight to 1.000000e+03 -Setting parameter mip_hyper_heuristic_relaxed_lp_time_limit to 1.000000e+00 -Setting parameter mip_hyper_heuristic_related_vars_time_limit to 3.000000e+01 -Setting parameter mip_semi_continuous_big_m to 5.000000e+09 -Setting parameter mip_hyper_diving_iteration_limit_factor to 5.000000e-02 -Setting parameter infeasibility_detection to true -Setting parameter strict_infeasibility to true -Setting parameter per_constraint_residual to true -Setting parameter save_best_primal_so_far to true -Setting parameter first_primal_feasible to true -Setting parameter mip_heuristics_only to true -Setting parameter log_to_console to false -Setting parameter crossover to true -Setting parameter eliminate_dense_columns to false -Setting parameter cudss_deterministic to true -Setting parameter dual_postsolve to false -Setting parameter barrier_iterative_refinement to false -Setting parameter mip_probing to false -Setting parameter mip_hyper_diving_show_type to false -Setting parameter log_file to 1 -Setting parameter solution_file to -Setting parameter user_problem_file to -Setting parameter presolve_file to 1 -cuOpt version: 26.8.0, git hash: 03fe3fc4, host arch: x86_64, device archs: 89-real -CPU: Intel(R) Xeon(R) Platinum 8362 CPU @ 2.80GHz, threads (physical/logical): 64/128, RAM: 890.33 GiB -CUDA 12.9, device: NVIDIA L40 (ID 0), VRAM: 47.38 GiB -CUDA device UUID: ce15376b-c11d-6252-d099-c87a5667ce97 - -Solving a problem with 2 constraints, 1 variables (0 integers), and 2 nonzeros -Problem scaling: -Objective coefficents range: [1e+00, 1e+00] -Constraint matrix coefficients range: [1e+00, 1e+00] -Constraint rhs / bounds range: [0e+00, 1e+00] -Variable bounds range: [0e+00, 0e+00] - -Original problem: 2 constraints, 1 variables, 2 nonzeros -Calling Papilo presolver (git hash 741a2b9c) -Presolve status: reduced the problem -Presolve removed: 2 constraints, 1 variables, 2 nonzeros -Presolved problem: 0 constraints, 0 variables (0 integer), 0 nonzeros -Optimal solution found during presolve -Presolve completely solved the problem -Papilo presolve time: 0.00s -Status: Optimal Objective: 0.000000 diff --git a/best_results.txt b/best_results.txt deleted file mode 100644 index e69de29bb2..0000000000 From 7e85ff290cb42973727abb2bcb625e526c6af849 Mon Sep 17 00:00:00 2001 From: Miles Lubin Date: Sat, 20 Jun 2026 22:48:15 +0000 Subject: [PATCH 05/17] refactor: consolidate MIP into cuopt::math_optimization::mip Branch-and-bound, cuts, and heuristics were split across ::dual_simplex and ::detail; unify them in one ::mip namespace. The shared problem_t representation (used by pdlp/barrier too) moves to ::mip as well. Co-Authored-By: Claude Opus 4.8 (1M context) Signed-off-by: Miles Lubin --- cpp/src/branch_and_bound/bb_event.hpp | 4 +- cpp/src/branch_and_bound/branch_and_bound.cpp | 63 +++++++------- cpp/src/branch_and_bound/branch_and_bound.hpp | 28 +++--- cpp/src/branch_and_bound/constants.hpp | 4 +- .../deterministic_workers.hpp | 7 +- .../branch_and_bound/diving_heuristics.cpp | 7 +- .../branch_and_bound/diving_heuristics.hpp | 7 +- cpp/src/branch_and_bound/mip_node.hpp | 7 +- cpp/src/branch_and_bound/node_queue.hpp | 7 +- cpp/src/branch_and_bound/pseudo_costs.cpp | 7 +- cpp/src/branch_and_bound/pseudo_costs.hpp | 7 +- .../shared_strong_branching_context.hpp | 4 +- cpp/src/branch_and_bound/symmetry.hpp | 7 +- cpp/src/branch_and_bound/worker.hpp | 7 +- cpp/src/branch_and_bound/worker_pool.hpp | 7 +- cpp/src/cuts/cuts.cpp | 9 +- cpp/src/cuts/cuts.hpp | 15 ++-- cpp/src/cuts/objective_step.cpp | 7 +- cpp/src/cuts/objective_step.hpp | 7 +- cpp/src/cuts/rational.hpp | 4 +- cpp/src/dual_simplex/solve.cpp | 16 ++-- .../diversity/assignment_hash_map.cu | 4 +- .../diversity/assignment_hash_map.cuh | 4 +- .../diversity/diversity_config.hpp | 4 +- .../diversity/diversity_manager.cu | 4 +- .../diversity/diversity_manager.cuh | 6 +- cpp/src/mip_heuristics/diversity/lns/rins.cu | 16 ++-- cpp/src/mip_heuristics/diversity/lns/rins.cuh | 4 +- .../diversity/multi_armed_bandit.cu | 4 +- .../diversity/multi_armed_bandit.cuh | 4 +- .../mip_heuristics/diversity/population.cu | 8 +- .../mip_heuristics/diversity/population.cuh | 4 +- .../recombiners/bound_prop_recombiner.cuh | 4 +- .../diversity/recombiners/fp_recombiner.cuh | 4 +- .../recombiners/line_segment_recombiner.cuh | 4 +- .../diversity/recombiners/recombiner.cuh | 4 +- .../recombiners/recombiner_configs.hpp | 4 +- .../recombiners/recombiner_stats.hpp | 4 +- .../diversity/recombiners/sub_mip.cuh | 15 ++-- cpp/src/mip_heuristics/diversity/weights.cuh | 4 +- cpp/src/mip_heuristics/early_heuristic.cuh | 4 +- .../feasibility_jump/cpu_fj_thread.cuh | 4 +- .../feasibility_jump/early_cpufj.cu | 4 +- .../feasibility_jump/early_cpufj.cuh | 4 +- .../feasibility_jump/early_gpufj.cu | 4 +- .../feasibility_jump/early_gpufj.cuh | 4 +- .../feasibility_jump/feasibility_jump.cu | 4 +- .../feasibility_jump/feasibility_jump.cuh | 4 +- .../feasibility_jump_impl_common.cuh | 4 +- .../feasibility_jump_kernels.cu | 26 +++--- .../feasibility_jump_kernels.cuh | 4 +- .../mip_heuristics/feasibility_jump/fj_cpu.cu | 4 +- .../feasibility_jump/fj_cpu.cuh | 4 +- .../mip_heuristics/feasibility_jump/utils.cuh | 4 +- .../feasibility_pump/feasibility_pump.cu | 4 +- .../feasibility_pump/feasibility_pump.cuh | 4 +- .../local_search/lagrangian.cuh | 4 +- .../line_segment_search.cu | 4 +- .../line_segment_search.cuh | 4 +- .../local_search/local_search.cu | 7 +- .../local_search/local_search.cuh | 6 +- .../local_search/local_search_config.hpp | 4 +- .../local_search/rounding/bounds_repair.cu | 4 +- .../local_search/rounding/bounds_repair.cuh | 4 +- .../local_search/rounding/constraint_prop.cu | 4 +- .../local_search/rounding/constraint_prop.cuh | 4 +- .../local_search/rounding/lb_bounds_repair.cu | 4 +- .../rounding/lb_bounds_repair.cuh | 4 +- .../rounding/lb_constraint_prop.cu | 4 +- .../rounding/lb_constraint_prop.cuh | 4 +- .../local_search/rounding/simple_rounding.cu | 4 +- .../local_search/rounding/simple_rounding.cuh | 4 +- .../rounding/simple_rounding_kernels.cuh | 4 +- cpp/src/mip_heuristics/logger.cuh | 4 +- .../mip_heuristics/mip_scaling_strategy.cu | 4 +- .../mip_heuristics/mip_scaling_strategy.cuh | 4 +- .../presolve/bounds_presolve.cu | 4 +- .../presolve/bounds_presolve.cuh | 4 +- .../presolve/bounds_presolve_helpers.cuh | 4 +- .../presolve/bounds_update_data.cu | 4 +- .../presolve/bounds_update_data.cuh | 4 +- .../presolve/bounds_update_helpers.cuh | 4 +- .../conditional_bound_strengthening.cu | 4 +- .../conditional_bound_strengthening.cuh | 4 +- .../presolve/conflict_graph/clique_table.cu | 4 +- .../presolve/conflict_graph/clique_table.cuh | 4 +- .../mip_heuristics/presolve/gf2_presolve.cpp | 4 +- .../mip_heuristics/presolve/gf2_presolve.hpp | 4 +- .../presolve/lb_probing_cache.cu | 4 +- .../presolve/load_balanced_bounds_presolve.cu | 4 +- .../load_balanced_bounds_presolve.cuh | 4 +- .../load_balanced_bounds_presolve_helpers.cuh | 4 +- .../load_balanced_bounds_presolve_kernels.cuh | 4 +- .../load_balanced_partition_helpers.cuh | 4 +- .../mip_heuristics/presolve/multi_probe.cu | 4 +- .../mip_heuristics/presolve/multi_probe.cuh | 4 +- .../mip_heuristics/presolve/probing_cache.cu | 4 +- .../mip_heuristics/presolve/probing_cache.cuh | 4 +- .../presolve/semi_continuous.cu | 4 +- .../presolve/semi_continuous.cuh | 4 +- .../presolve/third_party_presolve.cpp | 6 +- .../presolve/third_party_presolve.hpp | 4 +- .../presolve/trivial_presolve.cu | 4 +- .../presolve/trivial_presolve.cuh | 4 +- .../presolve/trivial_presolve_helpers.cuh | 4 +- cpp/src/mip_heuristics/presolve/utils.cuh | 4 +- .../mip_heuristics/problem/host_helper.cuh | 4 +- .../problem/load_balanced_problem.cu | 4 +- .../problem/load_balanced_problem.cuh | 4 +- .../mip_heuristics/problem/presolve_data.cu | 13 ++- .../mip_heuristics/problem/presolve_data.cuh | 4 +- cpp/src/mip_heuristics/problem/problem.cu | 38 ++++---- cpp/src/mip_heuristics/problem/problem.cuh | 4 +- .../mip_heuristics/problem/problem_fixing.cuh | 4 +- .../problem/problem_helpers.cuh | 22 ++--- .../problem/problem_kernels.cuh | 4 +- cpp/src/mip_heuristics/problem/write_mps.cu | 4 +- .../mip_heuristics/relaxed_lp/lp_state.cuh | 4 +- .../mip_heuristics/relaxed_lp/relaxed_lp.cu | 4 +- .../mip_heuristics/relaxed_lp/relaxed_lp.cuh | 4 +- .../solution/feasibility_test.cuh | 4 +- cpp/src/mip_heuristics/solution/solution.cu | 36 ++++---- cpp/src/mip_heuristics/solution/solution.cuh | 10 +-- .../solution/solution_kernels.cuh | 4 +- cpp/src/mip_heuristics/solve.cu | 81 +++++++++-------- cpp/src/mip_heuristics/solver.cu | 38 ++++---- cpp/src/mip_heuristics/solver.cuh | 4 +- cpp/src/mip_heuristics/solver_context.cuh | 10 +-- cpp/src/mip_heuristics/utilities/sort_csr.cuh | 4 +- cpp/src/mip_heuristics/utils.cuh | 8 +- cpp/src/pdlp/cusparse_view.cu | 8 +- cpp/src/pdlp/cusparse_view.hpp | 9 +- .../initial_scaling.cu | 23 +++-- .../initial_scaling.cuh | 8 +- .../optimal_batch_size_handler.cu | 2 +- cpp/src/pdlp/pdhg.cu | 2 +- cpp/src/pdlp/pdhg.hpp | 4 +- cpp/src/pdlp/pdlp.cu | 2 +- cpp/src/pdlp/pdlp.cuh | 13 ++- .../restart_strategy/pdlp_restart_strategy.cu | 14 +-- .../pdlp_restart_strategy.cuh | 4 +- cpp/src/pdlp/solve.cu | 40 ++++----- cpp/src/pdlp/solve.cuh | 6 +- .../convergence_information.cu | 2 +- .../convergence_information.hpp | 4 +- .../infeasibility_information.cu | 4 +- .../infeasibility_information.hpp | 8 +- .../termination_strategy.cu | 4 +- .../termination_strategy.hpp | 6 +- cpp/src/pdlp/translate.hpp | 4 +- cpp/src/pdlp/utilities/problem_checking.cu | 4 +- cpp/src/pdlp/utilities/problem_checking.cuh | 10 +-- cpp/src/pdlp/utils.cuh | 2 +- cpp/tests/linear_programming/pdlp_test.cu | 16 ++-- cpp/tests/mip/bounds_standardization_test.cu | 12 +-- cpp/tests/mip/cuts_test.cu | 87 +++++++++---------- cpp/tests/mip/elim_var_remap_test.cu | 24 ++--- cpp/tests/mip/feasibility_jump_tests.cu | 26 +++--- cpp/tests/mip/load_balancing_test.cu | 20 ++--- cpp/tests/mip/multi_probe_test.cu | 22 ++--- cpp/tests/mip/presolve_test.cu | 10 +-- cpp/tests/mip/problem_test.cu | 12 +-- cpp/tests/mip/unit_test.cu | 4 +- 163 files changed, 700 insertions(+), 661 deletions(-) diff --git a/cpp/src/branch_and_bound/bb_event.hpp b/cpp/src/branch_and_bound/bb_event.hpp index fc981699e3..c9d5b65ffa 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::math_optimization::dual_simplex { +namespace cuopt::math_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::math_optimization::dual_simplex +} // namespace cuopt::math_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 e4d1352fe7..55ff8d2043 100644 --- a/cpp/src/branch_and_bound/branch_and_bound.cpp +++ b/cpp/src/branch_and_bound/branch_and_bound.cpp @@ -44,7 +44,10 @@ #include #include -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_optimization::mip { + +using namespace cuopt::math_optimization::dual_simplex; // shared simplex types (lp_problem_t, + // etc.) namespace { template @@ -223,7 +226,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), @@ -655,8 +658,8 @@ void branch_and_bound_t::repair_heuristic_solutions() } template -void branch_and_bound_t::set_solution_at_root(mip_solution_t& solution, - const cut_info_t& cut_info) +void branch_and_bound_t::set_solution_at_root( + dual_simplex::mip_solution_t& solution, const cut_info_t& cut_info) { mutex_upper_.lock(); incumbent_.set_incumbent_solution(root_objective_, root_relax_soln_.x); @@ -684,8 +687,8 @@ void branch_and_bound_t::set_solution_at_root(mip_solution_t } template -void branch_and_bound_t::set_final_solution(mip_solution_t& solution, - f_t lower_bound) +void branch_and_bound_t::set_final_solution( + dual_simplex::mip_solution_t& solution, f_t lower_bound) { if (solver_status_ == mip_status_t::NUMERICAL) { settings_.log.printf("Numerical issue encountered. Stopping the solver...\n"); @@ -2153,7 +2156,7 @@ lp_status_t branch_and_bound_t::solve_root_relaxation( template auto branch_and_bound_t::do_cut_pass( [[maybe_unused]] i_t cut_pass, - mip_solution_t& solution, + dual_simplex::mip_solution_t& solution, i_t& num_fractional, std::vector& fractional, cut_generation_t& cut_generation, @@ -2433,7 +2436,7 @@ auto branch_and_bound_t::do_cut_pass( } template -mip_status_t branch_and_bound_t::solve(mip_solution_t& solution) +mip_status_t branch_and_bound_t::solve(dual_simplex::mip_solution_t& solution) { raft::common::nvtx::range scope("BB::solve"); @@ -2491,7 +2494,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); } } @@ -2652,7 +2655,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 +2673,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 +2702,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 +2727,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 +2745,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 +2787,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 +2801,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(); } @@ -4188,4 +4191,4 @@ template class branch_and_bound_t; #endif -} // namespace cuopt::math_optimization::dual_simplex +} // namespace cuopt::math_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 c18a109ba7..4de3707ad3 100644 --- a/cpp/src/branch_and_bound/branch_and_bound.hpp +++ b/cpp/src/branch_and_bound/branch_and_bound.hpp @@ -40,12 +40,15 @@ #include #include -namespace cuopt::math_optimization::detail { +namespace cuopt::math_optimization::mip { template struct clique_table_t; } -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_optimization::mip { + +using namespace cuopt::math_optimization::dual_simplex; // shared simplex types (lp_problem_t, + // etc.) template struct mip_symmetry_t; @@ -61,9 +64,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); @@ -83,8 +83,8 @@ class 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 = 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; } @@ -154,7 +154,7 @@ class branch_and_bound_t { 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(dual_simplex::mip_solution_t& solution); work_limit_context_t& get_work_unit_context() { return work_unit_context_; } @@ -165,7 +165,7 @@ class branch_and_bound_t { const user_problem_t& original_problem_; const 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_; @@ -202,7 +202,7 @@ class branch_and_bound_t { omp_atomic_t upper_bound_; // Solver-space incumbent tracked directly by B&B. - mip_solution_t incumbent_; + dual_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 @@ -278,7 +278,7 @@ class branch_and_bound_t { }; cut_pass_result_t do_cut_pass(i_t cut_pass, - mip_solution_t& solution, + dual_simplex::mip_solution_t& solution, i_t& num_fractional, std::vector& fractional, cut_generation_t& cut_generation, @@ -297,12 +297,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(dual_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(dual_simplex::mip_solution_t& solution, f_t lower_bound); // Update the incumbent solution with the new feasible solution // found during branch and bound. @@ -477,4 +477,4 @@ class branch_and_bound_t { heap_t diving_heap_; }; -} // namespace cuopt::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::mip diff --git a/cpp/src/branch_and_bound/constants.hpp b/cpp/src/branch_and_bound/constants.hpp index aaf607b047..b91968dd85 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::math_optimization::dual_simplex { +namespace cuopt::math_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::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::mip diff --git a/cpp/src/branch_and_bound/deterministic_workers.hpp b/cpp/src/branch_and_bound/deterministic_workers.hpp index 5e933d2ed8..0fa531cba7 100644 --- a/cpp/src/branch_and_bound/deterministic_workers.hpp +++ b/cpp/src/branch_and_bound/deterministic_workers.hpp @@ -22,7 +22,10 @@ #include #include -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_optimization::mip { + +using namespace cuopt::math_optimization::dual_simplex; // shared simplex types (lp_problem_t, + // etc.) template struct backlog_node_compare_t { @@ -455,4 +458,4 @@ class deterministic_diving_worker_pool_t } }; -} // namespace cuopt::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::mip diff --git a/cpp/src/branch_and_bound/diving_heuristics.cpp b/cpp/src/branch_and_bound/diving_heuristics.cpp index b4e760f431..6c2f927379 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::math_optimization::dual_simplex { +namespace cuopt::math_optimization::mip { + +using namespace cuopt::math_optimization::dual_simplex; // shared simplex types (lp_problem_t, + // etc.) template branch_variable_t line_search_diving(const std::vector& fractional, @@ -407,4 +410,4 @@ template branch_variable_t vector_length_diving(const lp_problem_t -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_optimization::mip { + +using namespace cuopt::math_optimization::dual_simplex; // shared simplex types (lp_problem_t, + // etc.) // When `log_diving_type` is true, each diving strategy gets its own letter; // otherwise every dive collapses to 'D'. @@ -100,4 +103,4 @@ branch_variable_t vector_length_diving(const lp_problem_t& lp, const std::vector& solution, logger_t& log); -} // namespace cuopt::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::mip diff --git a/cpp/src/branch_and_bound/mip_node.hpp b/cpp/src/branch_and_bound/mip_node.hpp index 0daee7150d..f6772e1840 100644 --- a/cpp/src/branch_and_bound/mip_node.hpp +++ b/cpp/src/branch_and_bound/mip_node.hpp @@ -21,7 +21,10 @@ #include #include -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_optimization::mip { + +using namespace cuopt::math_optimization::dual_simplex; // shared simplex types (lp_problem_t, + // etc.) enum class node_status_t : int { PENDING = 0, // Node is still in the tree, waiting to be solved @@ -459,4 +462,4 @@ class search_tree_t { static constexpr bool write_graphviz = false; }; -} // namespace cuopt::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::mip diff --git a/cpp/src/branch_and_bound/node_queue.hpp b/cpp/src/branch_and_bound/node_queue.hpp index ee4d0694f9..0e3df23207 100644 --- a/cpp/src/branch_and_bound/node_queue.hpp +++ b/cpp/src/branch_and_bound/node_queue.hpp @@ -13,7 +13,10 @@ #include #include -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_optimization::mip { + +using namespace cuopt::math_optimization::dual_simplex; // shared simplex types (lp_problem_t, + // etc.) // This is a generic heap implementation based // on the STL functions. The main benefit here is @@ -209,4 +212,4 @@ class node_queue_t { omp_atomic_t lower_bound_{std::numeric_limits::infinity()}; }; -} // namespace cuopt::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::mip diff --git a/cpp/src/branch_and_bound/pseudo_costs.cpp b/cpp/src/branch_and_bound/pseudo_costs.cpp index d87173df05..9f98d008af 100644 --- a/cpp/src/branch_and_bound/pseudo_costs.cpp +++ b/cpp/src/branch_and_bound/pseudo_costs.cpp @@ -25,7 +25,10 @@ #include -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_optimization::mip { + +using namespace cuopt::math_optimization::dual_simplex; // shared simplex types (lp_problem_t, + // etc.) namespace { static bool is_dual_simplex_done(dual::status_t status) @@ -1994,4 +1997,4 @@ template void strong_branching(const lp_problem_t& ori #endif -} // namespace cuopt::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::mip diff --git a/cpp/src/branch_and_bound/pseudo_costs.hpp b/cpp/src/branch_and_bound/pseudo_costs.hpp index 2e86c982ac..2c4293c2f7 100644 --- a/cpp/src/branch_and_bound/pseudo_costs.hpp +++ b/cpp/src/branch_and_bound/pseudo_costs.hpp @@ -24,7 +24,10 @@ #include #include -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_optimization::mip { + +using namespace cuopt::math_optimization::dual_simplex; // shared simplex types (lp_problem_t, + // etc.) template struct mip_symmetry_t; @@ -290,4 +293,4 @@ void strong_branching(const lp_problem_t& original_lp, mip_symmetry_t* symmetry, pseudo_costs_t& pc); -} // namespace cuopt::math_optimization::dual_simplex +} // namespace cuopt::math_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 6dea27128d..0c786358bc 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::math_optimization::dual_simplex { +namespace cuopt::math_optimization::mip { template struct shared_strong_branching_context_t { @@ -57,4 +57,4 @@ struct shared_strong_branching_context_view_t { } }; -} // namespace cuopt::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::mip diff --git a/cpp/src/branch_and_bound/symmetry.hpp b/cpp/src/branch_and_bound/symmetry.hpp index 9a9df275da..814f77e8b4 100644 --- a/cpp/src/branch_and_bound/symmetry.hpp +++ b/cpp/src/branch_and_bound/symmetry.hpp @@ -20,7 +20,10 @@ #include #include -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_optimization::mip { + +using namespace cuopt::math_optimization::dual_simplex; // shared simplex types (lp_problem_t, + // etc.) // permutation_t stores a dense permutation plus its support (non-identity entries). template @@ -1138,4 +1141,4 @@ std::unique_ptr> detect_symmetry( return result; } -} // namespace cuopt::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::mip diff --git a/cpp/src/branch_and_bound/worker.hpp b/cpp/src/branch_and_bound/worker.hpp index 7c84b0fc2e..a217bfa620 100644 --- a/cpp/src/branch_and_bound/worker.hpp +++ b/cpp/src/branch_and_bound/worker.hpp @@ -20,7 +20,10 @@ #include -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_optimization::mip { + +using namespace cuopt::math_optimization::dual_simplex; // shared simplex types (lp_problem_t, + // etc.) template struct branch_and_bound_stats_t { @@ -256,4 +259,4 @@ class diving_worker_t : public branch_and_bound_worker_t { bfs_worker_t* bfs_worker{nullptr}; }; -} // namespace cuopt::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::mip diff --git a/cpp/src/branch_and_bound/worker_pool.hpp b/cpp/src/branch_and_bound/worker_pool.hpp index 4073fc07c0..bcf9af5f02 100644 --- a/cpp/src/branch_and_bound/worker_pool.hpp +++ b/cpp/src/branch_and_bound/worker_pool.hpp @@ -10,7 +10,10 @@ #include #include -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_optimization::mip { + +using namespace cuopt::math_optimization::dual_simplex; // shared simplex types (lp_problem_t, + // etc.) template class worker_pool_t { @@ -106,4 +109,4 @@ using bfs_worker_pool_t = worker_pool_t>; template using diving_worker_pool_t = worker_pool_t>; -} // namespace cuopt::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::mip diff --git a/cpp/src/cuts/cuts.cpp b/cpp/src/cuts/cuts.cpp index 1f392893d0..de5161b8a4 100644 --- a/cpp/src/cuts/cuts.cpp +++ b/cpp/src/cuts/cuts.cpp @@ -27,7 +27,10 @@ #include #include -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_optimization::mip { + +using namespace cuopt::math_optimization::dual_simplex; // shared simplex types (lp_problem_t, + // etc.) namespace { @@ -354,7 +357,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, @@ -5599,4 +5602,4 @@ template void verify_cuts_against_saved_solution( const std::vector& saved_solution); #endif -} // namespace cuopt::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::mip diff --git a/cpp/src/cuts/cuts.hpp b/cpp/src/cuts/cuts.hpp index 5ca35d3ed0..9241895082 100644 --- a/cpp/src/cuts/cuts.hpp +++ b/cpp/src/cuts/cuts.hpp @@ -27,12 +27,15 @@ #include #include -namespace cuopt::math_optimization::detail { +namespace cuopt::math_optimization::mip { template struct clique_table_t; } -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_optimization::mip { + +using namespace cuopt::math_optimization::dual_simplex; // shared simplex types (lp_problem_t, + // etc.) enum cut_type_t : int8_t { MIXED_INTEGER_GOMORY = 0, @@ -592,8 +595,8 @@ class cut_generation_t { const std::vector& var_types, const 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), @@ -678,7 +681,7 @@ class cut_generation_t { flow_cover_generation_t flow_cover_generation_; const 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}; }; @@ -1069,4 +1072,4 @@ i_t remove_cuts(lp_problem_t& lp, std::vector& nonbasic_list, basis_update_mpf_t& basis_update); -} // namespace cuopt::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::mip diff --git a/cpp/src/cuts/objective_step.cpp b/cpp/src/cuts/objective_step.cpp index a588c1912e..c966862f30 100644 --- a/cpp/src/cuts/objective_step.cpp +++ b/cpp/src/cuts/objective_step.cpp @@ -14,7 +14,10 @@ #include #include -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_optimization::mip { + +using namespace cuopt::math_optimization::dual_simplex; // shared simplex types (objective_step_t, + // etc.) namespace { @@ -408,4 +411,4 @@ template objective_step_t compute_objective_step_info(const s const std::vector&, const std::vector&); -} // namespace cuopt::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::mip diff --git a/cpp/src/cuts/objective_step.hpp b/cpp/src/cuts/objective_step.hpp index df4599209c..3dbed08d95 100644 --- a/cpp/src/cuts/objective_step.hpp +++ b/cpp/src/cuts/objective_step.hpp @@ -12,7 +12,10 @@ #include #include -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_optimization::mip { + +using namespace cuopt::math_optimization::dual_simplex; // shared simplex types (objective_step_t, + // etc.) // 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 @@ -52,4 +55,4 @@ bool propagate_lattice(i_t n_vars, const std::vector& obj_coefs, std::vector& lattice_step); -} // namespace cuopt::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::mip diff --git a/cpp/src/cuts/rational.hpp b/cpp/src/cuts/rational.hpp index f6ab4755b7..1d83276af8 100644 --- a/cpp/src/cuts/rational.hpp +++ b/cpp/src/cuts/rational.hpp @@ -13,7 +13,7 @@ #include #include -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_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::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::mip diff --git a/cpp/src/dual_simplex/solve.cpp b/cpp/src/dual_simplex/solve.cpp index cae0a78518..c1cd83ec2c 100644 --- a/cpp/src/dual_simplex/solve.cpp +++ b/cpp/src/dual_simplex/solve.cpp @@ -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; diff --git a/cpp/src/mip_heuristics/diversity/assignment_hash_map.cu b/cpp/src/mip_heuristics/diversity/assignment_hash_map.cu index b8413e32dd..6d5f0548f0 100644 --- a/cpp/src/mip_heuristics/diversity/assignment_hash_map.cu +++ b/cpp/src/mip_heuristics/diversity/assignment_hash_map.cu @@ -16,7 +16,7 @@ namespace cuopt { namespace math_optimization { -namespace detail { +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 mip } // namespace math_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 387efad383..0c62fe1745 100644 --- a/cpp/src/mip_heuristics/diversity/assignment_hash_map.cuh +++ b/cpp/src/mip_heuristics/diversity/assignment_hash_map.cuh @@ -11,7 +11,7 @@ namespace cuopt { namespace math_optimization { -namespace detail { +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 mip } // namespace math_optimization } // namespace cuopt diff --git a/cpp/src/mip_heuristics/diversity/diversity_config.hpp b/cpp/src/mip_heuristics/diversity/diversity_config.hpp index 0e3ac58a9d..1a9ea8d3ce 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::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_optimization::mip diff --git a/cpp/src/mip_heuristics/diversity/diversity_manager.cu b/cpp/src/mip_heuristics/diversity/diversity_manager.cu index 4b31adef05..ea061cc635 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::math_optimization::detail { +namespace cuopt::math_optimization::mip { size_t fp_recombiner_config_t::max_n_of_vars_from_other = fp_recombiner_config_t::initial_n_of_vars_from_other; @@ -966,4 +966,4 @@ template class diversity_manager_t; template class diversity_manager_t; #endif -} // namespace cuopt::math_optimization::detail +} // namespace cuopt::math_optimization::mip diff --git a/cpp/src/mip_heuristics/diversity/diversity_manager.cuh b/cpp/src/mip_heuristics/diversity/diversity_manager.cuh index 6c1e7c8822..1e9c404902 100644 --- a/cpp/src/mip_heuristics/diversity/diversity_manager.cuh +++ b/cpp/src/mip_heuristics/diversity/diversity_manager.cuh @@ -29,7 +29,7 @@ #include -namespace cuopt::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_optimization::mip diff --git a/cpp/src/mip_heuristics/diversity/lns/rins.cu b/cpp/src/mip_heuristics/diversity/lns/rins.cu index ef92aa91c6..5abaddb539 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::math_optimization::detail { +namespace cuopt::math_optimization::mip { template rins_t::rins_t(mip_solver_context_t& context_, diversity_manager_t& dm_, @@ -238,7 +238,7 @@ void rins_t::run_rins() 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; + 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,8 +262,8 @@ 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( + 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, dual_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::math_optimization::detail +} // namespace cuopt::math_optimization::mip diff --git a/cpp/src/mip_heuristics/diversity/lns/rins.cuh b/cpp/src/mip_heuristics/diversity/lns/rins.cuh index 57a2748db7..e78f871f69 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::math_optimization::detail { +namespace cuopt::math_optimization::mip { // forward declare template @@ -84,4 +84,4 @@ class rins_t { omp_atomic_t launch_new_task{true}; }; -} // namespace cuopt::math_optimization::detail +} // namespace cuopt::math_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 6044f38f48..c175ef5178 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::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_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 ce67e37e74..81aa55aca9 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::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_optimization::mip diff --git a/cpp/src/mip_heuristics/diversity/population.cu b/cpp/src/mip_heuristics/diversity/population.cu index 329f8ba3ab..3215a06a63 100644 --- a/cpp/src/mip_heuristics/diversity/population.cu +++ b/cpp/src/mip_heuristics/diversity/population.cu @@ -18,7 +18,7 @@ #include -namespace cuopt::math_optimization::detail { +namespace cuopt::math_optimization::mip { constexpr double weight_increase_ratio = 2.; constexpr double weight_decrease_ratio = 0.9; @@ -282,7 +282,7 @@ void population_t::invoke_get_solution_callback( temp_sol.handle_ptr->sync_stream(); if (detail::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( context.settings)); @@ -349,7 +349,7 @@ 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), @@ -901,4 +901,4 @@ template class population_t; template class population_t; #endif -} // namespace cuopt::math_optimization::detail +} // namespace cuopt::math_optimization::mip diff --git a/cpp/src/mip_heuristics/diversity/population.cuh b/cpp/src/mip_heuristics/diversity/population.cuh index 95e618d802..c02f1d3c19 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::math_optimization::detail { +namespace cuopt::math_optimization::mip { // forward declare template @@ -214,4 +214,4 @@ class population_t { cuopt::timer_t timer; }; -} // namespace cuopt::math_optimization::detail +} // namespace cuopt::math_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 0420a66f86..f3b1b63b61 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::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_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 8dd495de62..62d5b28fbc 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::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_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 1304da2a79..fc0c1552bf 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::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_optimization::mip diff --git a/cpp/src/mip_heuristics/diversity/recombiners/recombiner.cuh b/cpp/src/mip_heuristics/diversity/recombiners/recombiner.cuh index cdfa32d144..de5e5a8031 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::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_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 6687072029..c1ad82a89d 100644 --- a/cpp/src/mip_heuristics/diversity/recombiners/recombiner_configs.hpp +++ b/cpp/src/mip_heuristics/diversity/recombiners/recombiner_configs.hpp @@ -7,7 +7,7 @@ #pragma once -namespace cuopt::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_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 c16723d9f6..768e12fd32 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::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_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 8d0ed44683..bd2962d5b5 100644 --- a/cpp/src/mip_heuristics/diversity/recombiners/sub_mip.cuh +++ b/cpp/src/mip_heuristics/diversity/recombiners/sub_mip.cuh @@ -16,7 +16,7 @@ #include #include -namespace cuopt::math_optimization::detail { +namespace cuopt::math_optimization::mip { template class sub_mip_recombiner_t : public recombiner_t { @@ -91,8 +91,8 @@ 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; + const bool run_sub_mip = fixed_problem.n_integer_vars > 8; + mip::mip_status_t branch_and_bound_status = mip::mip_status_t::UNSET; dual_simplex::mip_solution_t branch_and_bound_solution(1); if (run_sub_mip) { // run sub-mip @@ -120,9 +120,8 @@ 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( + 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, dual_simplex::tic(), empty_probing); branch_and_bound_status = branch_and_bound.solve(branch_and_bound_solution); if (solution_vector.size() > 0) { @@ -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::math_optimization::detail +} // namespace cuopt::math_optimization::mip diff --git a/cpp/src/mip_heuristics/diversity/weights.cuh b/cpp/src/mip_heuristics/diversity/weights.cuh index c0de35453a..7993817894 100644 --- a/cpp/src/mip_heuristics/diversity/weights.cuh +++ b/cpp/src/mip_heuristics/diversity/weights.cuh @@ -12,7 +12,7 @@ #include #include -namespace cuopt::math_optimization::detail { +namespace cuopt::math_optimization::mip { template struct weight_t { @@ -29,4 +29,4 @@ struct weight_t { rmm::device_scalar objective_weight; }; -} // namespace cuopt::math_optimization::detail +} // namespace cuopt::math_optimization::mip diff --git a/cpp/src/mip_heuristics/early_heuristic.cuh b/cpp/src/mip_heuristics/early_heuristic.cuh index 5d4fa624f8..74e5583ecb 100644 --- a/cpp/src/mip_heuristics/early_heuristic.cuh +++ b/cpp/src/mip_heuristics/early_heuristic.cuh @@ -21,7 +21,7 @@ #include #include -namespace cuopt::math_optimization::detail { +namespace cuopt::math_optimization::mip { template using early_incumbent_callback_t = std::function #include -namespace cuopt::math_optimization::detail { +namespace cuopt::math_optimization::mip { template struct fj_cpu_climber_t; @@ -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::math_optimization::detail +} // namespace cuopt::math_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 e2b612007e..f3c40e3ffb 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::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_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 a482abddf2..8a0d487f64 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::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_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 f0620db6f2..e12642485b 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::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_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 56958a7a8e..1a868fee69 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::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_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 979077d57c..d6186130e5 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::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_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 7dd9f7ce40..423b5fa214 100644 --- a/cpp/src/mip_heuristics/feasibility_jump/feasibility_jump.cuh +++ b/cpp/src/mip_heuristics/feasibility_jump/feasibility_jump.cuh @@ -25,7 +25,7 @@ #define FJ_DEBUG_LOAD_BALANCING 0 #define FJ_SINGLE_STEP 0 -namespace cuopt::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_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 82bfc97465..f7057b7c72 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::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_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 4e17da07bd..7c8d56141a 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::math_optimization::detail { +namespace cuopt::math_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 detail::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 detail::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 detail::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 detail::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 detail::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 detail::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 detail::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 detail::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 detail::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 detail::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::math_optimization::detail +} // namespace cuopt::math_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 62f6801cf5..7eb1057efa 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::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_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 0e9d96a1fa..a68b6534e8 100644 --- a/cpp/src/mip_heuristics/feasibility_jump/fj_cpu.cu +++ b/cpp/src/mip_heuristics/feasibility_jump/fj_cpu.cu @@ -46,7 +46,7 @@ #define CPUFJ_NVTX_RANGE(name) ((void)0) #endif -namespace cuopt::math_optimization::detail { +namespace cuopt::math_optimization::mip { template void finalize_fj_cpu_host_initialization( @@ -1893,4 +1893,4 @@ template void finalize_fj_cpu_host_initialization( const typename mip_solver_settings_t::tolerances_t& tolerances); #endif -} // namespace cuopt::math_optimization::detail +} // namespace cuopt::math_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 7d8b4dbfb2..8d58b03a63 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::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_optimization::mip diff --git a/cpp/src/mip_heuristics/feasibility_jump/utils.cuh b/cpp/src/mip_heuristics/feasibility_jump/utils.cuh index 2910710cf8..2564020cde 100644 --- a/cpp/src/mip_heuristics/feasibility_jump/utils.cuh +++ b/cpp/src/mip_heuristics/feasibility_jump/utils.cuh @@ -19,7 +19,7 @@ #include #include -namespace cuopt::math_optimization::detail { +namespace cuopt::math_optimization::mip { HDI uint64_t hash_64(uint64_t x) { @@ -212,4 +212,4 @@ struct contiguous_set_t { bitmap_t validity_bitmap; }; -} // namespace cuopt::math_optimization::detail +} // namespace cuopt::math_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 0dfe38bdbf..9bfbc52a16 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 @@ -29,7 +29,7 @@ #include #include -namespace cuopt::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_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 4690653215..51ee8c8078 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::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_optimization::mip diff --git a/cpp/src/mip_heuristics/local_search/lagrangian.cuh b/cpp/src/mip_heuristics/local_search/lagrangian.cuh index 0123c22f90..7331d5ddfd 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::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_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 cb0604285f..5d0fdf52d1 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::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_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 f506d71b97..c6ac3e6194 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::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_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 725d538b3a..3cc82225de 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::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_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 b1ae4a3a14..6bf1ae8a93 100644 --- a/cpp/src/mip_heuristics/local_search/local_search.cuh +++ b/cpp/src/mip_heuristics/local_search/local_search.cuh @@ -20,7 +20,7 @@ template class branch_and_bound_t; } -namespace cuopt::math_optimization::detail { +namespace cuopt::math_optimization::mip { // make sure RANDOM is always the last enum class ls_method_t : int { @@ -88,7 +88,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 +131,4 @@ class local_search_t { population_t* pop_ptr{nullptr}; }; -} // namespace cuopt::math_optimization::detail +} // namespace cuopt::math_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 28685f7982..6251d659af 100644 --- a/cpp/src/mip_heuristics/local_search/local_search_config.hpp +++ b/cpp/src/mip_heuristics/local_search/local_search_config.hpp @@ -7,7 +7,7 @@ #pragma once -namespace cuopt::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_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 62183830a8..c5440dd976 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::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +}; // namespace cuopt::math_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 f08347f3ff..a1e7aee46c 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::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_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 e8954743a0..ef3da385a6 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::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_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 d0b88d088e..2eff0d38a6 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::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_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 888029a099..438a62fe7d 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::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_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 b87f9221f4..d9839f6d72 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::math_optimization::detail { +namespace cuopt::math_optimization::mip { template struct lb_bounds_t { @@ -87,4 +87,4 @@ class lb_bounds_repair_t { i_t cycle_write_pos = 0; }; -} // namespace cuopt::math_optimization::detail +} // namespace cuopt::math_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 985e7060f4..f654628d70 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::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_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 3edc563713..7fe92d4b28 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::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_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 30a40ac5c4..e7d5eb7f9f 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::math_optimization::detail { +namespace cuopt::math_optimization::mip { template bool check_brute_force_rounding(solution_t& solution) @@ -189,4 +189,4 @@ INSTANTIATE(double) #undef INSTANTIATE -} // namespace cuopt::math_optimization::detail +} // namespace cuopt::math_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 b598043afc..62e25d75cc 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::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_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 f96a81d824..2b0fb2ee2c 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::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_optimization::mip diff --git a/cpp/src/mip_heuristics/logger.cuh b/cpp/src/mip_heuristics/logger.cuh index e129498942..066fb141cf 100644 --- a/cpp/src/mip_heuristics/logger.cuh +++ b/cpp/src/mip_heuristics/logger.cuh @@ -9,7 +9,7 @@ #include -namespace cuopt::math_optimization::detail { +namespace cuopt::math_optimization::mip { // Default to info level if not specified. #if !defined(CUOPT_LOG_ACTIVE_LEVEL) @@ -53,4 +53,4 @@ namespace cuopt::math_optimization::detail { #define DEVICE_LOG_CRITICAL(...) void(0) #endif -} // namespace cuopt::math_optimization::detail +} // namespace cuopt::math_optimization::mip diff --git a/cpp/src/mip_heuristics/mip_scaling_strategy.cu b/cpp/src/mip_heuristics/mip_scaling_strategy.cu index 31ec985b27..eece2171a8 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::math_optimization::detail { +namespace cuopt::math_optimization::mip { constexpr int row_scaling_max_iterations = 8; constexpr double row_scaling_min_initial_log2_spread = 12.0; @@ -879,4 +879,4 @@ INSTANTIATE(float) INSTANTIATE(double) #endif -} // namespace cuopt::math_optimization::detail +} // namespace cuopt::math_optimization::mip diff --git a/cpp/src/mip_heuristics/mip_scaling_strategy.cuh b/cpp/src/mip_heuristics/mip_scaling_strategy.cuh index a141ac1011..bfc1f92052 100644 --- a/cpp/src/mip_heuristics/mip_scaling_strategy.cuh +++ b/cpp/src/mip_heuristics/mip_scaling_strategy.cuh @@ -13,7 +13,7 @@ #include -namespace cuopt::math_optimization::detail { +namespace cuopt::math_optimization::mip { template class mip_scaling_strategy_t { @@ -29,4 +29,4 @@ class mip_scaling_strategy_t { optimization_problem_type_t& op_problem_scaled_; }; -} // namespace cuopt::math_optimization::detail +} // namespace cuopt::math_optimization::mip diff --git a/cpp/src/mip_heuristics/presolve/bounds_presolve.cu b/cpp/src/mip_heuristics/presolve/bounds_presolve.cu index 9e06373dc8..642888985f 100644 --- a/cpp/src/mip_heuristics/presolve/bounds_presolve.cu +++ b/cpp/src/mip_heuristics/presolve/bounds_presolve.cu @@ -23,7 +23,7 @@ #include "bounds_presolve_helpers.cuh" #include "bounds_update_helpers.cuh" -namespace cuopt::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_optimization::mip diff --git a/cpp/src/mip_heuristics/presolve/bounds_presolve.cuh b/cpp/src/mip_heuristics/presolve/bounds_presolve.cuh index eb84f1ea18..780e1f6c7a 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::math_optimization::detail { +namespace cuopt::math_optimization::mip { template class probing_cache_t; @@ -84,4 +84,4 @@ class bound_presolve_t { i_t solve_iter; }; -} // namespace cuopt::math_optimization::detail +} // namespace cuopt::math_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 093b281add..1b00f6a36f 100644 --- a/cpp/src/mip_heuristics/presolve/bounds_presolve_helpers.cuh +++ b/cpp/src/mip_heuristics/presolve/bounds_presolve_helpers.cuh @@ -15,7 +15,7 @@ #include "bounds_update_data.cuh" -namespace cuopt::math_optimization::detail { +namespace cuopt::math_optimization::mip { template struct tuple_plus_t { @@ -35,4 +35,4 @@ struct tuple_plus_t { } }; -} // namespace cuopt::math_optimization::detail +} // namespace cuopt::math_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 39cfb91313..d701ad03d3 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::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_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 6348c2e787..69cabf0ef7 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::math_optimization::detail { +namespace cuopt::math_optimization::mip { template struct bounds_update_data_t { @@ -45,4 +45,4 @@ struct bounds_update_data_t { view_t view(); }; -} // namespace cuopt::math_optimization::detail +} // namespace cuopt::math_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 060b8da6bd..87445596ed 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::math_optimization::detail { +namespace cuopt::math_optimization::mip { // Activity calculation @@ -398,4 +398,4 @@ __global__ void update_bounds_kernel(typename problem_t::view_t pb, } } -} // namespace cuopt::math_optimization::detail +} // namespace cuopt::math_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 9764e292d7..b2674a2482 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::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_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 5d0b48a117..dafcbbed87 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::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_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 4509f8f04b..26ddef9f12 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,7 @@ #include #include -namespace cuopt::math_optimization::detail { +namespace cuopt::math_optimization::mip { // do constraints with only binary variables. template @@ -785,4 +785,4 @@ INSTANTIATE(double) #endif #undef INSTANTIATE -} // namespace cuopt::math_optimization::detail +} // namespace cuopt::math_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 8fe55aae16..4059390847 100644 --- a/cpp/src/mip_heuristics/presolve/conflict_graph/clique_table.cuh +++ b/cpp/src/mip_heuristics/presolve/conflict_graph/clique_table.cuh @@ -31,7 +31,7 @@ #include #include -namespace cuopt::math_optimization::detail { +namespace cuopt::math_optimization::mip { struct clique_config_t { int min_clique_size = 512; @@ -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::math_optimization::detail +} // namespace cuopt::math_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 a6dbd4b75b..c5799137e4 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::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_optimization::mip diff --git a/cpp/src/mip_heuristics/presolve/gf2_presolve.hpp b/cpp/src/mip_heuristics/presolve/gf2_presolve.hpp index 495f46bdde..6bfda7a3ee 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::math_optimization::detail { +namespace cuopt::math_optimization::mip { template class GF2Presolve : public papilo::PresolveMethod { @@ -66,4 +66,4 @@ class GF2Presolve : public papilo::PresolveMethod { } }; -} // namespace cuopt::math_optimization::detail +} // namespace cuopt::math_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 f7c8acf99f..7ba04c53d1 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::math_optimization::detail { +namespace cuopt::math_optimization::mip { template void lb_probing_cache_t::update_bounds_with_selected( @@ -415,4 +415,4 @@ INSTANTIATE(double) #undef INSTANTIATE -} // namespace cuopt::math_optimization::detail +} // namespace cuopt::math_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 b3734c10fb..c0dbf0ec13 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::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_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 b90eed6635..ad0dfa459d 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::math_optimization::detail { +namespace cuopt::math_optimization::mip { template class load_balanced_problem_t; @@ -262,4 +262,4 @@ class load_balanced_bounds_presolve_t { i_t solve_iter; }; -} // namespace cuopt::math_optimization::detail +} // namespace cuopt::math_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 b414ab2dcf..437cbd202c 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::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_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 1cf4923f57..6a8a83f4b9 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::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_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 3ced570f59..c17d03a1ba 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::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_optimization::mip diff --git a/cpp/src/mip_heuristics/presolve/multi_probe.cu b/cpp/src/mip_heuristics/presolve/multi_probe.cu index 36142c9437..b5f2c54575 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::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_optimization::mip diff --git a/cpp/src/mip_heuristics/presolve/multi_probe.cuh b/cpp/src/mip_heuristics/presolve/multi_probe.cuh index 4affd97e77..cd022027a3 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::math_optimization::detail { +namespace cuopt::math_optimization::mip { template class multi_probe_t { @@ -83,4 +83,4 @@ class multi_probe_t { i_t redund_constraints_count_1 = 0; }; -} // namespace cuopt::math_optimization::detail +} // namespace cuopt::math_optimization::mip diff --git a/cpp/src/mip_heuristics/presolve/probing_cache.cu b/cpp/src/mip_heuristics/presolve/probing_cache.cu index 9621929cf4..fa2fc3f989 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::math_optimization::detail { +namespace cuopt::math_optimization::mip { template i_t probing_cache_t::check_number_of_conflicting_vars( @@ -967,4 +967,4 @@ INSTANTIATE(double) #undef INSTANTIATE -} // namespace cuopt::math_optimization::detail +} // namespace cuopt::math_optimization::mip diff --git a/cpp/src/mip_heuristics/presolve/probing_cache.cuh b/cpp/src/mip_heuristics/presolve/probing_cache.cuh index d8cbe37891..787defd7e8 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::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_optimization::mip diff --git a/cpp/src/mip_heuristics/presolve/semi_continuous.cu b/cpp/src/mip_heuristics/presolve/semi_continuous.cu index c7773f5db1..cb0fac1f0b 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::math_optimization::detail { +namespace cuopt::math_optimization::mip { namespace { @@ -416,4 +416,4 @@ template void expand_initial_solutions_for_semi_continuous(mip_solver_settings_t rmm::cuda_stream_view); #endif -} // namespace cuopt::math_optimization::detail +} // namespace cuopt::math_optimization::mip diff --git a/cpp/src/mip_heuristics/presolve/semi_continuous.cuh b/cpp/src/mip_heuristics/presolve/semi_continuous.cuh index 68b8142157..567978c651 100644 --- a/cpp/src/mip_heuristics/presolve/semi_continuous.cuh +++ b/cpp/src/mip_heuristics/presolve/semi_continuous.cuh @@ -10,7 +10,7 @@ #include #include -namespace cuopt::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_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 71329d08a8..302454b72a 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::math_optimization::detail { +namespace cuopt::math_optimization::mip { template papilo::Problem build_papilo_problem(const optimization_problem_t& op_problem, @@ -550,7 +550,7 @@ void set_presolve_methods(papilo::Presolve& presolver, if (category == problem_category_t::MIP) { // cuOpt custom GF2 presolver - presolver.addPresolveMethod(uptr(new cuopt::math_optimization::detail::GF2Presolve())); + presolver.addPresolveMethod(uptr(new cuopt::math_optimization::mip::GF2Presolve())); } // fast presolvers presolver.addPresolveMethod(uptr(new papilo::SingletonCols())); @@ -899,4 +899,4 @@ template struct papilo_postsolve_deleter; template class third_party_presolve_t; #endif -} // namespace cuopt::math_optimization::detail +} // namespace cuopt::math_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 d8a430be0e..39bf5938a9 100644 --- a/cpp/src/mip_heuristics/presolve/third_party_presolve.hpp +++ b/cpp/src/mip_heuristics/presolve/third_party_presolve.hpp @@ -20,7 +20,7 @@ template class PostsolveStorage; } -namespace cuopt::math_optimization::detail { +namespace cuopt::math_optimization::mip { template struct papilo_postsolve_deleter { @@ -107,4 +107,4 @@ class third_party_presolve_t { std::vector original_to_reduced_map_{}; }; -} // namespace cuopt::math_optimization::detail +} // namespace cuopt::math_optimization::mip diff --git a/cpp/src/mip_heuristics/presolve/trivial_presolve.cu b/cpp/src/mip_heuristics/presolve/trivial_presolve.cu index 14263b1709..efb8761389 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::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_optimization::mip diff --git a/cpp/src/mip_heuristics/presolve/trivial_presolve.cuh b/cpp/src/mip_heuristics/presolve/trivial_presolve.cuh index 5b80ea61a4..566d9ff7d4 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::math_optimization::detail { +namespace cuopt::math_optimization::mip { template void test_renumbered_coo(raft::device_span coo_major, const problem_t& pb) @@ -371,4 +371,4 @@ void trivial_presolve(problem_t& problem, bool remap_cache_ids = false problem.check_problem_representation(true); } -} // namespace cuopt::math_optimization::detail +} // namespace cuopt::math_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 e8c9ba4f8a..f2e3bcf03e 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::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_optimization::mip diff --git a/cpp/src/mip_heuristics/presolve/utils.cuh b/cpp/src/mip_heuristics/presolve/utils.cuh index 257d99e501..6f295fb1e7 100644 --- a/cpp/src/mip_heuristics/presolve/utils.cuh +++ b/cpp/src/mip_heuristics/presolve/utils.cuh @@ -7,7 +7,7 @@ #pragma once -namespace cuopt::math_optimization::detail { +namespace cuopt::math_optimization::mip { enum class termination_criterion_t { TIME_LIMIT, @@ -17,4 +17,4 @@ enum class termination_criterion_t { NO_UPDATE }; -} // namespace cuopt::math_optimization::detail +} // namespace cuopt::math_optimization::mip diff --git a/cpp/src/mip_heuristics/problem/host_helper.cuh b/cpp/src/mip_heuristics/problem/host_helper.cuh index dea0ae6d5a..366e467d53 100644 --- a/cpp/src/mip_heuristics/problem/host_helper.cuh +++ b/cpp/src/mip_heuristics/problem/host_helper.cuh @@ -14,7 +14,7 @@ #include -namespace cuopt::math_optimization::detail { +namespace cuopt::math_optimization::mip { template struct constraints_delta_t { @@ -65,4 +65,4 @@ struct variables_delta_t { } }; -} // namespace cuopt::math_optimization::detail +} // namespace cuopt::math_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 0e542f85a5..72153dee2c 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::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_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 7528dc658d..b96c8fc169 100644 --- a/cpp/src/mip_heuristics/problem/load_balanced_problem.cuh +++ b/cpp/src/mip_heuristics/problem/load_balanced_problem.cuh @@ -28,7 +28,7 @@ #include #include -namespace cuopt::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_optimization::mip diff --git a/cpp/src/mip_heuristics/problem/presolve_data.cu b/cpp/src/mip_heuristics/problem/presolve_data.cu index 49d4d4b370..7501a4fe45 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 math_optimization::detail { +namespace math_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::math_optimization::detail::has_nans(problem.handle_ptr, assignment); + auto has_nans = cuopt::math_optimization::mip::has_nans(problem.handle_ptr, assignment); if (has_nans) { CUOPT_LOG_DEBUG("Solution discarded due to nans"); return false; @@ -80,7 +80,7 @@ bool presolve_data_t::pre_process_assignment(problem_t& prob assignment.begin()); problem.handle_ptr->sync_stream(); - auto has_integrality_discrepancy = cuopt::math_optimization::detail::has_integrality_discrepancy( + auto has_integrality_discrepancy = cuopt::math_optimization::mip::has_integrality_discrepancy( problem.handle_ptr, problem.integer_indices, assignment, @@ -90,9 +90,8 @@ bool presolve_data_t::pre_process_assignment(problem_t& prob return false; } - auto has_variable_bounds_violation = - cuopt::math_optimization::detail::has_variable_bounds_violation( - problem.handle_ptr, assignment, &problem); + auto has_variable_bounds_violation = cuopt::math_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"); return false; @@ -250,5 +249,5 @@ template class presolve_data_t; template class presolve_data_t; #endif -} // namespace math_optimization::detail +} // namespace math_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 dcd432fdd8..63c8754759 100644 --- a/cpp/src/mip_heuristics/problem/presolve_data.cuh +++ b/cpp/src/mip_heuristics/problem/presolve_data.cuh @@ -14,7 +14,7 @@ #include namespace cuopt { -namespace math_optimization::detail { +namespace math_optimization::mip { template class problem_t; @@ -133,5 +133,5 @@ class presolve_data_t { std::vector> variable_substitutions; }; -} // namespace math_optimization::detail +} // namespace math_optimization::mip } // namespace cuopt diff --git a/cpp/src/mip_heuristics/problem/problem.cu b/cpp/src/mip_heuristics/problem/problem.cu index ec691ba531..a142b2a8a9 100644 --- a/cpp/src/mip_heuristics/problem/problem.cu +++ b/cpp/src/mip_heuristics/problem/problem.cu @@ -48,7 +48,7 @@ #include -namespace cuopt::math_optimization::detail { +namespace cuopt::math_optimization::mip { template void problem_t::op_problem_cstr_body(const optimization_problem_t& problem_) @@ -1363,7 +1363,7 @@ void problem_t::set_implied_integers(const std::vector& implied_i template void problem_t::recompute_objective_integrality() { - using cuopt::math_optimization::detail::is_integer; + using cuopt::math_optimization::mip::is_integer; objective_is_integral = thrust::all_of(handle_ptr->get_thrust_policy(), @@ -1449,7 +1449,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 +1467,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 +1487,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 +1804,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); @@ -2386,17 +2386,17 @@ 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_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 = detail::compute_hash(presolve_data.objective_offset); uint32_t h_obj_scale = detail::compute_hash(presolve_data.objective_scaling_factor); @@ -2496,4 +2496,4 @@ template class problem_t; template class problem_t; #endif -} // namespace cuopt::math_optimization::detail +} // namespace cuopt::math_optimization::mip diff --git a/cpp/src/mip_heuristics/problem/problem.cuh b/cpp/src/mip_heuristics/problem/problem.cuh index 4008077472..9056fdca5c 100644 --- a/cpp/src/mip_heuristics/problem/problem.cuh +++ b/cpp/src/mip_heuristics/problem/problem.cuh @@ -37,7 +37,7 @@ namespace cuopt { -namespace math_optimization::detail { +namespace math_optimization::mip { template struct clique_table_t; @@ -346,5 +346,5 @@ class problem_t { std::vector Q_values; }; -} // namespace math_optimization::detail +} // namespace math_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 3632259108..bb5445ee36 100644 --- a/cpp/src/mip_heuristics/problem/problem_fixing.cuh +++ b/cpp/src/mip_heuristics/problem/problem_fixing.cuh @@ -10,7 +10,7 @@ #include namespace cuopt { -namespace math_optimization::detail { +namespace math_optimization::mip { template struct problem_fixing_helpers_t { @@ -30,5 +30,5 @@ struct problem_fixing_helpers_t { rmm::device_uvector variable_fix_mask; }; -} // namespace math_optimization::detail +} // namespace math_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 c756c8857b..840077c2ba 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::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_optimization::mip diff --git a/cpp/src/mip_heuristics/problem/problem_kernels.cuh b/cpp/src/mip_heuristics/problem/problem_kernels.cuh index e485f192ce..316794b6e4 100644 --- a/cpp/src/mip_heuristics/problem/problem_kernels.cuh +++ b/cpp/src/mip_heuristics/problem/problem_kernels.cuh @@ -11,7 +11,7 @@ #include "problem.cuh" -namespace cuopt::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_optimization::mip diff --git a/cpp/src/mip_heuristics/problem/write_mps.cu b/cpp/src/mip_heuristics/problem/write_mps.cu index eb8c53e035..3f298287dc 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::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_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 49f632ff0c..9b6a7307b5 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::math_optimization::detail { +namespace cuopt::math_optimization::mip { template class problem_t; @@ -68,4 +68,4 @@ class lp_state_t { rmm::device_uvector prev_dual; }; -} // namespace cuopt::math_optimization::detail +} // namespace cuopt::math_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 a4da98de3d..f676b4ab3e 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::math_optimization::detail { +namespace cuopt::math_optimization::mip { template optimization_problem_solution_t get_relaxed_lp_solution( @@ -228,4 +228,4 @@ INSTANTIATE(double) #undef INSTANTIATE -} // namespace cuopt::math_optimization::detail +} // namespace cuopt::math_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 52251465e7..ef71ca78e2 100644 --- a/cpp/src/mip_heuristics/relaxed_lp/relaxed_lp.cuh +++ b/cpp/src/mip_heuristics/relaxed_lp/relaxed_lp.cuh @@ -14,7 +14,7 @@ #include #include "lp_state.cuh" -namespace cuopt::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_optimization::mip diff --git a/cpp/src/mip_heuristics/solution/feasibility_test.cuh b/cpp/src/mip_heuristics/solution/feasibility_test.cuh index 69cfee23ae..17f01f0801 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::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_optimization::mip diff --git a/cpp/src/mip_heuristics/solution/solution.cu b/cpp/src/mip_heuristics/solution/solution.cu index fca84db321..fdfc6a901a 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::math_optimization::detail { +namespace cuopt::math_optimization::mip { template rmm::device_uvector get_lower_bounds( @@ -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::math_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,23 @@ 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::math_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::math_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 +651,4 @@ template class solution_t; template class solution_t; #endif -} // namespace cuopt::math_optimization::detail +} // namespace cuopt::math_optimization::mip diff --git a/cpp/src/mip_heuristics/solution/solution.cuh b/cpp/src/mip_heuristics/solution/solution.cuh index 914ec9d63b..39828184d9 100644 --- a/cpp/src/mip_heuristics/solution/solution.cuh +++ b/cpp/src/mip_heuristics/solution/solution.cuh @@ -19,7 +19,7 @@ #include #include -namespace cuopt::math_optimization::detail { +namespace cuopt::math_optimization::mip { template class solution_t { @@ -93,9 +93,9 @@ 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::math_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 +154,4 @@ class solution_t { void test_variable_bounds(bool check_integer = true, i_t* is_feasible = nullptr); }; -} // namespace cuopt::math_optimization::detail +} // namespace cuopt::math_optimization::mip diff --git a/cpp/src/mip_heuristics/solution/solution_kernels.cuh b/cpp/src/mip_heuristics/solution/solution_kernels.cuh index 4ef5f56d7e..4c3d3e5ef0 100644 --- a/cpp/src/mip_heuristics/solution/solution_kernels.cuh +++ b/cpp/src/mip_heuristics/solution/solution_kernels.cuh @@ -11,7 +11,7 @@ #include -namespace cuopt::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_optimization::mip diff --git a/cpp/src/mip_heuristics/solve.cu b/cpp/src/mip_heuristics/solve.cu index 91b2cf41b1..eaba8d6642 100644 --- a/cpp/src/mip_heuristics/solve.cu +++ b/cpp/src/mip_heuristics/solve.cu @@ -87,8 +87,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,12 +104,12 @@ 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"); @@ -131,7 +131,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(), @@ -166,7 +166,7 @@ mip_solution_t run_mip_solver( solution.handle_ptr->sync_stream(); if (detail::mip_solver_settings_accessor:: has_semi_continuous_callback_translation(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(settings)); @@ -180,7 +180,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 +194,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. @@ -216,8 +216,8 @@ mip_solution_t run_mip_solver( 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 +225,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 +233,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 +246,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; @@ -288,7 +288,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 +322,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,13 +391,12 @@ 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( @@ -424,30 +423,30 @@ mip_solution_t solve_mip_helper(optimization_problem_t& op_p } // 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); + mip::problem_t problem(op_problem); dual_simplex::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 = 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 +480,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; @@ -528,21 +527,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,7 +550,7 @@ 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::math_optimization::problem_category_t::MIP, settings.presolver, @@ -561,24 +560,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, @@ -655,8 +654,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 +685,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()) { diff --git a/cpp/src/mip_heuristics/solver.cu b/cpp/src/mip_heuristics/solver.cu index 578c1cd708..5a7581d711 100644 --- a/cpp/src/mip_heuristics/solver.cu +++ b/cpp/src/mip_heuristics/solver.cu @@ -33,7 +33,7 @@ #include #include -namespace cuopt::math_optimization::detail { +namespace cuopt::math_optimization::mip { // 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) @@ -92,12 +92,12 @@ 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) + 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 @@ -303,13 +303,13 @@ solution_t mip_solver_t::run_solver() cuopt_problem_to_user_problem(context.problem_ptr->handle_ptr, *context.problem_ptr); bool has_symmetry_post = false; - context.symmetry = cuopt::math_optimization::dual_simplex::detect_symmetry( + context.symmetry = cuopt::math_optimization::mip::detect_symmetry( post_presolve_problem, simplex_settings, has_symmetry_post); } #endif - namespace dual_simplex = cuopt::math_optimization::dual_simplex; - dual_simplex::mip_status_t branch_and_bound_status = dual_simplex::mip_status_t::UNSET; + namespace dual_simplex = cuopt::math_optimization::dual_simplex; + mip::mip_status_t branch_and_bound_status = mip::mip_status_t::UNSET; dual_simplex::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(); } @@ -329,11 +329,11 @@ solution_t mip_solver_t::run_solver() 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; + 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); - 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(); @@ -426,13 +426,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 +456,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 +472,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 +509,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 +541,4 @@ template class mip_solver_t; template class mip_solver_t; #endif -} // namespace cuopt::math_optimization::detail +} // namespace cuopt::math_optimization::mip diff --git a/cpp/src/mip_heuristics/solver.cuh b/cpp/src/mip_heuristics/solver.cuh index 8deb0867be..0d8fd35640 100644 --- a/cpp/src/mip_heuristics/solver.cuh +++ b/cpp/src/mip_heuristics/solver.cuh @@ -13,7 +13,7 @@ #include #pragma once -namespace cuopt::math_optimization::detail { +namespace cuopt::math_optimization::mip { template class mip_solver_t { @@ -32,4 +32,4 @@ class mip_solver_t { timer_t timer_; }; -} // namespace cuopt::math_optimization::detail +} // namespace cuopt::math_optimization::mip diff --git a/cpp/src/mip_heuristics/solver_context.cuh b/cpp/src/mip_heuristics/solver_context.cuh index 4014133a82..269c298d01 100644 --- a/cpp/src/mip_heuristics/solver_context.cuh +++ b/cpp/src/mip_heuristics/solver_context.cuh @@ -18,14 +18,14 @@ #pragma once // Forward declare -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_optimization::mip { template class branch_and_bound_t; } #include -namespace cuopt::math_optimization::detail { +namespace cuopt::math_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::math_optimization::detail +} // namespace cuopt::math_optimization::mip diff --git a/cpp/src/mip_heuristics/utilities/sort_csr.cuh b/cpp/src/mip_heuristics/utilities/sort_csr.cuh index 8d66f24b05..68cba1b1ab 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 math_optimization::detail { +namespace math_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 math_optimization::detail +} // namespace math_optimization::mip } // namespace cuopt diff --git a/cpp/src/mip_heuristics/utils.cuh b/cpp/src/mip_heuristics/utils.cuh index 39a3940536..e1db2186c0 100644 --- a/cpp/src/mip_heuristics/utils.cuh +++ b/cpp/src/mip_heuristics/utils.cuh @@ -21,7 +21,7 @@ #pragma once -namespace cuopt::math_optimization::detail { +namespace cuopt::math_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 detail::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 detail::compute_hash(h_contents); } template @@ -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::math_optimization::detail +} // namespace cuopt::math_optimization::mip diff --git a/cpp/src/pdlp/cusparse_view.cu b/cpp/src/pdlp/cusparse_view.cu index 720760ee1f..c04f592bbd 100644 --- a/cpp/src/pdlp/cusparse_view.cu +++ b/cpp/src/pdlp/cusparse_view.cu @@ -512,7 +512,7 @@ void cusparse_spmvop_run(cusparseHandle_t handle, template cusparse_view_t::cusparse_view_t( raft::handle_t const* handle_ptr, - const detail::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, @@ -927,7 +927,7 @@ cusparse_view_t::cusparse_view_t( template cusparse_view_t::cusparse_view_t( raft::handle_t const* handle_ptr, - const detail::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, @@ -1150,7 +1150,7 @@ cusparse_view_t::cusparse_view_t( template cusparse_view_t::cusparse_view_t( raft::handle_t const* handle_ptr, - const detail::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 detail::problem_t& original_problem) + const mip::problem_t& original_problem) { RAFT_CUSPARSE_TRY(cusparseCsrSetPointers(A, const_cast(original_problem.offsets.data()), diff --git a/cpp/src/pdlp/cusparse_view.hpp b/cpp/src/pdlp/cusparse_view.hpp index 9043aa1530..bbd531d1e2 100644 --- a/cpp/src/pdlp/cusparse_view.hpp +++ b/cpp/src/pdlp/cusparse_view.hpp @@ -158,7 +158,7 @@ template class cusparse_view_t { public: cusparse_view_t(raft::handle_t const* handle_ptr, - const detail::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, @@ -169,7 +169,7 @@ class cusparse_view_t { bool enable_mixed_precision_spmv); cusparse_view_t(raft::handle_t const* handle_ptr, - const detail::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, @@ -183,7 +183,7 @@ class cusparse_view_t { const pdlp::pdlp_hyper_params_t& hyper_params); cusparse_view_t(raft::handle_t const* handle_ptr, - const detail::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,8 +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 detail::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); }; diff --git a/cpp/src/pdlp/initial_scaling_strategy/initial_scaling.cu b/cpp/src/pdlp/initial_scaling_strategy/initial_scaling.cu index 1da3848a2f..61a93157bc 100644 --- a/cpp/src/pdlp/initial_scaling_strategy/initial_scaling.cu +++ b/cpp/src/pdlp/initial_scaling_strategy/initial_scaling.cu @@ -70,7 +70,7 @@ __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, - detail::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, @@ -185,7 +185,7 @@ void pdlp_initial_scaling_strategy_t::bound_objective_rescaling() template __global__ void inf_norm_row_and_col_kernel( - const typename detail::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 detail::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 detail::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 detail::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( - detail::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,8 +894,7 @@ void pdlp_initial_scaling_strategy_t::unscale_solutions( } template -const detail::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_; } @@ -939,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 detail::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 detail::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, \ @@ -951,13 +950,13 @@ pdlp_initial_scaling_strategy_t::view() const int* A_T_indices); \ \ template __global__ void pock_chambolle_scaling_kernel_row( \ - const typename detail::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 detail::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, \ diff --git a/cpp/src/pdlp/initial_scaling_strategy/initial_scaling.cuh b/cpp/src/pdlp/initial_scaling_strategy/initial_scaling.cuh index 5b063b4592..6d2ee94188 100644 --- a/cpp/src/pdlp/initial_scaling_strategy/initial_scaling.cuh +++ b/cpp/src/pdlp/initial_scaling_strategy/initial_scaling.cuh @@ -47,7 +47,7 @@ class pdlp_initial_scaling_strategy_t { }; // struct view_t pdlp_initial_scaling_strategy_t(raft::handle_t const* handle_ptr, - detail::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, @@ -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(detail::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 detail::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_; - detail::problem_t& op_problem_scaled_; + mip::problem_t& op_problem_scaled_; rmm::device_uvector iteration_constraint_matrix_scaling_; rmm::device_uvector iteration_variable_scaling_; 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 bd65e8d3db..1316c692d4 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 @@ -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; diff --git a/cpp/src/pdlp/pdhg.cu b/cpp/src/pdlp/pdhg.cu index f00b3eb521..fb8a18647a 100644 --- a/cpp/src/pdlp/pdhg.cu +++ b/cpp/src/pdlp/pdhg.cu @@ -43,7 +43,7 @@ namespace cuopt::math_optimization::pdlp { template pdhg_solver_t::pdhg_solver_t( raft::handle_t const* handle_ptr, - detail::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::pdlp_hyper_params_t& hyper_params, diff --git a/cpp/src/pdlp/pdhg.hpp b/cpp/src/pdlp/pdhg.hpp index 88c90753b0..d5fad2f514 100644 --- a/cpp/src/pdlp/pdhg.hpp +++ b/cpp/src/pdlp/pdhg.hpp @@ -28,7 +28,7 @@ template class pdhg_solver_t { public: pdhg_solver_t(raft::handle_t const* handle_ptr, - detail::problem_t& op_problem, + mip::problem_t& op_problem, bool is_legacy_batch_mode, const std::vector& climber_strategies, const pdlp::pdlp_hyper_params_t& hyper_params, @@ -102,7 +102,7 @@ class pdhg_solver_t { raft::handle_t const* handle_ptr_{nullptr}; rmm::cuda_stream_view stream_view_; - detail::problem_t* problem_ptr; + mip::problem_t* problem_ptr; i_t primal_size_h_; i_t dual_size_h_; diff --git a/cpp/src/pdlp/pdlp.cu b/cpp/src/pdlp/pdlp.cu index 7f27a90cef..8f15e8f2c2 100644 --- a/cpp/src/pdlp/pdlp.cu +++ b/cpp/src/pdlp/pdlp.cu @@ -153,7 +153,7 @@ static size_t batch_size_handler(const pdlp_solver_settings_t& setting } template -pdlp_solver_t::pdlp_solver_t(detail::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)), diff --git a/cpp/src/pdlp/pdlp.cuh b/cpp/src/pdlp/pdlp.cuh index 1d84ad97ef..e4e9deee21 100644 --- a/cpp/src/pdlp/pdlp.cuh +++ b/cpp/src/pdlp/pdlp.cuh @@ -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 detail::problem_t object with a + * @param[in] op_problem An mip::problem_t object with a * representation of a linear program */ - pdlp_solver_t(detail::problem_t& op_problem, + pdlp_solver_t(mip::problem_t& op_problem, pdlp_solver_settings_t const& settings, bool is_batch_mode = false); @@ -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(detail::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 @@ -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}; - detail::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 - detail::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_; diff --git a/cpp/src/pdlp/restart_strategy/pdlp_restart_strategy.cu b/cpp/src/pdlp/restart_strategy/pdlp_restart_strategy.cu index d6706a08fb..11c7393e13 100644 --- a/cpp/src/pdlp/restart_strategy/pdlp_restart_strategy.cu +++ b/cpp/src/pdlp/restart_strategy/pdlp_restart_strategy.cu @@ -55,7 +55,7 @@ namespace cuopt::math_optimization::pdlp { template __global__ void solve_bound_constrained_trust_region_kernel( typename pdlp_restart_strategy_t::view_t restart_strategy_view, - typename detail::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,7 +66,7 @@ __global__ void solve_bound_constrained_trust_region_kernel( template pdlp_restart_strategy_t::pdlp_restart_strategy_t( raft::handle_t const* handle_ptr, - detail::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, @@ -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 detail::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 detail::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 detail::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 detail::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 detail::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); diff --git a/cpp/src/pdlp/restart_strategy/pdlp_restart_strategy.cuh b/cpp/src/pdlp/restart_strategy/pdlp_restart_strategy.cuh index d71807abfb..334a0866a0 100644 --- a/cpp/src/pdlp/restart_strategy/pdlp_restart_strategy.cuh +++ b/cpp/src/pdlp/restart_strategy/pdlp_restart_strategy.cuh @@ -112,7 +112,7 @@ class pdlp_restart_strategy_t { void resize_context(i_t new_size); pdlp_restart_strategy_t(raft::handle_t const* handle_ptr, - detail::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, @@ -308,7 +308,7 @@ class pdlp_restart_strategy_t { i_t primal_size_h_; i_t dual_size_h_; - detail::problem_t* problem_ptr; + mip::problem_t* problem_ptr; rmm::device_scalar primal_norm_weight_; rmm::device_scalar dual_norm_weight_; diff --git a/cpp/src/pdlp/solve.cu b/cpp/src/pdlp/solve.cu index 480dcc508f..c4ed281dd0 100644 --- a/cpp/src/pdlp/solve.cu +++ b/cpp/src/pdlp/solve.cu @@ -443,7 +443,7 @@ optimization_problem_solution_t convert_dual_simplex_sol( template optimization_problem_solution_t convert_dual_simplex_sol( - detail::problem_t& problem, + mip::problem_t& problem, const dual_simplex::lp_solution_t& solution, dual_simplex::lp_status_t status, f_t duration, @@ -544,7 +544,7 @@ 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) { @@ -618,7 +618,7 @@ 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) { @@ -639,7 +639,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 +653,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 +662,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)); } } @@ -756,7 +756,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) @@ -781,7 +781,7 @@ static optimization_problem_solution_t run_pdlp_solver( } 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) @@ -1511,7 +1511,7 @@ void run_dual_simplex_thread( 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) @@ -1756,7 +1756,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) @@ -1927,7 +1927,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,22 +1948,22 @@ 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::math_optimization::problem_category_t::LP, settings.presolver, @@ -1971,16 +1971,16 @@ optimization_problem_solution_t solve_lp( 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()); } @@ -2036,7 +2036,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", @@ -2333,7 +2333,7 @@ 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); \ diff --git a/cpp/src/pdlp/solve.cuh b/cpp/src/pdlp/solve.cuh index 0447e8bfee..af6fd4acc2 100644 --- a/cpp/src/pdlp/solve.cuh +++ b/cpp/src/pdlp/solve.cuh @@ -15,10 +15,10 @@ namespace cuopt::math_optimization { -namespace detail { +namespace mip { template class problem_t; -} // namespace detail +} // namespace mip template cuopt::math_optimization::optimization_problem_t mps_data_model_to_optimization_problem( @@ -27,7 +27,7 @@ cuopt::math_optimization::optimization_problem_t mps_data_model_to_opt template cuopt::math_optimization::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 = false); diff --git a/cpp/src/pdlp/termination_strategy/convergence_information.cu b/cpp/src/pdlp/termination_strategy/convergence_information.cu index 7f31189eaf..ad9e1ee70b 100644 --- a/cpp/src/pdlp/termination_strategy/convergence_information.cu +++ b/cpp/src/pdlp/termination_strategy/convergence_information.cu @@ -37,7 +37,7 @@ namespace cuopt::math_optimization::pdlp { template convergence_information_t::convergence_information_t( raft::handle_t const* handle_ptr, - detail::problem_t& op_problem, + mip::problem_t& op_problem, cusparse_view_t& cusparse_view, i_t primal_size, i_t dual_size, diff --git a/cpp/src/pdlp/termination_strategy/convergence_information.hpp b/cpp/src/pdlp/termination_strategy/convergence_information.hpp index da3c6de213..51d8ddd260 100644 --- a/cpp/src/pdlp/termination_strategy/convergence_information.hpp +++ b/cpp/src/pdlp/termination_strategy/convergence_information.hpp @@ -30,7 +30,7 @@ template class convergence_information_t { public: convergence_information_t(raft::handle_t const* handle_ptr, - detail::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_; - detail::problem_t* problem_ptr; + mip::problem_t* problem_ptr; cusparse_view_t& op_problem_cusparse_view_; rmm::device_uvector l2_norm_primal_linear_objective_; diff --git a/cpp/src/pdlp/termination_strategy/infeasibility_information.cu b/cpp/src/pdlp/termination_strategy/infeasibility_information.cu index b7a6e80a9f..07fde352ba 100644 --- a/cpp/src/pdlp/termination_strategy/infeasibility_information.cu +++ b/cpp/src/pdlp/termination_strategy/infeasibility_information.cu @@ -38,8 +38,8 @@ namespace cuopt::math_optimization::pdlp { template infeasibility_information_t::infeasibility_information_t( raft::handle_t const* handle_ptr, - detail::problem_t& op_problem, - const detail::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, diff --git a/cpp/src/pdlp/termination_strategy/infeasibility_information.hpp b/cpp/src/pdlp/termination_strategy/infeasibility_information.hpp index f0ade6ad0a..1f30e6a96f 100644 --- a/cpp/src/pdlp/termination_strategy/infeasibility_information.hpp +++ b/cpp/src/pdlp/termination_strategy/infeasibility_information.hpp @@ -28,8 +28,8 @@ template class infeasibility_information_t { public: infeasibility_information_t(raft::handle_t const* handle_ptr, - detail::problem_t& op_problem, - const detail::problem_t& + 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, @@ -90,7 +90,7 @@ class infeasibility_information_t { i_t primal_size_h_; i_t dual_size_h_; - detail::problem_t* problem_ptr; + mip::problem_t* problem_ptr; cusparse_view_t& op_problem_cusparse_view_; const cusparse_view_t& scaled_cusparse_view_; @@ -130,7 +130,7 @@ class infeasibility_information_t { const rmm::device_scalar reusable_device_scalar_value_neg_1_; const pdlp_initial_scaling_strategy_t& scaling_strategy_; - const detail::problem_t& op_problem_scaled_; + const mip::problem_t& op_problem_scaled_; detail::segmented_sum_handler_t segmented_sum_handler_; const std::vector& climber_strategies_; diff --git a/cpp/src/pdlp/termination_strategy/termination_strategy.cu b/cpp/src/pdlp/termination_strategy/termination_strategy.cu index 0e6f91aa84..e08748a29a 100644 --- a/cpp/src/pdlp/termination_strategy/termination_strategy.cu +++ b/cpp/src/pdlp/termination_strategy/termination_strategy.cu @@ -24,8 +24,8 @@ namespace cuopt::math_optimization::pdlp { template pdlp_termination_strategy_t::pdlp_termination_strategy_t( raft::handle_t const* handle_ptr, - detail::problem_t& op_problem, - const detail::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, diff --git a/cpp/src/pdlp/termination_strategy/termination_strategy.hpp b/cpp/src/pdlp/termination_strategy/termination_strategy.hpp index 3a783d949d..c1347c3c39 100644 --- a/cpp/src/pdlp/termination_strategy/termination_strategy.hpp +++ b/cpp/src/pdlp/termination_strategy/termination_strategy.hpp @@ -32,8 +32,8 @@ template class pdlp_termination_strategy_t { public: pdlp_termination_strategy_t(raft::handle_t const* handle_ptr, - detail::problem_t& op_problem, - const detail::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_; - detail::problem_t* problem_ptr; + mip::problem_t* problem_ptr; convergence_information_t convergence_information_; infeasibility_information_t infeasibility_information_; diff --git a/cpp/src/pdlp/translate.hpp b/cpp/src/pdlp/translate.hpp index 6d4cf8b638..ded19601e9 100644 --- a/cpp/src/pdlp/translate.hpp +++ b/cpp/src/pdlp/translate.hpp @@ -101,7 +101,7 @@ 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) + raft::handle_t const* handle_ptr, mip::problem_t& model) { dual_simplex::user_problem_t user_problem(handle_ptr); @@ -323,7 +323,7 @@ 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) diff --git a/cpp/src/pdlp/utilities/problem_checking.cu b/cpp/src/pdlp/utilities/problem_checking.cu index 028882fd7d..6307e2f283 100644 --- a/cpp/src/pdlp/utilities/problem_checking.cu +++ b/cpp/src/pdlp/utilities/problem_checking.cu @@ -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; diff --git a/cpp/src/pdlp/utilities/problem_checking.cuh b/cpp/src/pdlp/utilities/problem_checking.cuh index 708622037a..15f7423e8c 100644 --- a/cpp/src/pdlp/utilities/problem_checking.cuh +++ b/cpp/src/pdlp/utilities/problem_checking.cuh @@ -17,10 +17,10 @@ class device_uvector; namespace cuopt::math_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, diff --git a/cpp/src/pdlp/utils.cuh b/cpp/src/pdlp/utils.cuh index 20028e0565..1dd22df1cb 100644 --- a/cpp/src/pdlp/utils.cuh +++ b/cpp/src/pdlp/utils.cuh @@ -265,7 +265,7 @@ struct rhs_sum_of_squares_t { }; template -void inline combine_constraint_bounds(const detail::problem_t& op_problem, +void inline combine_constraint_bounds(const mip::problem_t& op_problem, rmm::device_uvector& combined_bounds) { cuopt_assert( diff --git a/cpp/tests/linear_programming/pdlp_test.cu b/cpp/tests/linear_programming/pdlp_test.cu index 6086cf98a3..d85dde3a8b 100644 --- a/cpp/tests/linear_programming/pdlp_test.cu +++ b/cpp/tests/linear_programming/pdlp_test.cu @@ -472,7 +472,7 @@ TEST(pdlp_class, initial_solution_test) auto op_problem = cuopt::math_optimization::mps_data_model_to_optimization_problem( &handle_, mps_data_model); - cuopt::math_optimization::detail::problem_t problem(op_problem); + cuopt::math_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 @@ -750,7 +750,7 @@ TEST(pdlp_class, initial_primal_weight_step_size_test) auto op_problem = cuopt::math_optimization::mps_data_model_to_optimization_problem( &handle_, mps_data_model); - cuopt::math_optimization::detail::problem_t problem(op_problem); + cuopt::math_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 @@ -854,7 +854,7 @@ End raft::copy( d_initial_primal.data(), h_initial_primal.data(), h_initial_primal.size(), handle.get_stream()); - auto problem = cuopt::math_optimization::detail::problem_t(op_problem); + auto problem = cuopt::math_optimization::mip::problem_t(op_problem); pdlp_solver_settings_t solver_settings; solver_settings.tolerances.relative_primal_tolerance = 0; // Shouldn't matter @@ -4082,7 +4082,7 @@ TEST(pdlp_class, precision_single_pslp_presolve) TEST(pdlp_class, shared_sb_context_unit) { - using namespace cuopt::math_optimization::dual_simplex; + using namespace cuopt::math_optimization::mip; constexpr int N = 10; shared_strong_branching_context_t ctx(N); @@ -4129,7 +4129,7 @@ TEST(pdlp_class, shared_sb_context_unit) TEST(pdlp_class, shared_sb_view_batch_pre_solved) { - using namespace cuopt::math_optimization::dual_simplex; + using namespace cuopt::math_optimization::mip; const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/afiro_original.mps"); @@ -4189,7 +4189,7 @@ TEST(pdlp_class, shared_sb_view_batch_pre_solved) TEST(pdlp_class, shared_sb_view_concurrent_mark) { - using namespace cuopt::math_optimization::dual_simplex; + using namespace cuopt::math_optimization::mip; const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/afiro_original.mps"); @@ -4261,7 +4261,7 @@ TEST(pdlp_class, shared_sb_view_concurrent_mark) TEST(pdlp_class, shared_sb_view_all_infeasible) { - using namespace cuopt::math_optimization::dual_simplex; + using namespace cuopt::math_optimization::mip; const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/afiro_original.mps"); @@ -4475,7 +4475,7 @@ TEST(pdlp_class, batch_bound_objective_rescaling_factors_match_input_expansion) hyper_params.do_pock_chambolle_scaling = false; hyper_params.bound_objective_rescaling = true; - cuopt::math_optimization::detail::problem_t problem(gpu_op); + cuopt::math_optimization::mip::problem_t problem(gpu_op); cuopt::math_optimization::pdlp::pdlp_initial_scaling_strategy_t scaling( &handle_, problem, diff --git a/cpp/tests/mip/bounds_standardization_test.cu b/cpp/tests/mip/bounds_standardization_test.cu index 684f2f62ea..316996dbbb 100644 --- a/cpp/tests/mip/bounds_standardization_test.cu +++ b/cpp/tests/mip/bounds_standardization_test.cu @@ -52,20 +52,20 @@ void test_bounds_standardization_test(std::string test_instance) 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 diff --git a/cpp/tests/mip/cuts_test.cu b/cpp/tests/mip/cuts_test.cu index bc2aa398e7..50ae39f9c6 100644 --- a/cpp/tests/mip/cuts_test.cu +++ b/cpp/tests/mip/cuts_test.cu @@ -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); + mip::problem_t mip_problem(op_problem); dual_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); @@ -176,23 +176,22 @@ io::mps_data_model_t& get_neos8_model_cached() 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 +278,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 +464,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 +511,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()); @@ -849,48 +848,48 @@ 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; + 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(); } @@ -1361,7 +1360,7 @@ 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); + mip::problem_t mip_problem(op_problem); dual_simplex::user_problem_t host_problem(op_problem.get_handle_ptr()); mip_problem.get_host_user_problem(host_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, diff --git a/cpp/tests/mip/elim_var_remap_test.cu b/cpp/tests/mip/elim_var_remap_test.cu index 64019f2359..4dd404fa1d 100644 --- a/cpp/tests/mip/elim_var_remap_test.cu +++ b/cpp/tests/mip/elim_var_remap_test.cu @@ -68,7 +68,7 @@ void test_elim_var_remap(std::string test_instance) 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(), @@ -135,21 +135,21 @@ void test_elim_var_solution(std::string test_instance) 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); diff --git a/cpp/tests/mip/feasibility_jump_tests.cu b/cpp/tests/mip/feasibility_jump_tests.cu index 9233106d6a..155fb9126b 100644 --- a/cpp/tests/mip/feasibility_jump_tests.cu +++ b/cpp/tests/mip/feasibility_jump_tests.cu @@ -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 = {}) { @@ -76,16 +76,16 @@ static fj_state_t run_fj(std::string test_instance, 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; diff --git a/cpp/tests/mip/load_balancing_test.cu b/cpp/tests/mip/load_balancing_test.cu index 4aae391570..fd2a9b4338 100644 --- a/cpp/tests/mip/load_balancing_test.cu +++ b/cpp/tests/mip/load_balancing_test.cu @@ -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) { @@ -126,14 +126,14 @@ void test_multi_probe(std::string path) 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); diff --git a/cpp/tests/mip/multi_probe_test.cu b/cpp/tests/mip/multi_probe_test.cu index 1094c62186..723bb717a9 100644 --- a/cpp/tests/mip/multi_probe_test.cu +++ b/cpp/tests/mip/multi_probe_test.cu @@ -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); @@ -148,12 +148,12 @@ void test_multi_probe(std::string path) 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); diff --git a/cpp/tests/mip/presolve_test.cu b/cpp/tests/mip/presolve_test.cu index 12ecec3736..ca357b814e 100644 --- a/cpp/tests/mip/presolve_test.cu +++ b/cpp/tests/mip/presolve_test.cu @@ -36,7 +36,7 @@ TEST(problem, find_implied_integers) auto path = make_path_absolute("mip/fiball.mps"); auto mps_data_model = cuopt::math_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::math_optimization::problem_category_t::MIP, cuopt::math_optimization::presolver_t::Papilo, @@ -45,10 +45,10 @@ TEST(problem, find_implied_integers) 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::math_optimization::test diff --git a/cpp/tests/mip/problem_test.cu b/cpp/tests/mip/problem_test.cu index 2970d7f6b7..c1d6e20726 100644 --- a/cpp/tests/mip/problem_test.cu +++ b/cpp/tests/mip/problem_test.cu @@ -42,7 +42,7 @@ namespace cuopt::math_optimization::test { namespace lp = cuopt::math_optimization; -namespace dtl = cuopt::math_optimization::detail; +namespace dtl = cuopt::math_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); } @@ -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::math_optimization::detail::problem_t problem(op_problem); + cuopt::math_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::math_optimization::detail::problem_t problem(op_problem); + cuopt::math_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::math_optimization::detail::problem_t problem(op_problem); + cuopt::math_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::math_optimization::detail::problem_t; + using custom_problem_t = cuopt::math_optimization::mip::problem_t; // Check if assert if nothing EXPECT_DEATH({ custom_problem_t problem(op_problem); }, ""); diff --git a/cpp/tests/mip/unit_test.cu b/cpp/tests/mip/unit_test.cu index b180a9cd76..02b2e3404f 100644 --- a/cpp/tests/mip/unit_test.cu +++ b/cpp/tests/mip/unit_test.cu @@ -267,7 +267,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 +318,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 = From 92bd0d9d4400ea7f0651c6bc5b5d330f94c099b8 Mon Sep 17 00:00:00 2001 From: Miles Lubin Date: Sun, 21 Jun 2026 00:37:33 +0000 Subject: [PATCH 06/17] refactor: fold stray primal/dual/phase2 namespaces into dual_simplex Co-Authored-By: Claude Opus 4.8 (1M context) Signed-off-by: Miles Lubin --- cpp/src/branch_and_bound/branch_and_bound.cpp | 168 ++-- cpp/src/branch_and_bound/branch_and_bound.hpp | 12 +- cpp/src/branch_and_bound/pseudo_costs.cpp | 159 ++-- cpp/src/dual_simplex/crossover.cpp | 16 +- cpp/src/dual_simplex/phase2.cpp | 769 +++++++++--------- cpp/src/dual_simplex/phase2.hpp | 72 +- cpp/src/dual_simplex/primal.cpp | 40 +- cpp/src/dual_simplex/primal.hpp | 18 +- cpp/src/dual_simplex/solve.cpp | 62 +- 9 files changed, 650 insertions(+), 666 deletions(-) diff --git a/cpp/src/branch_and_bound/branch_and_bound.cpp b/cpp/src/branch_and_bound/branch_and_bound.cpp index 55ff8d2043..c529438f5e 100644 --- a/cpp/src/branch_and_bound/branch_and_bound.cpp +++ b/cpp/src/branch_and_bound/branch_and_bound.cpp @@ -147,28 +147,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; } } @@ -582,11 +582,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 = 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; @@ -1204,7 +1204,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; @@ -1217,20 +1217,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); @@ -1308,10 +1308,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 { @@ -1330,7 +1330,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}; @@ -1380,7 +1380,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, @@ -1452,7 +1452,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 @@ -1477,9 +1477,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); } @@ -1505,7 +1505,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, @@ -1621,24 +1621,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; } @@ -1890,15 +1890,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); @@ -2321,31 +2321,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_, @@ -2363,7 +2363,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", dual_status_to_string(cut_status).c_str()); #ifdef WRITE_CUT_INFEASIBLE_MPS original_lp_.write_mps("cut_infeasible.mps"); #endif @@ -3526,22 +3526,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, @@ -4140,22 +4140,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, @@ -4175,8 +4175,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; } diff --git a/cpp/src/branch_and_bound/branch_and_bound.hpp b/cpp/src/branch_and_bound/branch_and_bound.hpp index 4de3707ad3..66400d27e0 100644 --- a/cpp/src/branch_and_bound/branch_and_bound.hpp +++ b/cpp/src/branch_and_bound/branch_and_bound.hpp @@ -336,10 +336,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); + 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); // Apply symmetry-based bound reductions (orbital fixing and, when // settings_.symmetry == 2, lexical reduction) to the current node. @@ -360,7 +360,7 @@ class branch_and_bound_t { mip_node_t* node_ptr, search_tree_t& search_tree, WorkerT* worker, - dual::status_t lp_status, + dual_status_t lp_status, Policy& policy); // Opportunistic tree update wrapper. @@ -368,7 +368,7 @@ 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, + dual_status_t lp_status, logger_t& log); // ============================================================================ diff --git a/cpp/src/branch_and_bound/pseudo_costs.cpp b/cpp/src/branch_and_bound/pseudo_costs.cpp index 9f98d008af..a7589b4be8 100644 --- a/cpp/src/branch_and_bound/pseudo_costs.cpp +++ b/cpp/src/branch_and_bound/pseudo_costs.cpp @@ -31,10 +31,10 @@ using namespace cuopt::math_optimization::dual_simplex; // shared simplex types // etc.) 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 @@ -308,8 +308,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) { @@ -361,22 +361,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 = 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", @@ -457,21 +457,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; @@ -497,36 +497,36 @@ 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 = 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(), + 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}; } } @@ -660,34 +660,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}; } @@ -1062,8 +1062,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(); @@ -1160,15 +1160,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; } } } @@ -1207,14 +1207,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); @@ -1742,8 +1741,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(); diff --git a/cpp/src/dual_simplex/crossover.cpp b/cpp/src/dual_simplex/crossover.cpp index 50165e7785..98a785847f 100644 --- a/cpp/src/dual_simplex/crossover.cpp +++ b/cpp/src/dual_simplex/crossover.cpp @@ -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; diff --git a/cpp/src/dual_simplex/phase2.cpp b/cpp/src/dual_simplex/phase2.cpp index e42157bc4d..076e3af56e 100644 --- a/cpp/src/dual_simplex/phase2.cpp +++ b/cpp/src/dual_simplex/phase2.cpp @@ -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 @@ -2348,16 +2346,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 +2370,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 +2393,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 " @@ -2491,19 +2489,17 @@ class phase2_timers_t { bool record_time; }; -} // 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 +2525,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 +2566,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"); @@ -2579,7 +2575,7 @@ dual::status_t dual_phase2_with_advanced_basis(i_t phase, std::vector z_old = z; phase2_work_estimate += 4 * n; - phase2::bound_info(lp, settings); + bound_info(lp, settings); phase2_work_estimate += 2 * n; f_t refactor_work = 0.0; @@ -2601,11 +2597,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,20 +2613,19 @@ 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( "|| y || %e || cB || %e\n", vector_norm_inf(y), vector_norm_inf(c_basic)); } - phase2::compute_reduced_costs( - objective, lp.A, y, basic_list, nonbasic_list, z, phase2_work_estimate); + compute_reduced_costs(objective, lp.A, y, basic_list, nonbasic_list, z, phase2_work_estimate); if constexpr (print_norms) { settings.log.printf("|| z || %e\n", vector_norm_inf(z)); } #ifdef COMPUTE_DUAL_RESIDUAL std::vector dual_res1; - phase2::compute_dual_residual(lp.A, objective, y, z, dual_res1); + compute_dual_residual(lp.A, objective, y, z, dual_res1); f_t dual_res_norm = vector_norm_inf(dual_res1); if (dual_res_norm > settings.tight_tol) { settings.log.printf("|| A'*y + z - c || %e\n", dual_res_norm); @@ -2638,19 +2633,19 @@ dual::status_t dual_phase2_with_advanced_basis(i_t phase, assert(dual_res_norm < 1e-3); #endif - phase2::set_primal_variables_on_bounds(lp, settings, z, vstatus, x); + set_primal_variables_on_bounds(lp, settings, z, vstatus, x); phase2_work_estimate += 5 * (n - m); #ifdef PRINT_VSTATUS_CHANGES i_t num_vstatus_changes; i_t num_z_changes; - phase2::vstatus_changes(vstatus, vstatus_old, z, z_old, num_vstatus_changes, num_z_changes); + vstatus_changes(vstatus, vstatus_old, z, z_old, num_vstatus_changes, num_z_changes); settings.log.printf("Number of vstatus changes %d\n", num_vstatus_changes); settings.log.printf("Number of z changes %d\n", num_z_changes); #endif const f_t init_dual_inf = - phase2::dual_infeasibility(lp, settings, vstatus, z, settings.tight_tol, settings.dual_tol); + dual_infeasibility(lp, settings, vstatus, z, settings.tight_tol, settings.dual_tol); phase2_work_estimate += 3 * n; if (init_dual_inf > settings.dual_tol) { settings.log.printf("Initial dual infeasibility %e\n", init_dual_inf); @@ -2663,17 +2658,17 @@ dual::status_t dual_phase2_with_advanced_basis(i_t phase, } phase2_work_estimate += 3 * n; - phase2::compute_primal_variables(ft, - lp.rhs, - lp.A, - basic_list, - nonbasic_list, - settings.tight_tol, - x, - xB_workspace, - phase2_work_estimate); - - if (toc(start_time) > settings.time_limit) { return dual::status_t::TIME_LIMIT; } + compute_primal_variables(ft, + lp.rhs, + lp.A, + basic_list, + nonbasic_list, + settings.tight_tol, + x, + xB_workspace, + phase2_work_estimate); + + 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 @@ -2690,18 +2685,18 @@ dual::status_t dual_phase2_with_advanced_basis(i_t phase, delta_y_steepest_edge.resize(n); phase2_work_estimate += n; if (slack_basis) { - phase2::initialize_steepest_edge_norms_from_slack_basis( + initialize_steepest_edge_norms_from_slack_basis( basic_list, nonbasic_list, delta_y_steepest_edge); phase2_work_estimate += 2 * n; } else { std::fill(delta_y_steepest_edge.begin(), delta_y_steepest_edge.end(), -1); phase2_work_estimate += n; f_t steepest_edge_start = tic(); - i_t status = phase2::initialize_steepest_edge_norms( + i_t status = 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 +2710,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) { @@ -2743,33 +2738,31 @@ dual::status_t dual_phase2_with_advanced_basis(i_t phase, delta_z_indices.reserve(n); phase2_work_estimate += n; - phase2::reset_basis_mark( - basic_list, nonbasic_list, basic_mark, nonbasic_mark, phase2_work_estimate); + reset_basis_mark(basic_list, nonbasic_list, basic_mark, nonbasic_mark, phase2_work_estimate); std::vector bounded_variables(n, 0); - phase2::compute_bounded_info(lp.lower, lp.upper, bounded_variables); + compute_bounded_info(lp.lower, lp.upper, bounded_variables); phase2_work_estimate += 4 * n; f_t primal_infeasibility; - f_t primal_infeasibility_squared = - phase2::compute_initial_primal_infeasibilities(lp, - settings, - basic_list, - x, - squared_infeasibilities, - infeasibility_indices, - primal_infeasibility); + f_t primal_infeasibility_squared = compute_initial_primal_infeasibilities(lp, + settings, + basic_list, + x, + squared_infeasibilities, + infeasibility_indices, + primal_infeasibility); phase2_work_estimate += 4 * m + 2 * n; #ifdef CHECK_BASIC_INFEASIBILITIES - phase2::check_basic_infeasibilities(basic_list, basic_mark, infeasibility_indices, 0); + check_basic_infeasibilities(basic_list, basic_mark, infeasibility_indices, 0); #endif csr_matrix_t Arow(1, 1, 0); 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 +2772,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); @@ -2792,7 +2785,7 @@ dual::status_t dual_phase2_with_advanced_basis(i_t phase, i_t num_refactors = 0; i_t total_bound_flips = 0; f_t delta_y_nz_percentage = 0.0; - phase2::phase2_timers_t timers(false); + phase2_timers_t timers(false); // Sparse vectors for main loop (declared outside loop for instrumentation) sparse_vector_t delta_y_sparse(m, 0); @@ -2838,20 +2831,20 @@ dual::status_t dual_phase2_with_advanced_basis(i_t phase, { PHASE2_NVTX_RANGE("DualSimplex::pricing"); if (settings.use_steepest_edge_pricing) { - leaving_index = phase2::steepest_edge_pricing_with_infeasibilities(lp, - settings, - x, - delta_y_steepest_edge, - basic_mark, - squared_infeasibilities, - infeasibility_indices, - direction, - basic_leaving_index, - max_val, - phase2_work_estimate); + leaving_index = steepest_edge_pricing_with_infeasibilities(lp, + settings, + x, + delta_y_steepest_edge, + basic_mark, + squared_infeasibilities, + infeasibility_indices, + direction, + basic_leaving_index, + max_val, + phase2_work_estimate); } else { // Max infeasibility pricing - leaving_index = phase2::phase2_pricing( + leaving_index = phase2_pricing( lp, settings, x, basic_list, direction, basic_leaving_index, primal_infeasibility); } } @@ -2888,14 +2881,13 @@ dual::status_t dual_phase2_with_advanced_basis(i_t phase, #endif #ifdef CHECK_PRIMAL_INFEASIBILITIES - primal_infeasibility_squared = - phase2::compute_initial_primal_infeasibilities(lp, - settings, - basic_list, - x, - squared_infeasibilities, - infeasibility_indices, - primal_infeasibility); + primal_infeasibility_squared = compute_initial_primal_infeasibilities(lp, + settings, + basic_list, + x, + squared_infeasibilities, + infeasibility_indices, + primal_infeasibility); if (primal_infeasibility > settings.primal_tol) { const i_t nz = infeasibility_indices.size(); for (i_t k = 0; k < nz; ++k) { @@ -2934,28 +2926,26 @@ 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( + reset_basis_mark( basic_list, nonbasic_list, basic_mark, nonbasic_mark, phase2_work_estimate); compute_initial_nonbasic_end(basic_mark, Arow, nonbasic_end); - phase2::compute_primal_solution_from_basis( + compute_primal_solution_from_basis( lp, ft, basic_list, nonbasic_list, vstatus, x, xB_workspace, phase2_work_estimate); primal_infeasibility_squared = - phase2::compute_initial_primal_infeasibilities(lp, - settings, - basic_list, - x, - squared_infeasibilities, - infeasibility_indices, - primal_infeasibility); + compute_initial_primal_infeasibilities(lp, + settings, + basic_list, + x, + squared_infeasibilities, + infeasibility_indices, + primal_infeasibility); phase2_work_estimate += 4 * m + 2 * n; iterations_since_refactor = 0; solve_work = 0.0; @@ -2970,31 +2960,31 @@ dual::status_t dual_phase2_with_advanced_basis(i_t phase, } } - phase2::prepare_optimality(0, - primal_infeasibility, - lp, - settings, - ft, - objective, - basic_list, - nonbasic_list, - vstatus, - phase, - start_time, - max_val, - iter, - x, - y, - z, - sol); - status = dual::status_t::OPTIMAL; + prepare_optimality(0, + primal_infeasibility, + lp, + settings, + ft, + objective, + basic_list, + nonbasic_list, + vstatus, + phase, + start_time, + max_val, + iter, + x, + y, + z, + sol); + 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 @@ -3005,13 +2995,13 @@ dual::status_t dual_phase2_with_advanced_basis(i_t phase, f_t btran_start_work = ft.work_estimate(); { PHASE2_NVTX_RANGE("DualSimplex::btran"); - phase2::compute_delta_y(ft, basic_leaving_index, direction, delta_y_sparse, UTsol_sparse); + compute_delta_y(ft, basic_leaving_index, direction, delta_y_sparse, UTsol_sparse); } timers.btran_time += timers.stop_timer(); 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 +3062,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 @@ -3080,7 +3070,7 @@ dual::status_t dual_phase2_with_advanced_basis(i_t phase, std::vector zeros(n, 0.0); std::vector delta_y_dense(m); delta_y_sparse.to_dense(delta_y_dense); - phase2::compute_dual_residual(lp.A, zeros, delta_y_dense, delta_z, dual_residual); + compute_dual_residual(lp.A, zeros, delta_y_dense, delta_z, dual_residual); // || A'*delta_y + delta_z ||_inf f_t dual_residual_norm = vector_norm_inf(dual_residual); settings.log.printf( @@ -3096,15 +3086,15 @@ dual::status_t dual_phase2_with_advanced_basis(i_t phase, { PHASE2_NVTX_RANGE("DualSimplex::ratio_test"); if (harris_ratio) { - f_t max_step_length = phase2::first_stage_harris(lp, vstatus, nonbasic_list, z, delta_z); - entering_index = phase2::second_stage_harris(lp, - vstatus, - nonbasic_list, - z, - delta_z, - max_step_length, - step_length, - nonbasic_entering_index); + f_t max_step_length = first_stage_harris(lp, vstatus, nonbasic_list, z, delta_z); + entering_index = second_stage_harris(lp, + vstatus, + nonbasic_list, + z, + delta_z, + max_step_length, + step_length, + nonbasic_entering_index); } else if (bound_flip_ratio) { timers.start_timer(); f_t slope = direction == 1 ? (lp.lower[leaving_index] - x[leaving_index]) @@ -3127,20 +3117,20 @@ 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 { - entering_index = phase2::phase2_ratio_test( + entering_index = phase2_ratio_test( 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); - f_t perturbation = phase2::amount_of_perturbation(lp, objective); + f_t perturbation = amount_of_perturbation(lp, objective); phase2_work_estimate += 2 * n; if (perturbation > 0.0 && phase == 2) { @@ -3148,10 +3138,10 @@ dual::status_t dual_phase2_with_advanced_basis(i_t phase, std::vector unperturbed_y(m); std::vector unperturbed_z(n); phase2_work_estimate += m + n; - phase2::compute_dual_solution_from_basis( + compute_dual_solution_from_basis( lp, ft, basic_list, nonbasic_list, unperturbed_y, unperturbed_z, phase2_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); phase2_work_estimate += 3 * n; settings.log.printf("Dual infeasibility after removing perturbation %e\n", dual_infeas); @@ -3164,106 +3154,105 @@ dual::status_t dual_phase2_with_advanced_basis(i_t phase, std::vector unperturbed_x(n); phase2_work_estimate += n; - phase2::compute_primal_solution_from_basis(lp, - ft, - basic_list, - nonbasic_list, - vstatus, - unperturbed_x, - xB_workspace, - phase2_work_estimate); + compute_primal_solution_from_basis(lp, + ft, + basic_list, + nonbasic_list, + vstatus, + unperturbed_x, + xB_workspace, + phase2_work_estimate); x = unperturbed_x; primal_infeasibility_squared = - phase2::compute_initial_primal_infeasibilities(lp, - settings, - basic_list, - x, - squared_infeasibilities, - infeasibility_indices, - primal_infeasibility); + compute_initial_primal_infeasibilities(lp, + settings, + basic_list, + x, + squared_infeasibilities, + infeasibility_indices, + primal_infeasibility); phase2_work_estimate += 4 * m + 2 * n; settings.log.printf("Updated primal infeasibility: %e\n", primal_infeasibility); objective = lp.objective; phase2_work_estimate += 2 * n; // Need to reset the objective value, since we have recomputed x - obj = phase2::compute_perturbed_objective(objective, x); + obj = compute_perturbed_objective(objective, x); phase2_work_estimate += 2 * n; if (dual_infeas <= settings.dual_tol && primal_infeasibility <= settings.primal_tol) { - phase2::prepare_optimality(1, - primal_infeasibility, - lp, - settings, - ft, - objective, - basic_list, - nonbasic_list, - vstatus, - phase, - start_time, - max_val, - iter, - x, - y, - z, - sol); - status = dual::status_t::OPTIMAL; + prepare_optimality(1, + primal_infeasibility, + lp, + settings, + ft, + objective, + basic_list, + nonbasic_list, + vstatus, + phase, + start_time, + max_val, + iter, + x, + y, + z, + sol); + status = dual_status_t::OPTIMAL; break; } settings.log.printf( "Continuing with perturbation removed and steepest edge norms reset\n"); // Clear delta_z before restarting the iteration phase2_work_estimate += 3 * delta_z_indices.size(); - phase2::clear_delta_z( - entering_index, leaving_index, delta_z_mark, delta_z_indices, delta_z); + clear_delta_z(entering_index, leaving_index, delta_z_mark, delta_z_indices, delta_z); continue; } else { std::vector unperturbed_x(n); phase2_work_estimate += n; - phase2::compute_primal_solution_from_basis(lp, - ft, - basic_list, - nonbasic_list, - vstatus, - unperturbed_x, - xB_workspace, - phase2_work_estimate); + compute_primal_solution_from_basis(lp, + ft, + basic_list, + nonbasic_list, + vstatus, + unperturbed_x, + xB_workspace, + phase2_work_estimate); x = unperturbed_x; phase2_work_estimate += 2 * n; primal_infeasibility_squared = - phase2::compute_initial_primal_infeasibilities(lp, - settings, - basic_list, - x, - squared_infeasibilities, - infeasibility_indices, - primal_infeasibility); + compute_initial_primal_infeasibilities(lp, + settings, + basic_list, + x, + squared_infeasibilities, + infeasibility_indices, + primal_infeasibility); phase2_work_estimate += 4 * m + 2 * n; - const f_t orig_dual_infeas = phase2::dual_infeasibility( - lp, settings, vstatus, z, settings.tight_tol, settings.dual_tol); + const f_t orig_dual_infeas = + dual_infeasibility(lp, settings, vstatus, z, settings.tight_tol, settings.dual_tol); phase2_work_estimate += 3 * n; if (primal_infeasibility <= settings.primal_tol && orig_dual_infeas <= settings.dual_tol) { - phase2::prepare_optimality(2, - primal_infeasibility, - lp, - settings, - ft, - objective, - basic_list, - nonbasic_list, - vstatus, - phase, - start_time, - max_val, - iter, - x, - y, - z, - sol); - status = dual::status_t::OPTIMAL; + prepare_optimality(2, + primal_infeasibility, + lp, + settings, + ft, + objective, + basic_list, + nonbasic_list, + vstatus, + phase, + start_time, + max_val, + iter, + x, + y, + z, + sol); + status = dual_status_t::OPTIMAL; break; } settings.log.printf("Failed to remove perturbation of %.2e.\n", perturbation); @@ -3282,30 +3271,30 @@ dual::status_t dual_phase2_with_advanced_basis(i_t phase, delta_y_sparse.to_dense(my_delta_y); // TODO(CMM): Do I use the perturbed or unperturbed objective? - const f_t obj_val = phase2::compute_perturbed_objective(objective, x); - phase2::compute_farkas_certificate(lp, - settings, - vstatus, - x, - y, - z, - my_delta_y, - delta_z, - direction, - leaving_index, - obj_val, - farkas_y, - farkas_zl, - farkas_zu, - farkas_constant); + const f_t obj_val = compute_perturbed_objective(objective, x); + compute_farkas_certificate(lp, + settings, + vstatus, + x, + y, + z, + my_delta_y, + delta_z, + direction, + leaving_index, + obj_val, + farkas_y, + farkas_zl, + farkas_zu, + farkas_constant); } } const f_t dual_infeas = - phase2::dual_infeasibility(lp, settings, vstatus, z, settings.tight_tol, settings.dual_tol); + 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 = dual_simplex::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,32 +3302,32 @@ 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(); // Update dual variables // y <- y + steplength * delta_y // z <- z + steplength * delta_z - i_t update_dual_variables_status = phase2::update_dual_variables(delta_y_sparse, - delta_z_indices, - delta_z, - step_length, - leaving_index, - y, - z, - phase2_work_estimate); + i_t update_dual_variables_status = update_dual_variables(delta_y_sparse, + delta_z_indices, + delta_z, + step_length, + leaving_index, + y, + z, + 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(); #ifdef COMPUTE_DUAL_RESIDUAL std::vector dual_res1; - phase2::compute_dual_residual(lp.A, objective, y, z, dual_res1); + compute_dual_residual(lp.A, objective, y, z, dual_res1); f_t dual_res_norm = vector_norm_inf(dual_res1); if (dual_res_norm > settings.dual_tol) { settings.log.printf("|| A'*y + z - c || %e steplength %e\n", dual_res_norm, step_length); @@ -3347,20 +3336,20 @@ dual::status_t dual_phase2_with_advanced_basis(i_t phase, timers.start_timer(); // Update primal variable - const i_t num_flipped = phase2::flip_bounds(lp, - settings, - bounded_variables, - objective, - z, - delta_z_indices, - nonbasic_list, - entering_index, - vstatus, - delta_x_flip, - atilde_mark, - atilde, - atilde_index, - phase2_work_estimate); + const i_t num_flipped = flip_bounds(lp, + settings, + bounded_variables, + objective, + z, + delta_z_indices, + nonbasic_list, + entering_index, + vstatus, + delta_x_flip, + atilde_mark, + atilde, + atilde_index, + phase2_work_estimate); timers.flip_time += timers.stop_timer(); total_bound_flips += num_flipped; @@ -3368,17 +3357,17 @@ dual::status_t dual_phase2_with_advanced_basis(i_t phase, delta_xB_0_sparse.clear(); if (num_flipped > 0) { timers.start_timer(); - phase2::adjust_for_flips(ft, - basic_list, - delta_z_indices, - atilde_index, - atilde, - atilde_mark, - atilde_sparse, - delta_xB_0_sparse, - delta_x_flip, - x, - phase2_work_estimate); + adjust_for_flips(ft, + basic_list, + delta_z_indices, + atilde_index, + atilde, + atilde_mark, + atilde_sparse, + delta_xB_0_sparse, + delta_x_flip, + x, + phase2_work_estimate); timers.ftran_time += timers.stop_timer(); } @@ -3389,29 +3378,29 @@ dual::status_t dual_phase2_with_advanced_basis(i_t phase, f_t ftran_start_work = ft.work_estimate(); { PHASE2_NVTX_RANGE("DualSimplex::ftran"); - if (phase2::compute_delta_x(lp, - ft, - entering_index, - leaving_index, - basic_leaving_index, - direction, - basic_list, - delta_x_flip, - rhs_sparse, - delta_z, - x, - utilde_sparse, - scaled_delta_xB_sparse, - delta_x, - phase2_work_estimate) == -1) { + if (compute_delta_x(lp, + ft, + entering_index, + leaving_index, + basic_leaving_index, + direction, + basic_list, + delta_x_flip, + rhs_sparse, + delta_z, + x, + utilde_sparse, + scaled_delta_xB_sparse, + 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 @@ -3423,19 +3412,19 @@ dual::status_t dual_phase2_with_advanced_basis(i_t phase, timers.start_timer(); f_t se_norms_start_work = ft.work_estimate(); - const i_t steepest_edge_status = phase2::update_steepest_edge_norms(settings, - basic_list, - ft, - direction, - delta_y_sparse, - steepest_edge_norm_check, - scaled_delta_xB_sparse, - basic_leaving_index, - entering_index, - v, - v_sparse, - delta_y_steepest_edge, - phase2_work_estimate); + const i_t steepest_edge_status = update_steepest_edge_norms(settings, + basic_list, + ft, + direction, + delta_y_sparse, + steepest_edge_norm_check, + scaled_delta_xB_sparse, + basic_leaving_index, + entering_index, + v, + v_sparse, + delta_y_steepest_edge, + phase2_work_estimate); #ifdef STEEPEST_EDGE_DEBUG if (steepest_edge_status == -1) { settings.log.printf("Num updates %d\n", ft.num_updates()); @@ -3447,12 +3436,12 @@ 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(); // x <- x + delta_x - phase2::update_primal_variables( + update_primal_variables( scaled_delta_xB_sparse, basic_list, delta_x, entering_index, x, phase2_work_estimate); timers.vector_time += timers.stop_timer(); @@ -3468,77 +3457,77 @@ dual::status_t dual_phase2_with_advanced_basis(i_t phase, timers.start_timer(); // TODO(CMM): Do I also need to update the objective due to the bound flips? // TODO(CMM): I'm using the unperturbed objective here, should this be the perturbed objective? - phase2::update_objective(basic_list, - scaled_delta_xB_sparse.i, - lp.objective, - delta_x, - entering_index, - obj, - phase2_work_estimate); + update_objective(basic_list, + scaled_delta_xB_sparse.i, + lp.objective, + delta_x, + entering_index, + obj, + phase2_work_estimate); timers.objective_time += timers.stop_timer(); timers.start_timer(); // Update primal infeasibilities due to changes in basic variables // from flipping bounds #ifdef CHECK_BASIC_INFEASIBILITIES - phase2::check_basic_infeasibilities(basic_list, basic_mark, infeasibility_indices, 2); + check_basic_infeasibilities(basic_list, basic_mark, infeasibility_indices, 2); #endif - bool needs_cleanup = phase2::update_primal_infeasibilities(lp, - settings, - basic_list, - x, - entering_index, - leaving_index, - delta_xB_0_sparse.i, - squared_infeasibilities, - infeasibility_indices, - primal_infeasibility_squared, - phase2_work_estimate); + bool needs_cleanup = update_primal_infeasibilities(lp, + settings, + basic_list, + x, + entering_index, + leaving_index, + delta_xB_0_sparse.i, + squared_infeasibilities, + infeasibility_indices, + primal_infeasibility_squared, + phase2_work_estimate); // Update primal infeasibilities due to changes in basic variables // from the leaving and entering variables - needs_cleanup |= phase2::update_primal_infeasibilities(lp, - settings, - basic_list, - x, - entering_index, - leaving_index, - scaled_delta_xB_sparse.i, - squared_infeasibilities, - infeasibility_indices, - primal_infeasibility_squared, - phase2_work_estimate); + needs_cleanup |= update_primal_infeasibilities(lp, + settings, + basic_list, + x, + entering_index, + leaving_index, + scaled_delta_xB_sparse.i, + squared_infeasibilities, + infeasibility_indices, + primal_infeasibility_squared, + phase2_work_estimate); // Update the entering variable { const f_t old_val = squared_infeasibilities[entering_index]; - phase2::update_single_primal_infeasibility(lp.lower, - lp.upper, - x, - settings.primal_tol, - squared_infeasibilities, - infeasibility_indices, - entering_index, - primal_infeasibility_squared); + update_single_primal_infeasibility(lp.lower, + lp.upper, + x, + settings.primal_tol, + squared_infeasibilities, + infeasibility_indices, + entering_index, + primal_infeasibility_squared); needs_cleanup |= (old_val != 0.0 && squared_infeasibilities[entering_index] == 0.0); } if (needs_cleanup) { - phase2::clean_up_infeasibilities( + clean_up_infeasibilities( squared_infeasibilities, infeasibility_indices, phase2_work_estimate); } #if CHECK_PRIMAL_INFEASIBILITIES - phase2::check_primal_infeasibilities( + check_primal_infeasibilities( lp, settings, basic_list, x, squared_infeasibilities, infeasibility_indices); #endif timers.update_infeasibility_time += timers.stop_timer(); // Clear delta_x - phase2::clear_delta_x( + clear_delta_x( basic_list, entering_index, scaled_delta_xB_sparse, delta_x, phase2_work_estimate); timers.start_timer(); f_t sum_perturb = 0.0; - phase2::compute_perturbation( + compute_perturbation( lp, settings, delta_z_indices, z, objective, sum_perturb, phase2_work_estimate); timers.perturb_time += timers.stop_timer(); @@ -3560,7 +3549,7 @@ dual::status_t dual_phase2_with_advanced_basis(i_t phase, leaving_index, entering_index, lp.A, row_mark, nonbasic_end, Arow, phase2_work_estimate); #ifdef CHECK_BASIC_INFEASIBILITIES - phase2::check_basic_infeasibilities(basic_list, basic_mark, infeasibility_indices, 5); + check_basic_infeasibilities(basic_list, basic_mark, infeasibility_indices, 5); #endif timers.start_timer(); @@ -3576,7 +3565,7 @@ dual::status_t dual_phase2_with_advanced_basis(i_t phase, if (!should_refactor) { i_t recommend_refactor = ft.update(utilde_sparse, UTsol_sparse, basic_leaving_index); #ifdef CHECK_UPDATE - phase2::check_update(lp, settings, ft, basic_list, basic_leaving_index); + check_update(lp, settings, ft, basic_list, basic_leaving_index); #endif should_refactor = recommend_refactor == 1; timers.lu_update_time += timers.stop_timer(); @@ -3584,7 +3573,7 @@ dual::status_t dual_phase2_with_advanced_basis(i_t phase, } #ifdef CHECK_BASIC_INFEASIBILITIES - phase2::check_basic_infeasibilities(basic_list, basic_mark, infeasibility_indices, 6); + check_basic_infeasibilities(basic_list, basic_mark, infeasibility_indices, 6); #endif if (should_refactor) { PHASE2_NVTX_RANGE("DualSimplex::refactorization"); @@ -3593,69 +3582,69 @@ 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); } refactor_work = ft.work_estimate() - refactor_start_work; - phase2::reset_basis_mark( + reset_basis_mark( basic_list, nonbasic_list, basic_mark, nonbasic_mark, phase2_work_estimate); compute_initial_nonbasic_end(basic_mark, Arow, nonbasic_end); if (should_recompute_x) { std::vector unperturbed_x(n); phase2_work_estimate += n; - phase2::compute_primal_solution_from_basis(lp, - ft, - basic_list, - nonbasic_list, - vstatus, - unperturbed_x, - xB_workspace, - phase2_work_estimate); + compute_primal_solution_from_basis(lp, + ft, + basic_list, + nonbasic_list, + vstatus, + unperturbed_x, + xB_workspace, + phase2_work_estimate); x = unperturbed_x; phase2_work_estimate += 2 * n; } primal_infeasibility_squared = - phase2::compute_initial_primal_infeasibilities(lp, - settings, - basic_list, - x, - squared_infeasibilities, - infeasibility_indices, - primal_infeasibility); + compute_initial_primal_infeasibilities(lp, + settings, + basic_list, + x, + squared_infeasibilities, + infeasibility_indices, + primal_infeasibility); phase2_work_estimate += 4 * m + 2 * n; iterations_since_refactor = 0; solve_work = 0.0; } #ifdef CHECK_BASIC_INFEASIBILITIES - phase2::check_basic_infeasibilities(basic_list, basic_mark, infeasibility_indices, 7); + check_basic_infeasibilities(basic_list, basic_mark, infeasibility_indices, 7); #endif } timers.lu_factorization_time += timers.stop_timer(); @@ -3663,19 +3652,19 @@ dual::status_t dual_phase2_with_advanced_basis(i_t phase, #ifdef STEEPEST_EDGE_DEBUG if (iter < 100 || iter % 100 == 0)) { - phase2::check_steepest_edge_norms(settings, basic_list, ft, delta_y_steepest_edge); + check_steepest_edge_norms(settings, basic_list, ft, delta_y_steepest_edge); } #endif #ifdef CHECK_BASIS_MARK - phase2::check_basis_mark(settings, basic_list, nonbasic_list, basic_mark, nonbasic_mark); + check_basis_mark(settings, basic_list, nonbasic_list, basic_mark, nonbasic_mark); #endif iter++; // Clear delta_z phase2_work_estimate += 3 * delta_z_indices.size(); - phase2::clear_delta_z(entering_index, leaving_index, delta_z_mark, delta_z_indices, delta_z); + clear_delta_z(entering_index, leaving_index, delta_z_mark, delta_z_indices, delta_z); f_t now = toc(start_time); @@ -3711,20 +3700,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 +3737,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 +3749,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, diff --git a/cpp/src/dual_simplex/phase2.hpp b/cpp/src/dual_simplex/phase2.hpp index 85717f8430..c911095259 100644 --- a/cpp/src/dual_simplex/phase2.hpp +++ b/cpp/src/dual_simplex/phase2.hpp @@ -23,8 +23,7 @@ struct work_limit_context_t; namespace cuopt::math_optimization::dual_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, diff --git a/cpp/src/dual_simplex/primal.cpp b/cpp/src/dual_simplex/primal.cpp index 0dcb41b547..b4c91b1741 100644 --- a/cpp/src/dual_simplex/primal.cpp +++ b/cpp/src/dual_simplex/primal.cpp @@ -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, diff --git a/cpp/src/dual_simplex/primal.hpp b/cpp/src/dual_simplex/primal.hpp index c300c0040e..5b5a980673 100644 --- a/cpp/src/dual_simplex/primal.hpp +++ b/cpp/src/dual_simplex/primal.hpp @@ -17,8 +17,7 @@ namespace cuopt::math_optimization::dual_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::math_optimization::dual_simplex diff --git a/cpp/src/dual_simplex/solve.cpp b/cpp/src/dual_simplex/solve.cpp index c1cd83ec2c..5939a3389e 100644 --- a/cpp/src/dual_simplex/solve.cpp +++ b/cpp/src/dual_simplex/solve.cpp @@ -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 From f6b11d12f3ab5bd7d829fd2884e2f78b75060244 Mon Sep 17 00:00:00 2001 From: Miles Lubin Date: Sun, 21 Jun 2026 00:58:23 +0000 Subject: [PATCH 07/17] refactor: eliminate the detail namespace under math_optimization Generic GPU helpers moved to the cuopt namespace; module-specific helpers into their module namespace; file-local helpers into anonymous namespaces. detail no longer used for organization (routing's cuopt::detail and the third-party cxxopts detail are unrelated and untouched). Co-Authored-By: Claude Opus 4.8 (1M context) Signed-off-by: Miles Lubin --- .../math_optimization/mip/solver_settings.hpp | 8 +--- .../optimization_problem_utils.hpp | 8 +--- .../utilities/segmented_sum_handler.cuh | 4 +- cpp/src/barrier/sparse_cholesky.cuh | 18 ++++----- cpp/src/barrier/translate_soc.hpp | 4 +- cpp/src/branch_and_bound/branch_and_bound.cpp | 2 +- cpp/src/branch_and_bound/mip_node.hpp | 2 +- cpp/src/branch_and_bound/pseudo_costs.hpp | 4 +- cpp/src/io/file_to_string.cpp | 4 +- cpp/src/io/file_to_string.hpp | 4 +- cpp/src/io/lp_parser.cpp | 2 +- cpp/src/io/mps_parser.cpp | 2 +- .../mip_heuristics/diversity/population.cu | 15 +++---- .../feasibility_jump_kernels.cu | 20 +++++----- cpp/src/mip_heuristics/problem/problem.cu | 6 +-- cpp/src/mip_heuristics/solve.cu | 39 ++++++++++--------- cpp/src/mip_heuristics/utils.cuh | 4 +- cpp/src/pdlp/cpu_optimization_problem.cpp | 2 +- cpp/src/pdlp/cuopt_c.cpp | 14 +++---- .../initial_scaling.cu | 2 +- cpp/src/pdlp/optimization_problem.cu | 2 +- cpp/src/pdlp/solve.cu | 4 +- .../convergence_information.hpp | 2 +- .../infeasibility_information.hpp | 2 +- cpp/src/pdlp/translate.hpp | 4 +- cpp/src/utilities/device_utils.cuh | 4 +- cpp/src/utilities/double_buffer.hpp | 4 +- cpp/src/utilities/driver_helpers.cuh | 3 -- cpp/src/utilities/hashing.hpp | 4 +- cpp/tests/linear_programming/pdlp_test.cu | 1 - cpp/tests/socp/general_quadratic_test.cu | 4 +- 31 files changed, 91 insertions(+), 107 deletions(-) diff --git a/cpp/include/cuopt/math_optimization/mip/solver_settings.hpp b/cpp/include/cuopt/math_optimization/mip/solver_settings.hpp index abab298e72..0909c8eb75 100644 --- a/cpp/include/cuopt/math_optimization/mip/solver_settings.hpp +++ b/cpp/include/cuopt/math_optimization/mip/solver_settings.hpp @@ -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 { @@ -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::math_optimization diff --git a/cpp/include/cuopt/math_optimization/optimization_problem_utils.hpp b/cpp/include/cuopt/math_optimization/optimization_problem_utils.hpp index 44bea5f0ad..ba04d56ed9 100644 --- a/cpp/include/cuopt/math_optimization/optimization_problem_utils.hpp +++ b/cpp/include/cuopt/math_optimization/optimization_problem_utils.hpp @@ -16,8 +16,6 @@ namespace cuopt::math_optimization { -namespace detail { - inline constexpr bool is_valid_public_var_type_code(char variable_type) { return variable_type == 'C' || variable_type == 'I' || variable_type == 'S'; @@ -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 @@ -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 } diff --git a/cpp/include/cuopt/math_optimization/utilities/segmented_sum_handler.cuh b/cpp/include/cuopt/math_optimization/utilities/segmented_sum_handler.cuh index fb895ffb3a..30cefd910b 100644 --- a/cpp/include/cuopt/math_optimization/utilities/segmented_sum_handler.cuh +++ b/cpp/include/cuopt/math_optimization/utilities/segmented_sum_handler.cuh @@ -21,7 +21,7 @@ #include -namespace cuopt::math_optimization::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::math_optimization::detail +} // namespace cuopt diff --git a/cpp/src/barrier/sparse_cholesky.cuh b/cpp/src/barrier/sparse_cholesky.cuh index 34ea2533ae..12fd8e8747 100644 --- a/cpp/src/barrier/sparse_cholesky.cuh +++ b/cpp/src/barrier/sparse_cholesky.cuh @@ -160,11 +160,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)); @@ -183,7 +182,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( @@ -205,7 +204,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)); @@ -228,15 +227,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)); @@ -377,10 +375,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)); diff --git a/cpp/src/barrier/translate_soc.hpp b/cpp/src/barrier/translate_soc.hpp index f993a5478e..64e8187158 100644 --- a/cpp/src/barrier/translate_soc.hpp +++ b/cpp/src/barrier/translate_soc.hpp @@ -26,7 +26,7 @@ #include #include -namespace cuopt::math_optimization::detail { +namespace cuopt::math_optimization::barrier { /** Convert MPS >= ('G') quadratic row to <= ('L') form on a working copy for SOC conversion. */ template @@ -1352,4 +1352,4 @@ void project_barrier_solution_to_model_variables( solution.z = std::move(model_z); } -} // namespace cuopt::math_optimization::detail +} // namespace cuopt::math_optimization::barrier diff --git a/cpp/src/branch_and_bound/branch_and_bound.cpp b/cpp/src/branch_and_bound/branch_and_bound.cpp index c529438f5e..c346c9103b 100644 --- a/cpp/src/branch_and_bound/branch_and_bound.cpp +++ b/cpp/src/branch_and_bound/branch_and_bound.cpp @@ -3381,7 +3381,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(); } diff --git a/cpp/src/branch_and_bound/mip_node.hpp b/cpp/src/branch_and_bound/mip_node.hpp index f6772e1840..2252503489 100644 --- a/cpp/src/branch_and_bound/mip_node.hpp +++ b/cpp/src/branch_and_bound/mip_node.hpp @@ -353,7 +353,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); } }; diff --git a/cpp/src/branch_and_bound/pseudo_costs.hpp b/cpp/src/branch_and_bound/pseudo_costs.hpp index 2c4293c2f7..a87b709913 100644 --- a/cpp/src/branch_and_bound/pseudo_costs.hpp +++ b/cpp/src/branch_and_bound/pseudo_costs.hpp @@ -206,8 +206,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, diff --git a/cpp/src/io/file_to_string.cpp b/cpp/src/io/file_to_string.cpp index 33665fe22a..7d9f7572de 100644 --- a/cpp/src/io/file_to_string.cpp +++ b/cpp/src/io/file_to_string.cpp @@ -207,7 +207,7 @@ std::vector zlib_file_to_string(const std::string& file) } // end namespace #endif // MPS_PARSER_WITH_ZLIB -namespace cuopt::math_optimization::io::detail { +namespace cuopt::math_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::math_optimization::io::detail +} // namespace cuopt::math_optimization::io diff --git a/cpp/src/io/file_to_string.hpp b/cpp/src/io/file_to_string.hpp index 84f6f10674..6d0d82b631 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::math_optimization::io::detail { +namespace cuopt::math_optimization::io { // Reads `file` into a buffer and appends a trailing '\0'. // @@ -21,4 +21,4 @@ namespace cuopt::math_optimization::io::detail { // The returned buffer's size includes the null terminator. std::vector file_to_string(const std::string& file); -} // namespace cuopt::math_optimization::io::detail +} // namespace cuopt::math_optimization::io diff --git a/cpp/src/io/lp_parser.cpp b/cpp/src/io/lp_parser.cpp index e844c59bb0..48a5f81d3c 100644 --- a/cpp/src/io/lp_parser.cpp +++ b/cpp/src/io/lp_parser.cpp @@ -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); } diff --git a/cpp/src/io/mps_parser.cpp b/cpp/src/io/mps_parser.cpp index 62b1a6495e..f455cd6dd4 100644 --- a/cpp/src/io/mps_parser.cpp +++ b/cpp/src/io/mps_parser.cpp @@ -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); } diff --git a/cpp/src/mip_heuristics/diversity/population.cu b/cpp/src/mip_heuristics/diversity/population.cu index 3215a06a63..de47d455b8 100644 --- a/cpp/src/mip_heuristics/diversity/population.cu +++ b/cpp/src/mip_heuristics/diversity/population.cu @@ -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)) { 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()); @@ -351,8 +352,8 @@ void population_t::run_solution_callbacks(solution_t& sol) if (has_semi_continuous_callback_translation) { 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()); 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 7c8d56141a..93fc982be3 100644 --- a/cpp/src/mip_heuristics/feasibility_jump/feasibility_jump_kernels.cu +++ b/cpp/src/mip_heuristics/feasibility_jump/feasibility_jump_kernels.cu @@ -1449,7 +1449,7 @@ template std::pair get_launch_dims_update_assignment_kernel(int TPB, const raft::handle_t* handle_ptr) { - return detail::get_launch_dims_max_occupancy( + return cuopt::get_launch_dims_max_occupancy( (void*)update_assignment_kernel, TPB, handle_ptr); } @@ -1467,7 +1467,7 @@ template std::pair get_launch_dims_compute_mtm_moves_kernel(int TPB, const raft::handle_t* handle_ptr) { - return detail::get_launch_dims_max_occupancy( + return cuopt::get_launch_dims_max_occupancy( (void*)compute_mtm_moves_kernel, TPB, handle_ptr); } @@ -1475,7 +1475,7 @@ template std::pair get_launch_dims_handle_local_minimum_kernel(int TPB, const raft::handle_t* handle_ptr) { - return detail::get_launch_dims_max_occupancy( + return cuopt::get_launch_dims_max_occupancy( (void*)handle_local_minimum_kernel, TPB, handle_ptr); } @@ -1483,7 +1483,7 @@ template std::pair get_launch_dims_update_lift_moves_kernel(int TPB, const raft::handle_t* handle_ptr) { - return detail::get_launch_dims_max_occupancy( + return cuopt::get_launch_dims_max_occupancy( (void*)update_lift_moves_kernel, TPB, handle_ptr); } @@ -1491,7 +1491,7 @@ template std::pair get_launch_dims_load_balancing_compute_workid_mappings( int TPB, const raft::handle_t* handle_ptr) { - return detail::get_launch_dims_max_occupancy( + return cuopt::get_launch_dims_max_occupancy( (void*)load_balancing_compute_workid_mappings, TPB, handle_ptr); } @@ -1499,7 +1499,7 @@ template std::pair get_launch_dims_load_balancing_compute_scores_binary( int TPB, const raft::handle_t* handle_ptr) { - return detail::get_launch_dims_max_occupancy( + return cuopt::get_launch_dims_max_occupancy( (void*)load_balancing_compute_scores_binary, TPB, handle_ptr); } @@ -1507,7 +1507,7 @@ template std::pair get_launch_dims_load_balancing_mtm_compute_candidates( int TPB, const raft::handle_t* handle_ptr) { - return detail::get_launch_dims_max_occupancy( + return cuopt::get_launch_dims_max_occupancy( (void*)load_balancing_mtm_compute_candidates, TPB, handle_ptr); } @@ -1515,7 +1515,7 @@ template std::pair get_launch_dims_load_balancing_mtm_compute_scores( int TPB, const raft::handle_t* handle_ptr) { - return detail::get_launch_dims_max_occupancy( + return cuopt::get_launch_dims_max_occupancy( (void*)load_balancing_mtm_compute_scores, TPB, handle_ptr); } @@ -1523,7 +1523,7 @@ template std::pair get_launch_dims_load_balancing_prepare_iteration( int TPB, const raft::handle_t* handle_ptr) { - return detail::get_launch_dims_max_occupancy( + return cuopt::get_launch_dims_max_occupancy( (void*)load_balancing_prepare_iteration, TPB, handle_ptr); } @@ -1566,7 +1566,7 @@ template std::pair get_launch_dims_update_changed_constraints_kernel( int TPB, const raft::handle_t* handle_ptr) { - return detail::get_launch_dims_max_occupancy( + return cuopt::get_launch_dims_max_occupancy( (void*)update_changed_constraints_kernel, TPB, handle_ptr); } diff --git a/cpp/src/mip_heuristics/problem/problem.cu b/cpp/src/mip_heuristics/problem/problem.cu index a142b2a8a9..9fc9cdc1a0 100644 --- a/cpp/src/mip_heuristics/problem/problem.cu +++ b/cpp/src/mip_heuristics/problem/problem.cu @@ -2397,8 +2397,8 @@ uint32_t problem_t::get_fingerprint() const 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 = detail::compute_hash(presolve_data.objective_offset); - uint32_t h_obj_scale = detail::compute_hash(presolve_data.objective_scaling_factor); + 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 +2415,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 diff --git a/cpp/src/mip_heuristics/solve.cu b/cpp/src/mip_heuristics/solve.cu index eaba8d6642..1132b676a6 100644 --- a/cpp/src/mip_heuristics/solve.cu +++ b/cpp/src/mip_heuristics/solve.cu @@ -116,14 +116,14 @@ mip_solution_t run_mip_solver( 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); @@ -164,12 +164,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)) { + 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(), @@ -260,10 +260,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, @@ -399,7 +400,7 @@ mip_solution_t solve_mip_helper(optimization_problem_t& op_p 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); } @@ -414,10 +415,11 @@ 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); } @@ -496,10 +498,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, diff --git a/cpp/src/mip_heuristics/utils.cuh b/cpp/src/mip_heuristics/utils.cuh index e1db2186c0..45fb4e8acc 100644 --- a/cpp/src/mip_heuristics/utils.cuh +++ b/cpp/src/mip_heuristics/utils.cuh @@ -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 detail::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 detail::compute_hash(h_contents); + return cuopt::compute_hash(h_contents); } template diff --git a/cpp/src/pdlp/cpu_optimization_problem.cpp b/cpp/src/pdlp/cpu_optimization_problem.cpp index 5ee0544cad..7dc5856fd2 100644 --- a/cpp/src/pdlp/cpu_optimization_problem.cpp +++ b/cpp/src/pdlp/cpu_optimization_problem.cpp @@ -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 diff --git a/cpp/src/pdlp/cuopt_c.cpp b/cpp/src/pdlp/cuopt_c.cpp index 6f3bd0790f..3412b477b1 100644 --- a/cpp/src/pdlp/cuopt_c.cpp +++ b/cpp/src/pdlp/cuopt_c.cpp @@ -263,9 +263,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 +288,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 +326,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 +354,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 @@ -834,7 +830,7 @@ cuopt_int_t cuOptGetVariableTypes(cuOptOptimizationProblem problem, char* variab // 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] = var_type_to_char(variable_types_host[j]); } return CUOPT_SUCCESS; } diff --git a/cpp/src/pdlp/initial_scaling_strategy/initial_scaling.cu b/cpp/src/pdlp/initial_scaling_strategy/initial_scaling.cu index 61a93157bc..7d3beec97d 100644 --- a/cpp/src/pdlp/initial_scaling_strategy/initial_scaling.cu +++ b/cpp/src/pdlp/initial_scaling_strategy/initial_scaling.cu @@ -150,7 +150,7 @@ template void pdlp_initial_scaling_strategy_t::bound_objective_rescaling() { // TODO: test bound obj scaling w/ MIP - detail::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 diff --git a/cpp/src/pdlp/optimization_problem.cu b/cpp/src/pdlp/optimization_problem.cu index 7015ca1e53..ada49ea390 100644 --- a/cpp/src/pdlp/optimization_problem.cu +++ b/cpp/src/pdlp/optimization_problem.cu @@ -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]); } } diff --git a/cpp/src/pdlp/solve.cu b/cpp/src/pdlp/solve.cu index c4ed281dd0..ca0f8362d1 100644 --- a/cpp/src/pdlp/solve.cu +++ b/cpp/src/pdlp/solve.cu @@ -525,7 +525,7 @@ run_barrier(dual_simplex::user_problem_t& user_problem, auto status = dual_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()); @@ -2162,7 +2162,7 @@ cuopt::math_optimization::optimization_problem_t mps_data_model_to_opt 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()); } diff --git a/cpp/src/pdlp/termination_strategy/convergence_information.hpp b/cpp/src/pdlp/termination_strategy/convergence_information.hpp index 51d8ddd260..28d800b721 100644 --- a/cpp/src/pdlp/termination_strategy/convergence_information.hpp +++ b/cpp/src/pdlp/termination_strategy/convergence_information.hpp @@ -201,7 +201,7 @@ 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_; - detail::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_; diff --git a/cpp/src/pdlp/termination_strategy/infeasibility_information.hpp b/cpp/src/pdlp/termination_strategy/infeasibility_information.hpp index 1f30e6a96f..83ecd89866 100644 --- a/cpp/src/pdlp/termination_strategy/infeasibility_information.hpp +++ b/cpp/src/pdlp/termination_strategy/infeasibility_information.hpp @@ -132,7 +132,7 @@ class infeasibility_information_t { const pdlp_initial_scaling_strategy_t& scaling_strategy_; const mip::problem_t& op_problem_scaled_; - detail::segmented_sum_handler_t segmented_sum_handler_; + cuopt::segmented_sum_handler_t segmented_sum_handler_; const std::vector& climber_strategies_; const pdlp::pdlp_hyper_params_t& hyper_params_; }; diff --git a/cpp/src/pdlp/translate.hpp b/cpp/src/pdlp/translate.hpp index ded19601e9..986a43149b 100644 --- a/cpp/src/pdlp/translate.hpp +++ b/cpp/src/pdlp/translate.hpp @@ -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); } @@ -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); } diff --git a/cpp/src/utilities/device_utils.cuh b/cpp/src/utilities/device_utils.cuh index 462134a0b6..259150d4c6 100644 --- a/cpp/src/utilities/device_utils.cuh +++ b/cpp/src/utilities/device_utils.cuh @@ -12,7 +12,7 @@ #include -namespace cuopt::math_optimization::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::math_optimization::detail +} // namespace cuopt diff --git a/cpp/src/utilities/double_buffer.hpp b/cpp/src/utilities/double_buffer.hpp index 6351bebefb..504393c54c 100644 --- a/cpp/src/utilities/double_buffer.hpp +++ b/cpp/src/utilities/double_buffer.hpp @@ -9,7 +9,7 @@ #include -namespace cuopt::math_optimization::detail { +namespace cuopt { template struct double_buffer_t { @@ -40,4 +40,4 @@ struct double_buffer_t { rmm::device_uvector bufs[2]; }; -} // namespace cuopt::math_optimization::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 9c42f37a7c..ba914ff164 100644 --- a/cpp/src/utilities/hashing.hpp +++ b/cpp/src/utilities/hashing.hpp @@ -9,7 +9,7 @@ #include #include -namespace cuopt::math_optimization::detail { +namespace cuopt { template inline uint32_t compute_hash(const std::vector& h_contents) @@ -43,4 +43,4 @@ __host__ __device__ return hash; } -} // namespace cuopt::math_optimization::detail +} // namespace cuopt diff --git a/cpp/tests/linear_programming/pdlp_test.cu b/cpp/tests/linear_programming/pdlp_test.cu index d85dde3a8b..057d3e235f 100644 --- a/cpp/tests/linear_programming/pdlp_test.cu +++ b/cpp/tests/linear_programming/pdlp_test.cu @@ -94,7 +94,6 @@ TEST(pdlp_class, run_double) TEST(pdlp_class, precision_mixed) { - using namespace cuopt::math_optimization::detail; using namespace cuopt::math_optimization::pdlp; if (!is_cusparse_runtime_mixed_precision_supported()) { const raft::handle_t handle_{}; diff --git a/cpp/tests/socp/general_quadratic_test.cu b/cpp/tests/socp/general_quadratic_test.cu index caf8479f4c..154949dba9 100644 --- a/cpp/tests/socp/general_quadratic_test.cu +++ b/cpp/tests/socp/general_quadratic_test.cu @@ -19,7 +19,7 @@ #include #include -namespace cuopt::math_optimization::detail::test { +namespace cuopt::math_optimization::barrier::test { using i_t = int; using f_t = double; @@ -824,4 +824,4 @@ TEST(general_quadratic, rotated_soc_heads_free_rejected) cuopt::logic_error); } -} // namespace cuopt::math_optimization::detail::test +} // namespace cuopt::math_optimization::barrier::test From 57a51ee3d8c0f4fad65120fa0c4ec2006c607e03 Mon Sep 17 00:00:00 2001 From: Miles Lubin Date: Sun, 21 Jun 2026 01:54:30 +0000 Subject: [PATCH 08/17] compat: forward to new path The C API is unchanged (same symbols, C linkage); only its header path moved to . Add a forwarding shim at the legacy path (with a deprecation #pragma message) so existing C/C++ consumers keep compiling. Installs via the existing include/cuopt/ directory rule. Co-Authored-By: Claude Opus 4.8 (1M context) Signed-off-by: Miles Lubin --- .../cuopt/linear_programming/cuopt_c.h | 27 +++++++++++++++++++ 1 file changed, 27 insertions(+) create mode 100644 cpp/include/cuopt/linear_programming/cuopt_c.h diff --git a/cpp/include/cuopt/linear_programming/cuopt_c.h b/cpp/include/cuopt/linear_programming/cuopt_c.h new file mode 100644 index 0000000000..083755a59d --- /dev/null +++ b/cpp/include/cuopt/linear_programming/cuopt_c.h @@ -0,0 +1,27 @@ +/* clang-format off */ +/* + * SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + */ +/* clang-format on */ + +/* + * Compatibility forwarder. + * + * The cuOpt C API header moved to as part of + * the cuopt::linear_programming -> cuopt::math_optimization rename. The C API + * itself is unchanged (same symbols, C linkage) -- only the include path moved. + * + * This shim keeps the legacy include path working. Please update includes to + * ; this forwarder may be removed in a future + * release. + */ +#ifndef CUOPT_LINEAR_PROGRAMMING_C_API_COMPAT_H +#define CUOPT_LINEAR_PROGRAMMING_C_API_COMPAT_H + +#pragma message( \ + " is deprecated; include instead.") + +#include + +#endif /* CUOPT_LINEAR_PROGRAMMING_C_API_COMPAT_H */ From 59336da587c3b5ae97f11f4604920ffcf99f486f Mon Sep 17 00:00:00 2001 From: Miles Lubin Date: Mon, 22 Jun 2026 13:41:26 +0000 Subject: [PATCH 09/17] refactor: rename dual_simplex namespace to simplex The namespace holds a full simplex solver -- primal and dual algorithms plus shared basis/LU/crossover infrastructure -- so 'simplex' is accurate. Namespace only; the src/dual_simplex/ directory and include paths are unchanged. Co-Authored-By: Claude Opus 4.8 (1M context) Signed-off-by: Miles Lubin --- cpp/include/cuopt/math_optimization/solve.hpp | 2 +- cpp/src/barrier/barrier.cu | 77 ++++----- cpp/src/barrier/barrier.hpp | 4 +- cpp/src/barrier/conjugate_gradient.hpp | 16 +- cpp/src/barrier/cusparse_view.cu | 4 +- cpp/src/barrier/cusparse_view.hpp | 4 +- cpp/src/barrier/dense_matrix.hpp | 4 +- cpp/src/barrier/dense_vector.hpp | 4 +- cpp/src/barrier/device_sparse_matrix.cu | 4 +- cpp/src/barrier/device_sparse_matrix.cuh | 4 +- cpp/src/barrier/iterative_refinement.hpp | 4 +- cpp/src/barrier/pinned_host_allocator.cu | 8 +- cpp/src/barrier/sparse_cholesky.cuh | 8 +- cpp/src/barrier/translate_soc.hpp | 52 +++--- cpp/src/branch_and_bound/branch_and_bound.cpp | 16 +- cpp/src/branch_and_bound/branch_and_bound.hpp | 14 +- .../deterministic_workers.hpp | 4 +- .../branch_and_bound/diving_heuristics.cpp | 4 +- .../branch_and_bound/diving_heuristics.hpp | 4 +- cpp/src/branch_and_bound/mip_node.hpp | 4 +- cpp/src/branch_and_bound/node_queue.hpp | 4 +- cpp/src/branch_and_bound/pseudo_costs.cpp | 10 +- cpp/src/branch_and_bound/pseudo_costs.hpp | 4 +- cpp/src/branch_and_bound/symmetry.hpp | 4 +- cpp/src/branch_and_bound/worker.hpp | 4 +- cpp/src/branch_and_bound/worker_pool.hpp | 4 +- cpp/src/cuts/cuts.cpp | 4 +- cpp/src/cuts/cuts.hpp | 4 +- cpp/src/cuts/objective_step.cpp | 4 +- cpp/src/cuts/objective_step.hpp | 4 +- cpp/src/dual_simplex/basis_solves.cpp | 4 +- cpp/src/dual_simplex/basis_solves.hpp | 4 +- cpp/src/dual_simplex/basis_updates.cpp | 30 ++-- cpp/src/dual_simplex/basis_updates.hpp | 4 +- .../bound_flipping_ratio_test.cpp | 4 +- .../bound_flipping_ratio_test.hpp | 4 +- cpp/src/dual_simplex/bounds_strengthening.cpp | 4 +- cpp/src/dual_simplex/bounds_strengthening.hpp | 4 +- cpp/src/dual_simplex/crossover.cpp | 4 +- cpp/src/dual_simplex/crossover.hpp | 4 +- cpp/src/dual_simplex/folding.cpp | 4 +- cpp/src/dual_simplex/folding.hpp | 4 +- cpp/src/dual_simplex/initial_basis.cpp | 4 +- cpp/src/dual_simplex/initial_basis.hpp | 4 +- cpp/src/dual_simplex/logger.hpp | 4 +- cpp/src/dual_simplex/phase1.cpp | 4 +- cpp/src/dual_simplex/phase1.hpp | 4 +- cpp/src/dual_simplex/phase2.cpp | 6 +- cpp/src/dual_simplex/phase2.hpp | 4 +- cpp/src/dual_simplex/presolve.cpp | 4 +- cpp/src/dual_simplex/presolve.hpp | 4 +- cpp/src/dual_simplex/primal.cpp | 4 +- cpp/src/dual_simplex/primal.hpp | 4 +- cpp/src/dual_simplex/random.hpp | 4 +- cpp/src/dual_simplex/right_looking_lu.cpp | 4 +- cpp/src/dual_simplex/right_looking_lu.hpp | 4 +- cpp/src/dual_simplex/scaling.cpp | 4 +- cpp/src/dual_simplex/scaling.hpp | 4 +- .../dual_simplex/simplex_solver_settings.hpp | 4 +- cpp/src/dual_simplex/singletons.cpp | 4 +- cpp/src/dual_simplex/singletons.hpp | 4 +- cpp/src/dual_simplex/solution.hpp | 4 +- cpp/src/dual_simplex/solve.cpp | 6 +- cpp/src/dual_simplex/solve.hpp | 4 +- cpp/src/dual_simplex/sparse_matrix.cpp | 4 +- cpp/src/dual_simplex/sparse_matrix.hpp | 6 +- cpp/src/dual_simplex/sparse_vector.cpp | 4 +- cpp/src/dual_simplex/sparse_vector.hpp | 4 +- cpp/src/dual_simplex/tic_toc.cpp | 4 +- cpp/src/dual_simplex/tic_toc.hpp | 4 +- cpp/src/dual_simplex/triangle_solve.cpp | 4 +- cpp/src/dual_simplex/triangle_solve.hpp | 4 +- cpp/src/dual_simplex/types.hpp | 4 +- cpp/src/dual_simplex/user_problem.hpp | 4 +- cpp/src/dual_simplex/vector_math.cpp | 4 +- cpp/src/dual_simplex/vector_math.cuh | 4 +- cpp/src/dual_simplex/vector_math.hpp | 4 +- .../diversity/diversity_manager.cu | 2 +- cpp/src/mip_heuristics/diversity/lns/rins.cu | 10 +- .../diversity/recombiners/sub_mip.cuh | 10 +- .../feasibility_jump/cpu_fj_thread.cuh | 6 +- .../mip_heuristics/feasibility_jump/fj_cpu.cu | 32 ++-- .../local_search/local_search.cuh | 2 +- .../presolve/conflict_graph/clique_table.cu | 20 +-- .../presolve/conflict_graph/clique_table.cuh | 4 +- .../presolve/semi_continuous.cu | 15 +- cpp/src/mip_heuristics/problem/problem.cu | 17 +- cpp/src/mip_heuristics/problem/problem.cuh | 8 +- cpp/src/mip_heuristics/solve.cu | 8 +- cpp/src/mip_heuristics/solver.cu | 20 +-- cpp/src/pdlp/solve.cu | 148 ++++++++---------- cpp/src/pdlp/translate.hpp | 45 +++--- .../unit_tests/right_looking_ldlt.cpp | 4 +- cpp/tests/dual_simplex/unit_tests/solve.cpp | 68 ++++---- .../dual_simplex/unit_tests/solve_barrier.cu | 38 ++--- cpp/tests/mip/cuts_test.cu | 21 ++- cpp/tests/mip/problem_test.cu | 2 +- cpp/tests/socp/general_quadratic_test.cu | 40 ++--- cpp/tests/socp/solve_barrier_socp.cu | 28 ++-- 99 files changed, 514 insertions(+), 541 deletions(-) diff --git a/cpp/include/cuopt/math_optimization/solve.hpp b/cpp/include/cuopt/math_optimization/solve.hpp index 350bb2a8a5..4ee90feb2e 100644 --- a/cpp/include/cuopt/math_optimization/solve.hpp +++ b/cpp/include/cuopt/math_optimization/solve.hpp @@ -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 diff --git a/cpp/src/barrier/barrier.cu b/cpp/src/barrier/barrier.cu index 995261e9a7..faf0097a25 100644 --- a/cpp/src/barrier/barrier.cu +++ b/cpp/src/barrier/barrier.cu @@ -52,8 +52,8 @@ namespace cuopt::math_optimization::barrier { -using namespace cuopt::math_optimization::dual_simplex; // shared simplex types (lp_problem_t, inf, - // etc.) +using namespace cuopt::math_optimization::simplex; // shared simplex types (lp_problem_t, inf, + // etc.) template bool validate_barrier_cone_layout(const lp_problem_t& problem, @@ -1011,13 +1011,9 @@ class iteration_data_t { { if (n_dense_columns == 0) { // Solve ADAT * x = b - if (debug) { - settings_.log.printf("||b|| = %.16e\n", dual_simplex::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", dual_simplex::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 @@ -1053,13 +1049,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", dual_simplex::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", dual_simplex::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; @@ -1097,7 +1089,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", - dual_simplex::vector_norm2(M_residual)); + simplex::vector_norm2(M_residual)); } } // A_sparse * D_sparse * A_sparse^T * M = U = AD_dense @@ -1150,7 +1142,7 @@ class iteration_data_t { 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", - dual_simplex::vector_norm2(H_residual)); + simplex::vector_norm2(H_residual)); } // x = (A_sparse * D_sparse * A_sparse^T)^{-1} * (b - U * y) @@ -1169,7 +1161,7 @@ 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", - dual_simplex::vector_norm2(solve_residual)); + simplex::vector_norm2(solve_residual)); } if (debug) { @@ -1177,7 +1169,7 @@ class iteration_data_t { 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", - dual_simplex::vector_norm2(residual_2)); + simplex::vector_norm2(residual_2)); } if (debug) { @@ -1186,7 +1178,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", - dual_simplex::vector_norm2(residual_1)); + simplex::vector_norm2(residual_1)); } if (full_debug && debug) { @@ -1211,7 +1203,7 @@ class iteration_data_t { adat_multiply(-1.0, ei, 1.0, u); - max_error = std::max(max_error, dual_simplex::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); } @@ -1351,7 +1343,7 @@ class iteration_data_t { adat_multiply(-1.0, ei, 1.0, u); - max_error = std::max(max_error, dual_simplex::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", @@ -1362,7 +1354,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", - dual_simplex::vector_norm2(total_residual)); + simplex::vector_norm2(total_residual)); } // Now do some rounds of PCG @@ -1431,7 +1423,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 = dual_simplex::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 @@ -1790,19 +1782,19 @@ 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", dual_simplex::vector_norm2(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", dual_simplex::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", dual_simplex::vector_norm2(A.x)); - printf("||w|| = %.16e\n", dual_simplex::vector_norm2(w)); - printf("||v|| = %.16e\n", dual_simplex::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)); } } @@ -2169,8 +2161,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 = dual_simplex::vector_norm_inf(lp.rhs); - const f_t norm_c = dual_simplex::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; @@ -2276,19 +2268,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", dual_simplex::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", dual_simplex::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", dual_simplex::vector_norm2(q)); + settings.log.printf("||q|| = %.16e\n", simplex::vector_norm2(q)); #endif // rhs_x <- A*Dinv*A'*q - rhs_x @@ -2296,7 +2288,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", - dual_simplex::vector_norm2(rhs_x)); + simplex::vector_norm2(rhs_x)); #endif // x = Dinv*(F*u - A'*q) @@ -2323,7 +2315,7 @@ int barrier_solver_t::initial_point(iteration_data_t& data) data.handle_ptr->get_stream().synchronize(); #ifdef PRINT_INFO settings.log.printf("||b - A * x||: %.16e\n", - dual_simplex::vector_norm2(init_primal_residual)); + simplex::vector_norm2(init_primal_residual)); #endif if (data.n_upper_bounds > 0) { @@ -2334,7 +2326,7 @@ int barrier_solver_t::initial_point(iteration_data_t& data) } #ifdef PRINT_INFO settings.log.printf("|| u - w - x||: %e\n", - dual_simplex::vector_norm2(init_bound_residual)); + simplex::vector_norm2(init_bound_residual)); #endif } @@ -2348,7 +2340,7 @@ int barrier_solver_t::initial_point(iteration_data_t& data) // y = 0 data.y.set_scalar(0.0); - f_t epsilon = 1.0 + dual_simplex::vector_norm1(lp.objective); + f_t epsilon = 1.0 + simplex::vector_norm1(lp.objective); // A^T y + z - E^T v - Q x = c // when y = 0, z - E^T v = c + Q x @@ -2448,7 +2440,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", - dual_simplex::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); @@ -3091,9 +3083,8 @@ i_t barrier_solver_t::gpu_compute_search_direction(iteration_data_t(dx_residual_4, stream_view_); - max_residual = std::max(max_residual, dx_residual_4_norm); + 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); } @@ -4123,8 +4114,8 @@ lp_status_t barrier_solver_t::solve(f_t start_time, lp_solution_t(data.b, stream_view_); - f_t norm_c = dual_simplex::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) { diff --git a/cpp/src/barrier/barrier.hpp b/cpp/src/barrier/barrier.hpp index 73b70f03c8..a903b98b92 100644 --- a/cpp/src/barrier/barrier.hpp +++ b/cpp/src/barrier/barrier.hpp @@ -18,8 +18,8 @@ #include namespace cuopt::math_optimization::barrier { -using namespace cuopt::math_optimization::dual_simplex; // shared simplex types (lp_problem_t, inf, - // etc.) +using namespace cuopt::math_optimization::simplex; // shared simplex types (lp_problem_t, inf, + // etc.) /** Validates SOC layout on an lp_problem_t before barrier presolve/solve. */ template diff --git a/cpp/src/barrier/conjugate_gradient.hpp b/cpp/src/barrier/conjugate_gradient.hpp index bd61327d54..7ecfce9db9 100644 --- a/cpp/src/barrier/conjugate_gradient.hpp +++ b/cpp/src/barrier/conjugate_gradient.hpp @@ -18,8 +18,8 @@ namespace cuopt::math_optimization::barrier { -using namespace cuopt::math_optimization::dual_simplex; // shared simplex types (lp_problem_t, inf, - // etc.) +using namespace cuopt::math_optimization::simplex; // shared simplex types (lp_problem_t, inf, + // etc.) template i_t preconditioned_conjugate_gradient(const T& op, @@ -45,12 +45,12 @@ i_t preconditioned_conjugate_gradient(const T& op, dense_vector_t Ap(b.size()); i_t iter = 0; - f_t norm_residual = dual_simplex::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, - dual_simplex::vector_norm_inf(residual)); + simplex::vector_norm_inf(residual)); } f_t rTy = residual.inner_product(y); @@ -65,7 +65,7 @@ i_t preconditioned_conjugate_gradient(const T& op, // Update residual = residual + alpha * Ap residual.axpy(alpha, Ap, 1.0); - f_t new_residual = dual_simplex::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( @@ -81,7 +81,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 = dual_simplex::vector_norm2(residual); + norm_residual = simplex::vector_norm2(residual); // Solve M y = r for y op.m_solve(residual, y); @@ -101,13 +101,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, - dual_simplex::vector_norm_inf(residual)); + simplex::vector_norm_inf(residual)); } } residual = b; op.a_multiply(1.0, x, -1.0, residual); - norm_residual = dual_simplex::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", diff --git a/cpp/src/barrier/cusparse_view.cu b/cpp/src/barrier/cusparse_view.cu index fbee992faf..a69a014931 100644 --- a/cpp/src/barrier/cusparse_view.cu +++ b/cpp/src/barrier/cusparse_view.cu @@ -24,8 +24,8 @@ namespace cuopt::math_optimization::barrier { -using namespace cuopt::math_optimization::dual_simplex; // shared simplex types (lp_problem_t, inf, - // etc.) +using namespace cuopt::math_optimization::simplex; // shared simplex types (lp_problem_t, inf, + // etc.) #define CUDA_VER_12_4_UP (CUDART_VERSION >= 12040) diff --git a/cpp/src/barrier/cusparse_view.hpp b/cpp/src/barrier/cusparse_view.hpp index 39db2c74d2..c601869e1c 100644 --- a/cpp/src/barrier/cusparse_view.hpp +++ b/cpp/src/barrier/cusparse_view.hpp @@ -23,8 +23,8 @@ // This allows handling many different X Y vector along with one common matrix namespace cuopt::math_optimization::barrier { -using namespace cuopt::math_optimization::dual_simplex; // shared simplex types (lp_problem_t, inf, - // etc.) +using namespace cuopt::math_optimization::simplex; // shared simplex types (lp_problem_t, inf, + // etc.) template class cusparse_view_t { public: diff --git a/cpp/src/barrier/dense_matrix.hpp b/cpp/src/barrier/dense_matrix.hpp index badb30c6f0..e8e94a4560 100644 --- a/cpp/src/barrier/dense_matrix.hpp +++ b/cpp/src/barrier/dense_matrix.hpp @@ -14,8 +14,8 @@ namespace cuopt::math_optimization::barrier { -using namespace cuopt::math_optimization::dual_simplex; // shared simplex types (lp_problem_t, inf, - // etc.) +using namespace cuopt::math_optimization::simplex; // shared simplex types (lp_problem_t, inf, + // etc.) template class dense_matrix_t { diff --git a/cpp/src/barrier/dense_vector.hpp b/cpp/src/barrier/dense_vector.hpp index 94e0fdd0cd..f170e9e6c2 100644 --- a/cpp/src/barrier/dense_vector.hpp +++ b/cpp/src/barrier/dense_vector.hpp @@ -14,8 +14,8 @@ namespace cuopt::math_optimization::barrier { -using namespace cuopt::math_optimization::dual_simplex; // shared simplex types (lp_problem_t, inf, - // etc.) +using namespace cuopt::math_optimization::simplex; // shared simplex types (lp_problem_t, inf, + // etc.) template > class dense_vector_t : public std::vector { diff --git a/cpp/src/barrier/device_sparse_matrix.cu b/cpp/src/barrier/device_sparse_matrix.cu index 954f99e35f..c0ed8b3b3a 100644 --- a/cpp/src/barrier/device_sparse_matrix.cu +++ b/cpp/src/barrier/device_sparse_matrix.cu @@ -15,7 +15,7 @@ // matrix_transpose_vector_multiply) specialized with barrier's // PinnedHostAllocator. They must live in the dual_simplex namespace (where the // templates are declared), even though the file resides under barrier/. -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_optimization::simplex { using cuopt::math_optimization::barrier::PinnedHostAllocator; @@ -72,4 +72,4 @@ template void csc_matrix_t::scale_columns class device_csr_matrix_t; diff --git a/cpp/src/barrier/iterative_refinement.hpp b/cpp/src/barrier/iterative_refinement.hpp index 9d692d56d2..66c887580c 100644 --- a/cpp/src/barrier/iterative_refinement.hpp +++ b/cpp/src/barrier/iterative_refinement.hpp @@ -30,8 +30,8 @@ namespace cuopt::math_optimization::barrier { -using namespace cuopt::math_optimization::dual_simplex; // shared simplex types (lp_problem_t, inf, - // etc.) +using namespace cuopt::math_optimization::simplex; // shared simplex types (lp_problem_t, inf, + // etc.) // Functors for device operations (defined at namespace scope to avoid CUDA lambda restrictions) template diff --git a/cpp/src/barrier/pinned_host_allocator.cu b/cpp/src/barrier/pinned_host_allocator.cu index bc628b29de..00e6ef49e4 100644 --- a/cpp/src/barrier/pinned_host_allocator.cu +++ b/cpp/src/barrier/pinned_host_allocator.cu @@ -12,8 +12,8 @@ namespace cuopt::math_optimization::barrier { -using namespace cuopt::math_optimization::dual_simplex; // shared simplex types (lp_problem_t, inf, - // etc.) +using namespace cuopt::math_optimization::simplex; // shared simplex types (lp_problem_t, inf, + // etc.) template struct PinnedHostAllocator { @@ -58,7 +58,7 @@ template class PinnedHostAllocator; } // namespace cuopt::math_optimization::barrier -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_optimization::simplex { // Explicit instantiation of the shared dual_simplex vector_math template with // barrier's PinnedHostAllocator must live in dual_simplex (the template's namespace). @@ -68,4 +68,4 @@ vector_norm_inf>& x); #endif -} // namespace cuopt::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::simplex diff --git a/cpp/src/barrier/sparse_cholesky.cuh b/cpp/src/barrier/sparse_cholesky.cuh index 12fd8e8747..8ae1ffc4f9 100644 --- a/cpp/src/barrier/sparse_cholesky.cuh +++ b/cpp/src/barrier/sparse_cholesky.cuh @@ -22,8 +22,8 @@ namespace cuopt::math_optimization::barrier { -using namespace cuopt::math_optimization::dual_simplex; // shared simplex types (lp_problem_t, inf, - // etc.) +using namespace cuopt::math_optimization::simplex; // shared simplex types (lp_problem_t, inf, + // etc.) template class sparse_cholesky_base_t { @@ -854,9 +854,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", - dual_simplex::vector_norm2(b_host), + simplex::vector_norm2(b_host), compute_hash(b_host), - dual_simplex::vector_norm2(x_host), + simplex::vector_norm2(x_host), compute_hash(x_host)); #endif diff --git a/cpp/src/barrier/translate_soc.hpp b/cpp/src/barrier/translate_soc.hpp index 64e8187158..117a963df5 100644 --- a/cpp/src/barrier/translate_soc.hpp +++ b/cpp/src/barrier/translate_soc.hpp @@ -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 @@ -819,8 +818,8 @@ void convert_quadratic_constraints_to_second_order_cones( user_problem.objective.resize(n_aug, 0); user_problem.lower.resize(n_aug, -inf); user_problem.upper.resize(n_aug, inf); - user_problem.var_types.resize( - n_aug, cuopt::math_optimization::dual_simplex::variable_type_t::CONTINUOUS); + user_problem.var_types.resize(n_aug, + cuopt::math_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::math_optimization::dual_simplex::variable_type_t::CONTINUOUS, + cuopt::math_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::math_optimization::dual_simplex::variable_type_t::CONTINUOUS, + cuopt::math_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::math_optimization::dual_simplex::variable_type_t::CONTINUOUS, + cuopt::math_optimization::simplex::variable_type_t::CONTINUOUS, error_type_t::ValidationError, "Rotated SOC tail variables must be continuous"); } @@ -923,8 +922,8 @@ void convert_quadratic_constraints_to_second_order_cones( user_problem.objective.resize(n_prob, 0); user_problem.lower.resize(n_prob, -inf); user_problem.upper.resize(n_prob, inf); - user_problem.var_types.resize( - n_prob, cuopt::math_optimization::dual_simplex::variable_type_t::CONTINUOUS); + user_problem.var_types.resize(n_prob, + cuopt::math_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; @@ -1064,8 +1063,8 @@ void convert_quadratic_constraints_to_second_order_cones( user_problem.objective.resize(n_new, 0); 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::math_optimization::dual_simplex::variable_type_t::CONTINUOUS); + user_problem.var_types.resize(n_new, + cuopt::math_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) { @@ -1151,8 +1150,8 @@ void convert_quadratic_constraints_to_second_order_cones( user_problem.objective.resize(n_new, 0); user_problem.lower.resize(n_new, neg_inf); user_problem.upper.resize(n_new, pos_inf); - user_problem.var_types.resize( - n_new, cuopt::math_optimization::dual_simplex::variable_type_t::CONTINUOUS); + user_problem.var_types.resize(n_new, + cuopt::math_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; } diff --git a/cpp/src/branch_and_bound/branch_and_bound.cpp b/cpp/src/branch_and_bound/branch_and_bound.cpp index c346c9103b..f2583a75ba 100644 --- a/cpp/src/branch_and_bound/branch_and_bound.cpp +++ b/cpp/src/branch_and_bound/branch_and_bound.cpp @@ -46,8 +46,8 @@ namespace cuopt::math_optimization::mip { -using namespace cuopt::math_optimization::dual_simplex; // shared simplex types (lp_problem_t, - // etc.) +using namespace cuopt::math_optimization::simplex; // shared simplex types (lp_problem_t, + // etc.) namespace { template @@ -658,8 +658,8 @@ void branch_and_bound_t::repair_heuristic_solutions() } template -void branch_and_bound_t::set_solution_at_root( - dual_simplex::mip_solution_t& solution, const cut_info_t& cut_info) +void branch_and_bound_t::set_solution_at_root(simplex::mip_solution_t& solution, + const cut_info_t& cut_info) { mutex_upper_.lock(); incumbent_.set_incumbent_solution(root_objective_, root_relax_soln_.x); @@ -687,8 +687,8 @@ void branch_and_bound_t::set_solution_at_root( } template -void branch_and_bound_t::set_final_solution( - dual_simplex::mip_solution_t& solution, f_t lower_bound) +void branch_and_bound_t::set_final_solution(simplex::mip_solution_t& solution, + f_t lower_bound) { if (solver_status_ == mip_status_t::NUMERICAL) { settings_.log.printf("Numerical issue encountered. Stopping the solver...\n"); @@ -2156,7 +2156,7 @@ lp_status_t branch_and_bound_t::solve_root_relaxation( template auto branch_and_bound_t::do_cut_pass( [[maybe_unused]] i_t cut_pass, - dual_simplex::mip_solution_t& solution, + simplex::mip_solution_t& solution, i_t& num_fractional, std::vector& fractional, cut_generation_t& cut_generation, @@ -2436,7 +2436,7 @@ auto branch_and_bound_t::do_cut_pass( } template -mip_status_t branch_and_bound_t::solve(dual_simplex::mip_solution_t& solution) +mip_status_t branch_and_bound_t::solve(simplex::mip_solution_t& solution) { raft::common::nvtx::range scope("BB::solve"); diff --git a/cpp/src/branch_and_bound/branch_and_bound.hpp b/cpp/src/branch_and_bound/branch_and_bound.hpp index 66400d27e0..031f6727fa 100644 --- a/cpp/src/branch_and_bound/branch_and_bound.hpp +++ b/cpp/src/branch_and_bound/branch_and_bound.hpp @@ -47,8 +47,8 @@ struct clique_table_t; namespace cuopt::math_optimization::mip { -using namespace cuopt::math_optimization::dual_simplex; // shared simplex types (lp_problem_t, - // etc.) +using namespace cuopt::math_optimization::simplex; // shared simplex types (lp_problem_t, + // etc.) template struct mip_symmetry_t; @@ -154,7 +154,7 @@ class branch_and_bound_t { std::vector& upper_bounds); // The main entry routine. Returns the solver status and populates solution with the incumbent. - mip_status_t solve(dual_simplex::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_; } @@ -202,7 +202,7 @@ class branch_and_bound_t { omp_atomic_t upper_bound_; // Solver-space incumbent tracked directly by B&B. - dual_simplex::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 @@ -278,7 +278,7 @@ class branch_and_bound_t { }; cut_pass_result_t do_cut_pass(i_t cut_pass, - dual_simplex::mip_solution_t& solution, + simplex::mip_solution_t& solution, i_t& num_fractional, std::vector& fractional, cut_generation_t& cut_generation, @@ -297,12 +297,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(dual_simplex::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(dual_simplex::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. diff --git a/cpp/src/branch_and_bound/deterministic_workers.hpp b/cpp/src/branch_and_bound/deterministic_workers.hpp index 0fa531cba7..e04e466313 100644 --- a/cpp/src/branch_and_bound/deterministic_workers.hpp +++ b/cpp/src/branch_and_bound/deterministic_workers.hpp @@ -24,8 +24,8 @@ namespace cuopt::math_optimization::mip { -using namespace cuopt::math_optimization::dual_simplex; // shared simplex types (lp_problem_t, - // etc.) +using namespace cuopt::math_optimization::simplex; // shared simplex types (lp_problem_t, + // etc.) template struct backlog_node_compare_t { diff --git a/cpp/src/branch_and_bound/diving_heuristics.cpp b/cpp/src/branch_and_bound/diving_heuristics.cpp index 6c2f927379..6b77396983 100644 --- a/cpp/src/branch_and_bound/diving_heuristics.cpp +++ b/cpp/src/branch_and_bound/diving_heuristics.cpp @@ -9,8 +9,8 @@ namespace cuopt::math_optimization::mip { -using namespace cuopt::math_optimization::dual_simplex; // shared simplex types (lp_problem_t, - // etc.) +using namespace cuopt::math_optimization::simplex; // shared simplex types (lp_problem_t, + // etc.) template branch_variable_t line_search_diving(const std::vector& fractional, diff --git a/cpp/src/branch_and_bound/diving_heuristics.hpp b/cpp/src/branch_and_bound/diving_heuristics.hpp index 31efa35313..3581440694 100644 --- a/cpp/src/branch_and_bound/diving_heuristics.hpp +++ b/cpp/src/branch_and_bound/diving_heuristics.hpp @@ -18,8 +18,8 @@ namespace cuopt::math_optimization::mip { -using namespace cuopt::math_optimization::dual_simplex; // shared simplex types (lp_problem_t, - // etc.) +using namespace cuopt::math_optimization::simplex; // shared simplex types (lp_problem_t, + // etc.) // When `log_diving_type` is true, each diving strategy gets its own letter; // otherwise every dive collapses to 'D'. diff --git a/cpp/src/branch_and_bound/mip_node.hpp b/cpp/src/branch_and_bound/mip_node.hpp index 2252503489..967463cc0f 100644 --- a/cpp/src/branch_and_bound/mip_node.hpp +++ b/cpp/src/branch_and_bound/mip_node.hpp @@ -23,8 +23,8 @@ namespace cuopt::math_optimization::mip { -using namespace cuopt::math_optimization::dual_simplex; // shared simplex types (lp_problem_t, - // etc.) +using namespace cuopt::math_optimization::simplex; // shared simplex types (lp_problem_t, + // etc.) enum class node_status_t : int { PENDING = 0, // Node is still in the tree, waiting to be solved diff --git a/cpp/src/branch_and_bound/node_queue.hpp b/cpp/src/branch_and_bound/node_queue.hpp index 0e3df23207..5b222f80a1 100644 --- a/cpp/src/branch_and_bound/node_queue.hpp +++ b/cpp/src/branch_and_bound/node_queue.hpp @@ -15,8 +15,8 @@ namespace cuopt::math_optimization::mip { -using namespace cuopt::math_optimization::dual_simplex; // shared simplex types (lp_problem_t, - // etc.) +using namespace cuopt::math_optimization::simplex; // shared simplex types (lp_problem_t, + // etc.) // This is a generic heap implementation based // on the STL functions. The main benefit here is diff --git a/cpp/src/branch_and_bound/pseudo_costs.cpp b/cpp/src/branch_and_bound/pseudo_costs.cpp index a7589b4be8..4f8b37c16f 100644 --- a/cpp/src/branch_and_bound/pseudo_costs.cpp +++ b/cpp/src/branch_and_bound/pseudo_costs.cpp @@ -27,8 +27,8 @@ namespace cuopt::math_optimization::mip { -using namespace cuopt::math_optimization::dual_simplex; // shared simplex types (lp_problem_t, - // etc.) +using namespace cuopt::math_optimization::simplex; // shared simplex types (lp_problem_t, + // etc.) namespace { static bool is_dual_simplex_done(dual_status_t status) @@ -534,7 +534,7 @@ std::pair trial_branching(const lp_problem_t& orig template static cuopt::math_optimization::io::mps_data_model_t simplex_problem_to_mps_data_model( - const dual_simplex::lp_problem_t& lp, + const simplex::lp_problem_t& lp, const std::vector& new_slacks, const std::vector& root_soln, std::vector& original_root_soln_x) @@ -558,7 +558,7 @@ static cuopt::math_optimization::io::mps_data_model_t simplex_problem_ original_root_soln_x.resize(n); // Remove slacks from A - dual_simplex::csc_matrix_t A_no_slacks = lp.A; + simplex::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; @@ -570,7 +570,7 @@ static cuopt::math_optimization::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); + simplex::csr_matrix_t csr_A(m, n, 0); A_no_slacks.to_compressed_row(csr_A); int nz = csr_A.row_start[m]; diff --git a/cpp/src/branch_and_bound/pseudo_costs.hpp b/cpp/src/branch_and_bound/pseudo_costs.hpp index a87b709913..73d5b7b0ca 100644 --- a/cpp/src/branch_and_bound/pseudo_costs.hpp +++ b/cpp/src/branch_and_bound/pseudo_costs.hpp @@ -26,8 +26,8 @@ namespace cuopt::math_optimization::mip { -using namespace cuopt::math_optimization::dual_simplex; // shared simplex types (lp_problem_t, - // etc.) +using namespace cuopt::math_optimization::simplex; // shared simplex types (lp_problem_t, + // etc.) template struct mip_symmetry_t; diff --git a/cpp/src/branch_and_bound/symmetry.hpp b/cpp/src/branch_and_bound/symmetry.hpp index 814f77e8b4..be163a7fed 100644 --- a/cpp/src/branch_and_bound/symmetry.hpp +++ b/cpp/src/branch_and_bound/symmetry.hpp @@ -22,8 +22,8 @@ namespace cuopt::math_optimization::mip { -using namespace cuopt::math_optimization::dual_simplex; // shared simplex types (lp_problem_t, - // etc.) +using namespace cuopt::math_optimization::simplex; // shared simplex types (lp_problem_t, + // etc.) // permutation_t stores a dense permutation plus its support (non-identity entries). template diff --git a/cpp/src/branch_and_bound/worker.hpp b/cpp/src/branch_and_bound/worker.hpp index a217bfa620..1007779eeb 100644 --- a/cpp/src/branch_and_bound/worker.hpp +++ b/cpp/src/branch_and_bound/worker.hpp @@ -22,8 +22,8 @@ namespace cuopt::math_optimization::mip { -using namespace cuopt::math_optimization::dual_simplex; // shared simplex types (lp_problem_t, - // etc.) +using namespace cuopt::math_optimization::simplex; // shared simplex types (lp_problem_t, + // etc.) template struct branch_and_bound_stats_t { diff --git a/cpp/src/branch_and_bound/worker_pool.hpp b/cpp/src/branch_and_bound/worker_pool.hpp index bcf9af5f02..931d61f07e 100644 --- a/cpp/src/branch_and_bound/worker_pool.hpp +++ b/cpp/src/branch_and_bound/worker_pool.hpp @@ -12,8 +12,8 @@ namespace cuopt::math_optimization::mip { -using namespace cuopt::math_optimization::dual_simplex; // shared simplex types (lp_problem_t, - // etc.) +using namespace cuopt::math_optimization::simplex; // shared simplex types (lp_problem_t, + // etc.) template class worker_pool_t { diff --git a/cpp/src/cuts/cuts.cpp b/cpp/src/cuts/cuts.cpp index de5161b8a4..a90f435c5c 100644 --- a/cpp/src/cuts/cuts.cpp +++ b/cpp/src/cuts/cuts.cpp @@ -29,8 +29,8 @@ namespace cuopt::math_optimization::mip { -using namespace cuopt::math_optimization::dual_simplex; // shared simplex types (lp_problem_t, - // etc.) +using namespace cuopt::math_optimization::simplex; // shared simplex types (lp_problem_t, + // etc.) namespace { diff --git a/cpp/src/cuts/cuts.hpp b/cpp/src/cuts/cuts.hpp index 9241895082..831e7d6da7 100644 --- a/cpp/src/cuts/cuts.hpp +++ b/cpp/src/cuts/cuts.hpp @@ -34,8 +34,8 @@ struct clique_table_t; namespace cuopt::math_optimization::mip { -using namespace cuopt::math_optimization::dual_simplex; // shared simplex types (lp_problem_t, - // etc.) +using namespace cuopt::math_optimization::simplex; // shared simplex types (lp_problem_t, + // etc.) enum cut_type_t : int8_t { MIXED_INTEGER_GOMORY = 0, diff --git a/cpp/src/cuts/objective_step.cpp b/cpp/src/cuts/objective_step.cpp index c966862f30..d55a77cafa 100644 --- a/cpp/src/cuts/objective_step.cpp +++ b/cpp/src/cuts/objective_step.cpp @@ -16,8 +16,8 @@ namespace cuopt::math_optimization::mip { -using namespace cuopt::math_optimization::dual_simplex; // shared simplex types (objective_step_t, - // etc.) +using namespace cuopt::math_optimization::simplex; // shared simplex types (objective_step_t, + // etc.) namespace { diff --git a/cpp/src/cuts/objective_step.hpp b/cpp/src/cuts/objective_step.hpp index 3dbed08d95..5257a89050 100644 --- a/cpp/src/cuts/objective_step.hpp +++ b/cpp/src/cuts/objective_step.hpp @@ -14,8 +14,8 @@ namespace cuopt::math_optimization::mip { -using namespace cuopt::math_optimization::dual_simplex; // shared simplex types (objective_step_t, - // etc.) +using namespace cuopt::math_optimization::simplex; // shared simplex types (objective_step_t, + // etc.) // 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 diff --git a/cpp/src/dual_simplex/basis_solves.cpp b/cpp/src/dual_simplex/basis_solves.cpp index 0926956e44..aa7379fec0 100644 --- a/cpp/src/dual_simplex/basis_solves.cpp +++ b/cpp/src/dual_simplex/basis_solves.cpp @@ -15,7 +15,7 @@ #include -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_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::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::simplex diff --git a/cpp/src/dual_simplex/basis_solves.hpp b/cpp/src/dual_simplex/basis_solves.hpp index 5d5b2fea49..c50a6e1230 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::math_optimization::dual_simplex { +namespace cuopt::math_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::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::simplex diff --git a/cpp/src/dual_simplex/basis_updates.cpp b/cpp/src/dual_simplex/basis_updates.cpp index 8360716f9f..d5306e4615 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::math_optimization::dual_simplex { +namespace cuopt::math_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::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::simplex diff --git a/cpp/src/dual_simplex/basis_updates.hpp b/cpp/src/dual_simplex/basis_updates.hpp index 38a6105547..efac680770 100644 --- a/cpp/src/dual_simplex/basis_updates.hpp +++ b/cpp/src/dual_simplex/basis_updates.hpp @@ -15,7 +15,7 @@ #include -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_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::math_optimization::dual_simplex +} // namespace cuopt::math_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 79383ab8f9..258694461f 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::math_optimization::dual_simplex { +namespace cuopt::math_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::math_optimization::dual_simplex +} // namespace cuopt::math_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 ed16b9fbaf..506a97a3b8 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::math_optimization::dual_simplex { +namespace cuopt::math_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::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::simplex diff --git a/cpp/src/dual_simplex/bounds_strengthening.cpp b/cpp/src/dual_simplex/bounds_strengthening.cpp index 757100ce1a..9edc8af71a 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::math_optimization::dual_simplex { +namespace cuopt::math_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::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::simplex diff --git a/cpp/src/dual_simplex/bounds_strengthening.hpp b/cpp/src/dual_simplex/bounds_strengthening.hpp index a4bc759e27..1261e3f278 100644 --- a/cpp/src/dual_simplex/bounds_strengthening.hpp +++ b/cpp/src/dual_simplex/bounds_strengthening.hpp @@ -9,7 +9,7 @@ #include -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_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::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::simplex diff --git a/cpp/src/dual_simplex/crossover.cpp b/cpp/src/dual_simplex/crossover.cpp index 98a785847f..8594c97602 100644 --- a/cpp/src/dual_simplex/crossover.cpp +++ b/cpp/src/dual_simplex/crossover.cpp @@ -19,7 +19,7 @@ #include -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_optimization::simplex { namespace { @@ -1636,4 +1636,4 @@ template crossover_status_t crossover( #endif -} // namespace cuopt::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::simplex diff --git a/cpp/src/dual_simplex/crossover.hpp b/cpp/src/dual_simplex/crossover.hpp index 1b3f74ae8a..9684f439ec 100644 --- a/cpp/src/dual_simplex/crossover.hpp +++ b/cpp/src/dual_simplex/crossover.hpp @@ -13,7 +13,7 @@ #include #include -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_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::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::simplex diff --git a/cpp/src/dual_simplex/folding.cpp b/cpp/src/dual_simplex/folding.cpp index d32179d785..bee839328d 100644 --- a/cpp/src/dual_simplex/folding.cpp +++ b/cpp/src/dual_simplex/folding.cpp @@ -15,7 +15,7 @@ #include #include -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_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::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::simplex diff --git a/cpp/src/dual_simplex/folding.hpp b/cpp/src/dual_simplex/folding.hpp index 87dff2aa64..c4ff8558cd 100644 --- a/cpp/src/dual_simplex/folding.hpp +++ b/cpp/src/dual_simplex/folding.hpp @@ -11,11 +11,11 @@ #include #include -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_optimization::simplex { template void folding(lp_problem_t& problem, const simplex_solver_settings_t& settings, presolve_info_t& presolve_info); -} // namespace cuopt::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::simplex diff --git a/cpp/src/dual_simplex/initial_basis.cpp b/cpp/src/dual_simplex/initial_basis.cpp index c2a73c3e2f..57453e4819 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::math_optimization::dual_simplex { +namespace cuopt::math_optimization::simplex { uint8_t encode(variable_status_t vstatus) { @@ -325,4 +325,4 @@ template int initial_basis_selection( #endif -} // namespace cuopt::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::simplex diff --git a/cpp/src/dual_simplex/initial_basis.hpp b/cpp/src/dual_simplex/initial_basis.hpp index eab3a8d181..72c0fd069c 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::math_optimization::dual_simplex { +namespace cuopt::math_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::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::simplex diff --git a/cpp/src/dual_simplex/logger.hpp b/cpp/src/dual_simplex/logger.hpp index e5770b95af..80ad55287a 100644 --- a/cpp/src/dual_simplex/logger.hpp +++ b/cpp/src/dual_simplex/logger.hpp @@ -17,7 +17,7 @@ #include #include -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_optimization::simplex { class logger_t { public: @@ -128,4 +128,4 @@ class logger_t { std::FILE* log_file; }; -} // namespace cuopt::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::simplex diff --git a/cpp/src/dual_simplex/phase1.cpp b/cpp/src/dual_simplex/phase1.cpp index 8b16e694ce..895b496b48 100644 --- a/cpp/src/dual_simplex/phase1.cpp +++ b/cpp/src/dual_simplex/phase1.cpp @@ -15,7 +15,7 @@ #include #include -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_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::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::simplex diff --git a/cpp/src/dual_simplex/phase1.hpp b/cpp/src/dual_simplex/phase1.hpp index ca943f8307..c5a78e64f3 100644 --- a/cpp/src/dual_simplex/phase1.hpp +++ b/cpp/src/dual_simplex/phase1.hpp @@ -14,9 +14,9 @@ #include #include -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_optimization::simplex { template i_t create_phase1_problem(const lp_problem_t& lp, lp_problem_t& out); -} // namespace cuopt::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::simplex diff --git a/cpp/src/dual_simplex/phase2.cpp b/cpp/src/dual_simplex/phase2.cpp index 076e3af56e..5412c592cc 100644 --- a/cpp/src/dual_simplex/phase2.cpp +++ b/cpp/src/dual_simplex/phase2.cpp @@ -42,7 +42,7 @@ #include #include -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_optimization::simplex { constexpr int FEATURE_LOG_INTERVAL = 100; @@ -3294,7 +3294,7 @@ dual_status_t dual_phase2_with_advanced_basis(i_t phase, 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 = dual_simplex::primal_infeasibility(lp, settings, vstatus, x); + const f_t primal_inf = simplex::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()); @@ -3791,4 +3791,4 @@ template void compute_initial_nonbasic_end(const std::vector& std::vector& nonbasic_end); #endif -} // namespace cuopt::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::simplex diff --git a/cpp/src/dual_simplex/phase2.hpp b/cpp/src/dual_simplex/phase2.hpp index c911095259..e2cfaa377a 100644 --- a/cpp/src/dual_simplex/phase2.hpp +++ b/cpp/src/dual_simplex/phase2.hpp @@ -21,7 +21,7 @@ namespace cuopt { struct work_limit_context_t; } -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_optimization::simplex { enum class dual_status_t { OPTIMAL = 0, @@ -107,4 +107,4 @@ void compute_initial_nonbasic_end(const std::vector& basic_mark, csr_matrix_t& Arow, std::vector& nonbasic_end); -} // namespace cuopt::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::simplex diff --git a/cpp/src/dual_simplex/presolve.cpp b/cpp/src/dual_simplex/presolve.cpp index 9ec2237e15..8ae227becd 100644 --- a/cpp/src/dual_simplex/presolve.cpp +++ b/cpp/src/dual_simplex/presolve.cpp @@ -17,7 +17,7 @@ #include #include -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_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::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::simplex diff --git a/cpp/src/dual_simplex/presolve.hpp b/cpp/src/dual_simplex/presolve.hpp index 7e4fc32ba3..176e7bfa18 100644 --- a/cpp/src/dual_simplex/presolve.hpp +++ b/cpp/src/dual_simplex/presolve.hpp @@ -20,7 +20,7 @@ #include #include -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_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::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::simplex diff --git a/cpp/src/dual_simplex/primal.cpp b/cpp/src/dual_simplex/primal.cpp index b4c91b1741..77f4241e33 100644 --- a/cpp/src/dual_simplex/primal.cpp +++ b/cpp/src/dual_simplex/primal.cpp @@ -14,7 +14,7 @@ #include #include -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_optimization::simplex { namespace { @@ -558,4 +558,4 @@ template primal_status_t primal_phase2( #endif -} // namespace cuopt::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::simplex diff --git a/cpp/src/dual_simplex/primal.hpp b/cpp/src/dual_simplex/primal.hpp index 5b5a980673..7b36b375db 100644 --- a/cpp/src/dual_simplex/primal.hpp +++ b/cpp/src/dual_simplex/primal.hpp @@ -15,7 +15,7 @@ #include -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_optimization::simplex { enum class primal_status_t { OPTIMAL = 0, @@ -36,4 +36,4 @@ primal_status_t primal_phase2(i_t phase, lp_solution_t& sol, i_t& iter); -} // namespace cuopt::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::simplex diff --git a/cpp/src/dual_simplex/random.hpp b/cpp/src/dual_simplex/random.hpp index 1ee0304be0..1c79058594 100644 --- a/cpp/src/dual_simplex/random.hpp +++ b/cpp/src/dual_simplex/random.hpp @@ -9,7 +9,7 @@ #include -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_optimization::simplex { template class random_t { @@ -34,4 +34,4 @@ class random_t { std::mt19937 gen; }; -} // namespace cuopt::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::simplex diff --git a/cpp/src/dual_simplex/right_looking_lu.cpp b/cpp/src/dual_simplex/right_looking_lu.cpp index 5045979bd7..94088985e5 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::math_optimization::dual_simplex { +namespace cuopt::math_optimization::simplex { namespace { @@ -1813,4 +1813,4 @@ template int right_looking_ldlt(const csc_matrix_t& A, double& work_estimate); #endif -} // namespace cuopt::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::simplex diff --git a/cpp/src/dual_simplex/right_looking_lu.hpp b/cpp/src/dual_simplex/right_looking_lu.hpp index 8518fdc690..64595fe95f 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::math_optimization::dual_simplex { +namespace cuopt::math_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::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::simplex diff --git a/cpp/src/dual_simplex/scaling.cpp b/cpp/src/dual_simplex/scaling.cpp index ac436efc62..efcdfc0f15 100644 --- a/cpp/src/dual_simplex/scaling.cpp +++ b/cpp/src/dual_simplex/scaling.cpp @@ -10,7 +10,7 @@ #include -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_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::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::simplex diff --git a/cpp/src/dual_simplex/scaling.hpp b/cpp/src/dual_simplex/scaling.hpp index 5ba0b9baa6..4eaf810959 100644 --- a/cpp/src/dual_simplex/scaling.hpp +++ b/cpp/src/dual_simplex/scaling.hpp @@ -14,7 +14,7 @@ #include -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_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::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::simplex diff --git a/cpp/src/dual_simplex/simplex_solver_settings.hpp b/cpp/src/dual_simplex/simplex_solver_settings.hpp index 143e9ec69d..8c6a87ed1c 100644 --- a/cpp/src/dual_simplex/simplex_solver_settings.hpp +++ b/cpp/src/dual_simplex/simplex_solver_settings.hpp @@ -24,7 +24,7 @@ namespace cuopt::math_optimization { struct benchmark_info_t; } -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_optimization::simplex { template struct simplex_solver_settings_t { @@ -228,4 +228,4 @@ struct simplex_solver_settings_t { cuopt::math_optimization::benchmark_info_t* benchmark_info_ptr = nullptr; }; -} // namespace cuopt::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::simplex diff --git a/cpp/src/dual_simplex/singletons.cpp b/cpp/src/dual_simplex/singletons.cpp index 500d9cdde8..834c1a797b 100644 --- a/cpp/src/dual_simplex/singletons.cpp +++ b/cpp/src/dual_simplex/singletons.cpp @@ -11,7 +11,7 @@ #include -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_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::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::simplex diff --git a/cpp/src/dual_simplex/singletons.hpp b/cpp/src/dual_simplex/singletons.hpp index db66488e03..34007b7fed 100644 --- a/cpp/src/dual_simplex/singletons.hpp +++ b/cpp/src/dual_simplex/singletons.hpp @@ -12,7 +12,7 @@ #include #include -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_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::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::simplex diff --git a/cpp/src/dual_simplex/solution.hpp b/cpp/src/dual_simplex/solution.hpp index 53fa9c6867..2079d2224e 100644 --- a/cpp/src/dual_simplex/solution.hpp +++ b/cpp/src/dual_simplex/solution.hpp @@ -12,7 +12,7 @@ #include #include -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_optimization::simplex { template class lp_solution_t { @@ -78,4 +78,4 @@ class mip_solution_t { omp_atomic_t has_incumbent; }; -} // namespace cuopt::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::simplex diff --git a/cpp/src/dual_simplex/solve.cpp b/cpp/src/dual_simplex/solve.cpp index 5939a3389e..06ef949bff 100644 --- a/cpp/src/dual_simplex/solve.cpp +++ b/cpp/src/dual_simplex/solve.cpp @@ -33,12 +33,12 @@ #include #include -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_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()); } @@ -846,4 +846,4 @@ template int solve_mip_with_guess( #endif -} // namespace cuopt::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::simplex diff --git a/cpp/src/dual_simplex/solve.hpp b/cpp/src/dual_simplex/solve.hpp index 7b01d6ca37..f5fd7833cf 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::math_optimization::dual_simplex { +namespace cuopt::math_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::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::simplex diff --git a/cpp/src/dual_simplex/sparse_matrix.cpp b/cpp/src/dual_simplex/sparse_matrix.cpp index f2e887bfcc..4a1873cbc4 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::math_optimization::dual_simplex { +namespace cuopt::math_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::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::simplex diff --git a/cpp/src/dual_simplex/sparse_matrix.hpp b/cpp/src/dual_simplex/sparse_matrix.hpp index 75e3f1bc84..5edcd1ec0b 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::math_optimization::dual_simplex { +namespace cuopt::math_optimization::simplex { template class csr_matrix_t; // Forward declaration of CSR matrix needed to define CSC @@ -55,7 +55,7 @@ class csc_matrix_t { i_t col_length(i_t j) const { return col_start[j + 1] - col_start[j]; } // Convert the CSC matrix to a CSR matrix - i_t to_compressed_row(cuopt::math_optimization::dual_simplex::csr_matrix_t& Arow) const; + i_t to_compressed_row(cuopt::math_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; @@ -311,4 +311,4 @@ i_t matrix_vector_multiply( return 0; } -} // namespace cuopt::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::simplex diff --git a/cpp/src/dual_simplex/sparse_vector.cpp b/cpp/src/dual_simplex/sparse_vector.cpp index 6323bf3dc4..9ef07754a4 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::math_optimization::dual_simplex { +namespace cuopt::math_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::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::simplex diff --git a/cpp/src/dual_simplex/sparse_vector.hpp b/cpp/src/dual_simplex/sparse_vector.hpp index f3fb2c9e7c..3f0e0dbd50 100644 --- a/cpp/src/dual_simplex/sparse_vector.hpp +++ b/cpp/src/dual_simplex/sparse_vector.hpp @@ -12,7 +12,7 @@ #include -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_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::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::simplex diff --git a/cpp/src/dual_simplex/tic_toc.cpp b/cpp/src/dual_simplex/tic_toc.cpp index 0b0402c679..c113a8da00 100644 --- a/cpp/src/dual_simplex/tic_toc.cpp +++ b/cpp/src/dual_simplex/tic_toc.cpp @@ -9,7 +9,7 @@ #include -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_optimization::simplex { double tic() { @@ -24,4 +24,4 @@ double toc(double start) return (now - start); } -} // namespace cuopt::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::simplex diff --git a/cpp/src/dual_simplex/tic_toc.hpp b/cpp/src/dual_simplex/tic_toc.hpp index 419e91ce37..2e8bae608c 100644 --- a/cpp/src/dual_simplex/tic_toc.hpp +++ b/cpp/src/dual_simplex/tic_toc.hpp @@ -9,8 +9,8 @@ #include -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_optimization::simplex { double tic(); double toc(double start); -} // namespace cuopt::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::simplex diff --git a/cpp/src/dual_simplex/triangle_solve.cpp b/cpp/src/dual_simplex/triangle_solve.cpp index d04238119b..ba210a2f67 100644 --- a/cpp/src/dual_simplex/triangle_solve.cpp +++ b/cpp/src/dual_simplex/triangle_solve.cpp @@ -9,7 +9,7 @@ #include -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_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::math_optimization::dual_simplex { +namespace cuopt::math_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::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::simplex diff --git a/cpp/src/dual_simplex/types.hpp b/cpp/src/dual_simplex/types.hpp index 5da243c506..59094569cd 100644 --- a/cpp/src/dual_simplex/types.hpp +++ b/cpp/src/dual_simplex/types.hpp @@ -10,7 +10,7 @@ #include #include -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_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::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::simplex diff --git a/cpp/src/dual_simplex/user_problem.hpp b/cpp/src/dual_simplex/user_problem.hpp index 55d7ceb243..bbbcfafbc6 100644 --- a/cpp/src/dual_simplex/user_problem.hpp +++ b/cpp/src/dual_simplex/user_problem.hpp @@ -15,7 +15,7 @@ #include -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_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::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::simplex diff --git a/cpp/src/dual_simplex/vector_math.cpp b/cpp/src/dual_simplex/vector_math.cpp index d12366e563..93f65f1b0a 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::math_optimization::dual_simplex { +namespace cuopt::math_optimization::simplex { template f_t vector_norm2_squared(const std::vector& x) @@ -211,4 +211,4 @@ template int inverse_permutation(const std::vector& p, std::vector #include -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_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::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::simplex diff --git a/cpp/src/dual_simplex/vector_math.hpp b/cpp/src/dual_simplex/vector_math.hpp index 9441aa348f..5547c0a352 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::math_optimization::dual_simplex { +namespace cuopt::math_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::math_optimization::dual_simplex +} // namespace cuopt::math_optimization::simplex diff --git a/cpp/src/mip_heuristics/diversity/diversity_manager.cu b/cpp/src/mip_heuristics/diversity/diversity_manager.cu index ea061cc635..57fc82a29b 100644 --- a/cpp/src/mip_heuristics/diversity/diversity_manager.cu +++ b/cpp/src/mip_heuristics/diversity/diversity_manager.cu @@ -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; diff --git a/cpp/src/mip_heuristics/diversity/lns/rins.cu b/cpp/src/mip_heuristics/diversity/lns/rins.cu index 5abaddb539..627f7cce2a 100644 --- a/cpp/src/mip_heuristics/diversity/lns/rins.cu +++ b/cpp/src/mip_heuristics/diversity/lns/rins.cu @@ -234,10 +234,10 @@ 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::math_optimization::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); + namespace simplex = cuopt::math_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); @@ -264,7 +264,7 @@ void rins_t::run_rins() }; 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, dual_simplex::tic(), empty_probing); + 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); diff --git a/cpp/src/mip_heuristics/diversity/recombiners/sub_mip.cuh b/cpp/src/mip_heuristics/diversity/recombiners/sub_mip.cuh index bd2962d5b5..0ca102ca82 100644 --- a/cpp/src/mip_heuristics/diversity/recombiners/sub_mip.cuh +++ b/cpp/src/mip_heuristics/diversity/recombiners/sub_mip.cuh @@ -93,12 +93,12 @@ class sub_mip_recombiner_t : public recombiner_t { // brute force rounding threshold is 8 const bool run_sub_mip = fixed_problem.n_integer_vars > 8; mip::mip_status_t branch_and_bound_status = mip::mip_status_t::UNSET; - dual_simplex::mip_solution_t branch_and_bound_solution(1); + simplex::mip_solution_t branch_and_bound_solution(1); if (run_sub_mip) { // run sub-mip - namespace dual_simplex = cuopt::math_optimization::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::math_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 @@ -122,7 +122,7 @@ class sub_mip_recombiner_t : public recombiner_t { branch_and_bound_settings.log.log = false; 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, dual_simplex::tic(), empty_probing); + 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(), diff --git a/cpp/src/mip_heuristics/feasibility_jump/cpu_fj_thread.cuh b/cpp/src/mip_heuristics/feasibility_jump/cpu_fj_thread.cuh index 63d242d97e..a3c7d326b7 100644 --- a/cpp/src/mip_heuristics/feasibility_jump/cpu_fj_thread.cuh +++ b/cpp/src/mip_heuristics/feasibility_jump/cpu_fj_thread.cuh @@ -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); diff --git a/cpp/src/mip_heuristics/feasibility_jump/fj_cpu.cu b/cpp/src/mip_heuristics/feasibility_jump/fj_cpu.cu index a68b6534e8..0a6f537f40 100644 --- a/cpp/src/mip_heuristics/feasibility_jump/fj_cpu.cu +++ b/cpp/src/mip_heuristics/feasibility_jump/fj_cpu.cu @@ -1416,10 +1416,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 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::atomic& preemption_flag, int64_t seed) { @@ -1438,7 +1438,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 +1454,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 == simplex::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 +1465,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 +1475,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] != simplex::variable_type_t::CONTINUOUS) { value = std::clamp(std::round(value), problem.lower[j], problem.upper[j]); } projected_seed[j] = value; @@ -1795,10 +1795,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 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) @@ -1841,10 +1841,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 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); @@ -1873,10 +1873,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 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); diff --git a/cpp/src/mip_heuristics/local_search/local_search.cuh b/cpp/src/mip_heuristics/local_search/local_search.cuh index 6bf1ae8a93..e00aafaa46 100644 --- a/cpp/src/mip_heuristics/local_search/local_search.cuh +++ b/cpp/src/mip_heuristics/local_search/local_search.cuh @@ -15,7 +15,7 @@ #include #include -namespace cuopt::math_optimization::dual_simplex { +namespace cuopt::math_optimization::simplex { template class branch_and_bound_t; } 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 26ddef9f12..1a33a3fe38 100644 --- a/cpp/src/mip_heuristics/presolve/conflict_graph/clique_table.cu +++ b/cpp/src/mip_heuristics/presolve/conflict_graph/clique_table.cu @@ -99,7 +99,7 @@ void sort_csr_by_constraint_coefficients( template void make_coeff_positive_knapsack_constraint( - const dual_simplex::user_problem_t& problem, + const simplex::user_problem_t& problem, std::vector>& knapsack_constraints, typename mip_solver_settings_t::tolerances_t tolerances) { @@ -132,9 +132,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 simplex::user_problem_t& problem, std::vector>& knapsack_constraints, - dual_simplex::csr_matrix_t& A) + simplex::csr_matrix_t& A) { // we might add additional constraints for the equality constraints i_t added_constraints = 0; @@ -154,7 +154,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 +593,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 simplex::user_problem_t& problem, clique_table_t& clique_table, typename mip_solver_settings_t::tolerances_t tolerances, bool remove_small_cliques_flag, @@ -605,7 +605,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); + simplex::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 +662,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(simplex::user_problem_t& problem, typename mip_solver_settings_t::tolerances_t tolerances, std::shared_ptr>* clique_table_out, cuopt::timer_t& timer, @@ -680,7 +680,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); + simplex::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 +762,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, \ + 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); \ template void build_clique_table( \ - const dual_simplex::user_problem_t& problem, \ + const simplex::user_problem_t& problem, \ clique_table_t& clique_table, \ typename mip_solver_settings_t::tolerances_t tolerances, \ bool remove_small_cliques_flag, \ 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 4059390847..58f330a9e9 100644 --- a/cpp/src/mip_heuristics/presolve/conflict_graph/clique_table.cuh +++ b/cpp/src/mip_heuristics/presolve/conflict_graph/clique_table.cuh @@ -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, diff --git a/cpp/src/mip_heuristics/presolve/semi_continuous.cu b/cpp/src/mip_heuristics/presolve/semi_continuous.cu index cb0fac1f0b..af20d18c38 100644 --- a/cpp/src/mip_heuristics/presolve/semi_continuous.cu +++ b/cpp/src/mip_heuristics/presolve/semi_continuous.cu @@ -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; diff --git a/cpp/src/mip_heuristics/problem/problem.cu b/cpp/src/mip_heuristics/problem/problem.cu index 9fc9cdc1a0..f41e8c7f8c 100644 --- a/cpp/src/mip_heuristics/problem/problem.cu +++ b/cpp/src/mip_heuristics/problem/problem.cu @@ -1415,7 +1415,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()); @@ -2153,7 +2153,7 @@ void problem_t::preprocess_problem() template void problem_t::set_constraints_from_host_user_problem( - const cuopt::math_optimization::dual_simplex::user_problem_t& user_problem) + const cuopt::math_optimization::simplex::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 +2165,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()); + simplex::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); @@ -2274,7 +2274,7 @@ void problem_t::papilo_uncrush_assignment(rmm::device_uvector& as template void problem_t::get_host_user_problem( - cuopt::math_optimization::dual_simplex::user_problem_t& user_problem) const + cuopt::math_optimization::simplex::user_problem_t& user_problem) const { raft::common::nvtx::range fun_scope("get_host_user_problem"); // std::lock_guard lock(problem_mutex); @@ -2286,7 +2286,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); + simplex::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 +2361,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::math_optimization::dual_simplex::variable_type_t::CONTINUOUS - : cuopt::math_optimization::dual_simplex::variable_type_t::INTEGER; + user_problem.var_types[j] = model_variable_types[j] == var_t::CONTINUOUS + ? cuopt::math_optimization::simplex::variable_type_t::CONTINUOUS + : cuopt::math_optimization::simplex::variable_type_t::INTEGER; } } diff --git a/cpp/src/mip_heuristics/problem/problem.cuh b/cpp/src/mip_heuristics/problem/problem.cuh index 9056fdca5c..20a885a62e 100644 --- a/cpp/src/mip_heuristics/problem/problem.cuh +++ b/cpp/src/mip_heuristics/problem/problem.cuh @@ -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::math_optimization::dual_simplex::objective_step_t& get_objective_step() const + const cuopt::math_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::math_optimization::dual_simplex::user_problem_t& user_problem) const; + cuopt::math_optimization::simplex::user_problem_t& user_problem) const; void set_constraints_from_host_user_problem( - const cuopt::math_optimization::dual_simplex::user_problem_t& user_problem); + const cuopt::math_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::math_optimization::dual_simplex::objective_step_t objective_step; + cuopt::math_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. diff --git a/cpp/src/mip_heuristics/solve.cu b/cpp/src/mip_heuristics/solve.cu index 1132b676a6..38230d0c8b 100644 --- a/cpp/src/mip_heuristics/solve.cu +++ b/cpp/src/mip_heuristics/solve.cu @@ -209,10 +209,10 @@ 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::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 = + simplex::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; @@ -431,10 +431,10 @@ mip_solution_t solve_mip_helper(optimization_problem_t& op_p bool has_symmetry = false; if (settings.symmetry != 0) { mip::problem_t problem(op_problem); - dual_simplex::simplex_solver_settings_t simplex_settings; + simplex::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 = + simplex::user_problem_t user_problem = cuopt_problem_to_user_problem(op_problem.get_handle_ptr(), problem); symmetry = mip::detect_symmetry(user_problem, simplex_settings, has_symmetry); if (has_symmetry) { settings.presolver = presolver_t::None; } diff --git a/cpp/src/mip_heuristics/solver.cu b/cpp/src/mip_heuristics/solver.cu index 5a7581d711..8031aa1278 100644 --- a/cpp/src/mip_heuristics/solver.cu +++ b/cpp/src/mip_heuristics/solver.cu @@ -60,7 +60,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::simplex_solver_settings_t& settings) : dm(dm), settings_(settings) {}; void solution_callback(std::vector& solution, f_t objective) @@ -83,14 +83,14 @@ 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::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 simplex::user_problem_t& branch_and_bound_problem, const probing_cache_t& probing_cache, mip::probing_implied_bound_t& probing_implied_bound) @@ -296,10 +296,10 @@ 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::math_optimization::dual_simplex::simplex_solver_settings_t simplex_settings; + cuopt::math_optimization::simplex::simplex_solver_settings_t simplex_settings; simplex_settings.set_log(true); simplex_settings.time_limit = context.settings.time_limit; - cuopt::math_optimization::dual_simplex::user_problem_t post_presolve_problem = + cuopt::math_optimization::simplex::user_problem_t post_presolve_problem = cuopt_problem_to_user_problem(context.problem_ptr->handle_ptr, *context.problem_ptr); bool has_symmetry_post = false; @@ -308,9 +308,9 @@ solution_t mip_solver_t::run_solver() } #endif - namespace dual_simplex = cuopt::math_optimization::dual_simplex; + namespace simplex = cuopt::math_optimization::simplex; mip::mip_status_t branch_and_bound_status = mip::mip_status_t::UNSET; - dual_simplex::user_problem_t branch_and_bound_problem(context.problem_ptr->handle_ptr); + simplex::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 +328,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; + simplex::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); 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 simplex::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); diff --git a/cpp/src/pdlp/solve.cu b/cpp/src/pdlp/solve.cu index ca0f8362d1..633d2c1ad7 100644 --- a/cpp/src/pdlp/solve.cu +++ b/cpp/src/pdlp/solve.cu @@ -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; } @@ -444,8 +442,8 @@ optimization_problem_solution_t convert_dual_simplex_sol( template optimization_problem_solution_t convert_dual_simplex_sol( mip::problem_t& 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, @@ -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,8 +519,8 @@ 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); barrier::project_barrier_solution_to_model_variables(user_problem, solution); @@ -531,10 +529,9 @@ run_barrier(dual_simplex::user_problem_t& user_problem, !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; } @@ -549,7 +546,7 @@ optimization_problem_solution_t run_barrier( 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; } @@ -623,7 +618,7 @@ optimization_problem_solution_t run_dual_simplex( 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, @@ -831,41 +826,39 @@ optimization_problem_solution_t run_pdlp(mip::problem_t& pro 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 = @@ -1496,16 +1489,15 @@ 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)); } @@ -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; @@ -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, diff --git a/cpp/src/pdlp/translate.hpp b/cpp/src/pdlp/translate.hpp index 986a43149b..913fbaffeb 100644 --- a/cpp/src/pdlp/translate.hpp +++ b/cpp/src/pdlp/translate.hpp @@ -26,10 +26,10 @@ namespace cuopt::math_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); @@ -86,10 +86,9 @@ static dual_simplex::user_problem_t cuopt_problem_to_user_problem( auto variable_types = problem.get_variable_types_host(); for (int j = 0; j < n; ++j) { - user_problem.var_types[j] = - variable_types[j] == var_t::CONTINUOUS - ? cuopt::math_optimization::dual_simplex::variable_type_t::CONTINUOUS - : cuopt::math_optimization::dual_simplex::variable_type_t::INTEGER; + user_problem.var_types[j] = variable_types[j] == var_t::CONTINUOUS + ? cuopt::math_optimization::simplex::variable_type_t::CONTINUOUS + : cuopt::math_optimization::simplex::variable_type_t::INTEGER; } user_problem.Q_offsets = problem.get_quadratic_objective_offsets(); @@ -100,10 +99,10 @@ static dual_simplex::user_problem_t cuopt_problem_to_user_problem( } 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, 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 +111,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())); @@ -180,10 +179,9 @@ static dual_simplex::user_problem_t cuopt_problem_to_user_problem( auto model_variable_types = cuopt::host_copy(model.variable_types, handle_ptr->get_stream()); for (int j = 0; j < n; ++j) { - user_problem.var_types[j] = - model_variable_types[j] == var_t::CONTINUOUS - ? cuopt::math_optimization::dual_simplex::variable_type_t::CONTINUOUS - : cuopt::math_optimization::dual_simplex::variable_type_t::INTEGER; + user_problem.var_types[j] = model_variable_types[j] == var_t::CONTINUOUS + ? cuopt::math_optimization::simplex::variable_type_t::CONTINUOUS + : cuopt::math_optimization::simplex::variable_type_t::INTEGER; } user_problem.Q_offsets = model.Q_offsets; @@ -201,10 +199,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 +222,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 +302,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::math_optimization::dual_simplex::variable_type_t::CONTINUOUS - : cuopt::math_optimization::dual_simplex::variable_type_t::INTEGER; + ? cuopt::math_optimization::simplex::variable_type_t::CONTINUOUS + : cuopt::math_optimization::simplex::variable_type_t::INTEGER; } user_problem.Q_offsets = model.get_quadratic_objective_offsets(); @@ -325,16 +323,15 @@ static dual_simplex::user_problem_t cuopt_optimization_problem_to_user template 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 +344,7 @@ void translate_to_crossover_problem(const mip::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); 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 3bf50e6d54..d5bf854d42 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::math_optimization::dual_simplex::test { +namespace cuopt::math_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::math_optimization::dual_simplex::test +} // namespace cuopt::math_optimization::simplex::test diff --git a/cpp/tests/dual_simplex/unit_tests/solve.cpp b/cpp/tests/dual_simplex/unit_tests/solve.cpp index a21d211e5e..72785e3bad 100644 --- a/cpp/tests/dual_simplex/unit_tests/solve.cpp +++ b/cpp/tests/dual_simplex/unit_tests/solve.cpp @@ -19,14 +19,14 @@ #include #include -namespace cuopt::math_optimization::dual_simplex::test { +namespace cuopt::math_optimization::simplex::test { TEST(dual_simplex, chess_set) { cuopt::init_logger_t log("", true); - namespace dual_simplex = cuopt::math_optimization::dual_simplex; + namespace simplex = cuopt::math_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::math_optimization::dual_simplex::user_problem_t user_problem(&handle); + cuopt::math_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,12 @@ 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::math_optimization::dual_simplex::variable_type_t::INTEGER; + user_problem.var_types[j] = cuopt::math_optimization::simplex::variable_type_t::INTEGER; } - cuopt::math_optimization::dual_simplex::simplex_solver_settings_t settings; + cuopt::math_optimization::simplex::simplex_solver_settings_t settings; std::vector solution(num_items); - EXPECT_EQ((cuopt::math_optimization::dual_simplex::solve(user_problem, settings, solution)), 0); + EXPECT_EQ((cuopt::math_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 +185,7 @@ TEST(dual_simplex, empty_columns) // take[i] binary for all i raft::handle_t handle{}; - cuopt::math_optimization::dual_simplex::user_problem_t user_problem(&handle); + cuopt::math_optimization::simplex::user_problem_t user_problem(&handle); constexpr int m = 1; constexpr int n = num_items; constexpr int nz = num_items - 1; @@ -232,16 +232,16 @@ TEST(dual_simplex, empty_columns) 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::math_optimization::dual_simplex::variable_type_t::CONTINUOUS; + user_problem.var_types[j] = cuopt::math_optimization::simplex::variable_type_t::CONTINUOUS; } - cuopt::math_optimization::dual_simplex::simplex_solver_settings_t settings; + cuopt::math_optimization::simplex::simplex_solver_settings_t settings; - cuopt::math_optimization::dual_simplex::lp_solution_t solution( - user_problem.num_rows, user_problem.num_cols); - EXPECT_EQ((cuopt::math_optimization::dual_simplex::solve_linear_program( - user_problem, settings, solution)), - cuopt::math_optimization::dual_simplex::lp_status_t::OPTIMAL); + cuopt::math_optimization::simplex::lp_solution_t solution(user_problem.num_rows, + user_problem.num_cols); + EXPECT_EQ( + (cuopt::math_optimization::simplex::solve_linear_program(user_problem, settings, solution)), + cuopt::math_optimization::simplex::lp_status_t::OPTIMAL); double objective = 0.0; for (int j = 0; j < num_items; ++j) { objective += value[j] * solution.x[j]; @@ -267,7 +267,7 @@ TEST(dual_simplex, dual_variable_greater_than) // x0, x1 >= 0 raft::handle_t handle{}; - cuopt::math_optimization::dual_simplex::user_problem_t user_problem(&handle); + cuopt::math_optimization::simplex::user_problem_t user_problem(&handle); constexpr int m = 2; constexpr int n = 2; constexpr int nz = 4; @@ -311,16 +311,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); @@ -330,4 +330,4 @@ TEST(dual_simplex, dual_variable_greater_than) EXPECT_NEAR(solution.z[1], 0.0, 1e-6); } -} // namespace cuopt::math_optimization::dual_simplex::test +} // namespace cuopt::math_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 1022dd4995..ecad27016c 100644 --- a/cpp/tests/dual_simplex/unit_tests/solve_barrier.cu +++ b/cpp/tests/dual_simplex/unit_tests/solve_barrier.cu @@ -27,7 +27,7 @@ #include #include -namespace cuopt::math_optimization::dual_simplex::test { +namespace cuopt::math_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::math_optimization::dual_simplex; + namespace simplex = cuopt::math_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::math_optimization::dual_simplex::user_problem_t user_problem(&handle); + cuopt::math_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); @@ -217,4 +217,4 @@ TEST(barrier, min_x_squared_free_variable_dual_correction) EXPECT_NEAR(h_z[0], 0.0, tol); } -} // namespace cuopt::math_optimization::dual_simplex::test +} // namespace cuopt::math_optimization::simplex::test diff --git a/cpp/tests/mip/cuts_test.cu b/cpp/tests/mip/cuts_test.cu index 50ae39f9c6..52a1802a47 100644 --- a/cpp/tests/mip/cuts_test.cu +++ b/cpp/tests/mip/cuts_test.cu @@ -142,7 +142,7 @@ mip::clique_table_t build_clique_table_for_model_with_min_size( { auto op_problem = mps_data_model_to_optimization_problem(&handle, model); mip::problem_t mip_problem(op_problem); - dual_simplex::user_problem_t host_problem(op_problem.get_handle_ptr()); + simplex::user_problem_t host_problem(op_problem.get_handle_ptr()); mip_problem.get_host_user_problem(host_problem); mip::clique_config_t clique_config; @@ -847,7 +847,7 @@ TEST(cuts, test_cuts_2) TEST(cuts, test_duplicate_cuts_detection) { - dual_simplex::simplex_solver_settings_t settings; + simplex::simplex_solver_settings_t settings; mip::cut_pool_t cut_pool(4, settings); mip::inequality_t cut1; cut1.push_back(0, 1.0); @@ -1346,11 +1346,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,16 +1361,15 @@ 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); mip::problem_t mip_problem(op_problem); - dual_simplex::user_problem_t host_problem(op_problem.get_handle_ptr()); + 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; diff --git a/cpp/tests/mip/problem_test.cu b/cpp/tests/mip/problem_test.cu index c1d6e20726..477ff24ea3 100644 --- a/cpp/tests/mip/problem_test.cu +++ b/cpp/tests/mip/problem_test.cu @@ -205,7 +205,7 @@ TEST(problem, run_small_tests) } } -namespace ds = cuopt::math_optimization::dual_simplex; +namespace ds = cuopt::math_optimization::simplex; template void test_roundtrip_equivalence(i_t n_cnst, i_t n_var) diff --git a/cpp/tests/socp/general_quadratic_test.cu b/cpp/tests/socp/general_quadratic_test.cu index 154949dba9..7639640bf0 100644 --- a/cpp/tests/socp/general_quadratic_test.cu +++ b/cpp/tests/socp/general_quadratic_test.cu @@ -46,7 +46,7 @@ TEST(general_quadratic, dense_pd_2x2_solve) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::math_optimization::dual_simplex; + using namespace cuopt::math_optimization::simplex; user_problem_t user_problem(&handle); // Need at least one linear constraint for the barrier solver. @@ -91,7 +91,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); + simplex::csr_matrix_t csr_A(m, n, nz); csr_A.m = m; csr_A.n = n; csr_A.row_start = {0, 2}; @@ -159,7 +159,7 @@ TEST(general_quadratic, rejects_non_convex) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::math_optimization::dual_simplex; + using namespace cuopt::math_optimization::simplex; user_problem_t user_problem(&handle); constexpr int m = 0; @@ -194,7 +194,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); + simplex::csr_matrix_t csr_A(m, n, nz); csr_A.m = m; csr_A.n = n; csr_A.row_start = {0}; @@ -217,7 +217,7 @@ TEST(general_quadratic, rank_deficient_psd_solve) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::math_optimization::dual_simplex; + using namespace cuopt::math_optimization::simplex; user_problem_t user_problem(&handle); constexpr int m = 1; @@ -257,7 +257,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); + simplex::csr_matrix_t csr_A(m, n, nz); csr_A.m = m; csr_A.n = n; csr_A.row_start = {0, 2}; @@ -302,7 +302,7 @@ TEST(general_quadratic, with_inequality_constraint) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::math_optimization::dual_simplex; + using namespace cuopt::math_optimization::simplex; user_problem_t user_problem(&handle); // 2 constraints: one equality, one inequality @@ -348,7 +348,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); + simplex::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 +400,7 @@ TEST(general_quadratic, least_squares_b_in_range) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::math_optimization::dual_simplex; + using namespace cuopt::math_optimization::simplex; user_problem_t user_problem(&handle); // Variables: x0, x1, u (u = t - b^T*b = t - 5). @@ -460,7 +460,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); + simplex::csr_matrix_t csr_A(m, n, nz); csr_A.m = m; csr_A.n = n; csr_A.row_start = {0, 2}; @@ -519,7 +519,7 @@ TEST(general_quadratic, least_squares_b_not_in_range) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::math_optimization::dual_simplex; + using namespace cuopt::math_optimization::simplex; user_problem_t user_problem(&handle); constexpr int m = 1; @@ -562,7 +562,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); + simplex::csr_matrix_t csr_A(m, n, nz); csr_A.m = m; csr_A.n = n; csr_A.row_start = {0, 2}; @@ -592,7 +592,7 @@ TEST(general_quadratic, soc_head_nonneg_accepted) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::math_optimization::dual_simplex; + using namespace cuopt::math_optimization::simplex; user_problem_t user_problem(&handle); // Variables: x0, x1, t. Constraint: x0^2 + x1^2 - t^2 <= 0 @@ -637,7 +637,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); + simplex::csr_matrix_t csr_A(m, n, 1); csr_A.m = m; csr_A.n = n; csr_A.row_start = {0, 1}; @@ -659,7 +659,7 @@ TEST(general_quadratic, soc_head_free_rejected) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::math_optimization::dual_simplex; + using namespace cuopt::math_optimization::simplex; user_problem_t user_problem(&handle); constexpr int m = 1; @@ -695,7 +695,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); + simplex::csr_matrix_t csr_A(m, n, nz); csr_A.m = m; csr_A.n = n; csr_A.row_start = {0, 1}; @@ -715,7 +715,7 @@ TEST(general_quadratic, rotated_soc_heads_nonneg_accepted) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::math_optimization::dual_simplex; + using namespace cuopt::math_optimization::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); + simplex::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,7 @@ TEST(general_quadratic, rotated_soc_heads_free_rejected) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::math_optimization::dual_simplex; + using namespace cuopt::math_optimization::simplex; user_problem_t user_problem(&handle); constexpr int m = 1; @@ -810,7 +810,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); + simplex::csr_matrix_t csr_A(m, n, nz); csr_A.m = m; csr_A.n = n; csr_A.row_start = {0, 1}; diff --git a/cpp/tests/socp/solve_barrier_socp.cu b/cpp/tests/socp/solve_barrier_socp.cu index f2f7cc88bb..716ae4b293 100644 --- a/cpp/tests/socp/solve_barrier_socp.cu +++ b/cpp/tests/socp/solve_barrier_socp.cu @@ -20,7 +20,7 @@ #include #include -namespace cuopt::math_optimization::dual_simplex::test { +namespace cuopt::math_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,7 @@ TEST(barrier, cone_metadata_reindexed_when_slack_is_inserted_before_cones) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::math_optimization::dual_simplex; + using namespace cuopt::math_optimization::simplex; user_problem_t user_problem(&handle); constexpr int m = 1; @@ -98,7 +98,7 @@ TEST(barrier, presolve_reindexes_cone_start_after_empty_column_removal) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::math_optimization::dual_simplex; + using namespace cuopt::math_optimization::simplex; user_problem_t user_problem(&handle); constexpr int m = 1; @@ -167,7 +167,7 @@ TEST(barrier, presolve_keeps_direct_free_variables_before_cones) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::math_optimization::dual_simplex; + using namespace cuopt::math_optimization::simplex; user_problem_t user_problem(&handle); constexpr int m = 1; @@ -230,7 +230,7 @@ TEST(barrier, rejects_middle_cone_input_before_barrier) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::math_optimization::dual_simplex; + using namespace cuopt::math_optimization::simplex; user_problem_t user_problem(&handle); constexpr int m = 3; @@ -282,7 +282,7 @@ TEST(barrier, socp_min_x0_subject_to_norm_constraint) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::math_optimization::dual_simplex; + using namespace cuopt::math_optimization::simplex; user_problem_t user_problem(&handle); constexpr int m = 1; @@ -343,7 +343,7 @@ TEST(barrier, mixed_linear_and_soc_block) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::math_optimization::dual_simplex; + using namespace cuopt::math_optimization::simplex; user_problem_t user_problem(&handle); constexpr int m = 2; @@ -409,7 +409,7 @@ TEST(barrier, mixed_linear_and_soc_tail_coupling) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::math_optimization::dual_simplex; + using namespace cuopt::math_optimization::simplex; user_problem_t user_problem(&handle); constexpr int m = 2; @@ -476,7 +476,7 @@ TEST(barrier, mixed_linear_and_soc_tail_coupling_with_inequality) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::math_optimization::dual_simplex; + using namespace cuopt::math_optimization::simplex; user_problem_t user_problem(&handle); constexpr int m = 2; @@ -546,7 +546,7 @@ TEST(barrier, mixed_linear_and_two_soc_blocks) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::math_optimization::dual_simplex; + using namespace cuopt::math_optimization::simplex; user_problem_t user_problem(&handle); constexpr int m = 4; @@ -627,7 +627,7 @@ TEST(barrier, mixed_linear_and_two_soc_blocks_with_inequality) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::math_optimization::dual_simplex; + using namespace cuopt::math_optimization::simplex; user_problem_t user_problem(&handle); constexpr int m = 4; @@ -707,7 +707,7 @@ TEST(barrier, free_linear_prefix_is_uncrushed_correctly_with_soc_block) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::math_optimization::dual_simplex; + using namespace cuopt::math_optimization::simplex; user_problem_t user_problem(&handle); constexpr int m = 2; @@ -771,7 +771,7 @@ TEST(barrier, qp_with_soc_block) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::math_optimization::dual_simplex; + using namespace cuopt::math_optimization::simplex; user_problem_t user_problem(&handle); constexpr int m = 1; @@ -824,4 +824,4 @@ TEST(barrier, qp_with_soc_block) EXPECT_NEAR(std::abs(solution.x[3]), 0.0, 1e-4); } -} // namespace cuopt::math_optimization::dual_simplex::test +} // namespace cuopt::math_optimization::simplex::test From d5726ae4f26b56b548fb3e45b1a3e785f9b9534c Mon Sep 17 00:00:00 2001 From: Miles Lubin Date: Mon, 22 Jun 2026 15:51:54 +0000 Subject: [PATCH 10/17] refactor: remove using-namespace directives from headers Header-scope 'using namespace' leaks into every including TU. Replace with explicit qualification in the affected barrier/branch_and_bound/cuts headers (and grpc_server_types.hpp). TU-local directives in .cpp/.cu are left as-is. Co-Authored-By: Claude Opus 4.8 (1M context) Signed-off-by: Miles Lubin --- cpp/src/barrier/barrier.hpp | 47 ++- cpp/src/barrier/conjugate_gradient.hpp | 5 +- cpp/src/barrier/cusparse_view.hpp | 4 +- cpp/src/barrier/dense_matrix.hpp | 5 +- cpp/src/barrier/dense_vector.hpp | 9 +- cpp/src/barrier/device_sparse_matrix.cuh | 21 +- cpp/src/barrier/iterative_refinement.hpp | 3 - cpp/src/barrier/sparse_cholesky.cuh | 55 ++-- cpp/src/branch_and_bound/branch_and_bound.hpp | 60 ++-- .../deterministic_workers.hpp | 53 ++-- .../branch_and_bound/diving_heuristics.hpp | 23 +- cpp/src/branch_and_bound/mip_node.hpp | 19 +- cpp/src/branch_and_bound/node_queue.hpp | 5 +- cpp/src/branch_and_bound/pseudo_costs.hpp | 28 +- cpp/src/branch_and_bound/symmetry.hpp | 47 ++- cpp/src/branch_and_bound/worker.hpp | 33 +-- cpp/src/branch_and_bound/worker_pool.hpp | 11 +- cpp/src/cuts/cuts.hpp | 277 +++++++++--------- cpp/src/cuts/objective_step.hpp | 5 +- cpp/src/grpc/server/grpc_server_types.hpp | 5 +- cpp/src/grpc/server/grpc_service_impl.cpp | 2 + cpp/src/grpc/server/grpc_worker.cpp | 2 + 22 files changed, 340 insertions(+), 379 deletions(-) diff --git a/cpp/src/barrier/barrier.hpp b/cpp/src/barrier/barrier.hpp index a903b98b92..a0caaef12b 100644 --- a/cpp/src/barrier/barrier.hpp +++ b/cpp/src/barrier/barrier.hpp @@ -18,13 +18,10 @@ #include namespace cuopt::math_optimization::barrier { -using namespace cuopt::math_optimization::simplex; // shared simplex types (lp_problem_t, inf, - // etc.) - -/** 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 @@ -32,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, @@ -101,21 +98,21 @@ 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_; }; diff --git a/cpp/src/barrier/conjugate_gradient.hpp b/cpp/src/barrier/conjugate_gradient.hpp index 7ecfce9db9..ff85140bf1 100644 --- a/cpp/src/barrier/conjugate_gradient.hpp +++ b/cpp/src/barrier/conjugate_gradient.hpp @@ -18,12 +18,9 @@ namespace cuopt::math_optimization::barrier { -using namespace cuopt::math_optimization::simplex; // shared simplex types (lp_problem_t, inf, - // etc.) - 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) diff --git a/cpp/src/barrier/cusparse_view.hpp b/cpp/src/barrier/cusparse_view.hpp index c601869e1c..f302173727 100644 --- a/cpp/src/barrier/cusparse_view.hpp +++ b/cpp/src/barrier/cusparse_view.hpp @@ -23,13 +23,11 @@ // This allows handling many different X Y vector along with one common matrix namespace cuopt::math_optimization::barrier { -using namespace cuopt::math_optimization::simplex; // shared simplex types (lp_problem_t, inf, - // etc.) 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(); pdlp::cusparse_dn_vec_descr_wrapper_t create_vector(rmm::device_uvector const& vec); diff --git a/cpp/src/barrier/dense_matrix.hpp b/cpp/src/barrier/dense_matrix.hpp index e8e94a4560..58dffbfbfe 100644 --- a/cpp/src/barrier/dense_matrix.hpp +++ b/cpp/src/barrier/dense_matrix.hpp @@ -14,9 +14,6 @@ namespace cuopt::math_optimization::barrier { -using namespace cuopt::math_optimization::simplex; // shared simplex types (lp_problem_t, inf, - // etc.) - template class dense_matrix_t { public: @@ -35,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; diff --git a/cpp/src/barrier/dense_vector.hpp b/cpp/src/barrier/dense_vector.hpp index f170e9e6c2..a31ded0551 100644 --- a/cpp/src/barrier/dense_vector.hpp +++ b/cpp/src/barrier/dense_vector.hpp @@ -14,9 +14,6 @@ namespace cuopt::math_optimization::barrier { -using namespace cuopt::math_optimization::simplex; // shared simplex types (lp_problem_t, inf, - // etc.) - template > class dense_vector_t : public std::vector { public: @@ -59,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]); } @@ -69,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]); } @@ -189,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]); } diff --git a/cpp/src/barrier/device_sparse_matrix.cuh b/cpp/src/barrier/device_sparse_matrix.cuh index 650820433e..f4dc7dc38e 100644 --- a/cpp/src/barrier/device_sparse_matrix.cuh +++ b/cpp/src/barrier/device_sparse_matrix.cuh @@ -25,9 +25,6 @@ namespace cuopt::math_optimization::barrier { -using namespace cuopt::math_optimization::simplex; // shared simplex types (lp_problem_t, inf, - // etc.) - template class device_csr_matrix_t; @@ -128,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]), @@ -149,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; @@ -171,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) @@ -255,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]), @@ -276,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; diff --git a/cpp/src/barrier/iterative_refinement.hpp b/cpp/src/barrier/iterative_refinement.hpp index 66c887580c..96a8cfa37c 100644 --- a/cpp/src/barrier/iterative_refinement.hpp +++ b/cpp/src/barrier/iterative_refinement.hpp @@ -30,9 +30,6 @@ namespace cuopt::math_optimization::barrier { -using namespace cuopt::math_optimization::simplex; // shared simplex types (lp_problem_t, inf, - // etc.) - // Functors for device operations (defined at namespace scope to avoid CUDA lambda restrictions) template struct scale_op { diff --git a/cpp/src/barrier/sparse_cholesky.cuh b/cpp/src/barrier/sparse_cholesky.cuh index 8ae1ffc4f9..43823e550f 100644 --- a/cpp/src/barrier/sparse_cholesky.cuh +++ b/cpp/src/barrier/sparse_cholesky.cuh @@ -22,15 +22,12 @@ namespace cuopt::math_optimization::barrier { -using namespace cuopt::math_optimization::simplex; // shared simplex types (lp_problem_t, inf, - // etc.) - 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; @@ -138,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), @@ -393,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"); @@ -476,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; { @@ -493,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); @@ -511,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( @@ -535,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()); @@ -554,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) { @@ -572,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; } @@ -602,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"); @@ -695,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( @@ -714,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)); @@ -736,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); } @@ -760,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; } @@ -891,7 +888,7 @@ 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; diff --git a/cpp/src/branch_and_bound/branch_and_bound.hpp b/cpp/src/branch_and_bound/branch_and_bound.hpp index 031f6727fa..0e79d0311b 100644 --- a/cpp/src/branch_and_bound/branch_and_bound.hpp +++ b/cpp/src/branch_and_bound/branch_and_bound.hpp @@ -47,9 +47,6 @@ struct clique_table_t; namespace cuopt::math_optimization::mip { -using namespace cuopt::math_optimization::simplex; // shared simplex types (lp_problem_t, - // etc.) - template struct mip_symmetry_t; @@ -79,8 +76,8 @@ 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, @@ -141,13 +138,14 @@ 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, @@ -162,8 +160,8 @@ 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_; omp_atomic_t signal_extend_cliques_{false}; @@ -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). @@ -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}; @@ -282,13 +280,13 @@ class branch_and_bound_t { 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, @@ -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); diff --git a/cpp/src/branch_and_bound/deterministic_workers.hpp b/cpp/src/branch_and_bound/deterministic_workers.hpp index e04e466313..2698e8b8a4 100644 --- a/cpp/src/branch_and_bound/deterministic_workers.hpp +++ b/cpp/src/branch_and_bound/deterministic_workers.hpp @@ -24,9 +24,6 @@ namespace cuopt::math_optimization::mip { -using namespace cuopt::math_optimization::simplex; // shared simplex types (lp_problem_t, - // etc.) - template struct backlog_node_compare_t { bool operator()(const mip_node_t* a, const mip_node_t* b) const @@ -88,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), @@ -140,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)) { } @@ -296,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) @@ -318,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; @@ -405,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) { @@ -440,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); diff --git a/cpp/src/branch_and_bound/diving_heuristics.hpp b/cpp/src/branch_and_bound/diving_heuristics.hpp index 3581440694..d75f9245db 100644 --- a/cpp/src/branch_and_bound/diving_heuristics.hpp +++ b/cpp/src/branch_and_bound/diving_heuristics.hpp @@ -18,9 +18,6 @@ namespace cuopt::math_optimization::mip { -using namespace cuopt::math_optimization::simplex; // shared simplex types (lp_problem_t, - // etc.) - // When `log_diving_type` is true, each diving strategy gets its own letter; // otherwise every dive collapses to 'D'. inline char feasible_solution_symbol(search_strategy_t strategy, bool log_diving_type) @@ -59,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::math_optimization::mip diff --git a/cpp/src/branch_and_bound/mip_node.hpp b/cpp/src/branch_and_bound/mip_node.hpp index 967463cc0f..dfb52ad1e3 100644 --- a/cpp/src/branch_and_bound/mip_node.hpp +++ b/cpp/src/branch_and_bound/mip_node.hpp @@ -23,9 +23,6 @@ namespace cuopt::math_optimization::mip { -using namespace cuopt::math_optimization::simplex; // shared simplex types (lp_problem_t, - // etc.) - enum class node_status_t : int { PENDING = 0, // Node is still in the tree, waiting to be solved INTEGER_FEASIBLE = 1, // Node has an integer feasible solution @@ -100,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), @@ -116,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), @@ -386,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); @@ -428,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) @@ -438,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, diff --git a/cpp/src/branch_and_bound/node_queue.hpp b/cpp/src/branch_and_bound/node_queue.hpp index 5b222f80a1..672c7c60f9 100644 --- a/cpp/src/branch_and_bound/node_queue.hpp +++ b/cpp/src/branch_and_bound/node_queue.hpp @@ -15,9 +15,6 @@ namespace cuopt::math_optimization::mip { -using namespace cuopt::math_optimization::simplex; // shared simplex types (lp_problem_t, - // etc.) - // This is a generic heap implementation based // on the STL functions. The main benefit here is // that we access the underlying container. @@ -111,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, diff --git a/cpp/src/branch_and_bound/pseudo_costs.hpp b/cpp/src/branch_and_bound/pseudo_costs.hpp index 73d5b7b0ca..553ce8a198 100644 --- a/cpp/src/branch_and_bound/pseudo_costs.hpp +++ b/cpp/src/branch_and_bound/pseudo_costs.hpp @@ -26,9 +26,6 @@ namespace cuopt::math_optimization::mip { -using namespace cuopt::math_optimization::simplex; // shared simplex types (lp_problem_t, - // etc.) - template struct mip_symmetry_t; @@ -110,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), @@ -192,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, @@ -215,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; @@ -276,20 +274,20 @@ 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); diff --git a/cpp/src/branch_and_bound/symmetry.hpp b/cpp/src/branch_and_bound/symmetry.hpp index be163a7fed..faba88868a 100644 --- a/cpp/src/branch_and_bound/symmetry.hpp +++ b/cpp/src/branch_and_bound/symmetry.hpp @@ -22,9 +22,6 @@ namespace cuopt::math_optimization::mip { -using namespace cuopt::math_optimization::simplex; // shared simplex types (lp_problem_t, - // etc.) - // permutation_t stores a dense permutation plus its support (non-identity entries). template class permutation_t { @@ -341,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) { @@ -608,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; @@ -683,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; } } @@ -732,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]; @@ -838,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; @@ -940,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 @@ -973,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); @@ -1063,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)) { @@ -1117,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( diff --git a/cpp/src/branch_and_bound/worker.hpp b/cpp/src/branch_and_bound/worker.hpp index 1007779eeb..28f58e1a45 100644 --- a/cpp/src/branch_and_bound/worker.hpp +++ b/cpp/src/branch_and_bound/worker.hpp @@ -22,9 +22,6 @@ namespace cuopt::math_optimization::mip { -using namespace cuopt::math_optimization::simplex; // shared simplex types (lp_problem_t, - // etc.) - template struct branch_and_bound_stats_t { f_t start_time = 0.0; @@ -57,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; @@ -93,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), @@ -117,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); @@ -145,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) { @@ -231,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); diff --git a/cpp/src/branch_and_bound/worker_pool.hpp b/cpp/src/branch_and_bound/worker_pool.hpp index 931d61f07e..c2867568fb 100644 --- a/cpp/src/branch_and_bound/worker_pool.hpp +++ b/cpp/src/branch_and_bound/worker_pool.hpp @@ -12,9 +12,6 @@ namespace cuopt::math_optimization::mip { -using namespace cuopt::math_optimization::simplex; // shared simplex types (lp_problem_t, - // etc.) - template class worker_pool_t { public: @@ -22,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_); diff --git a/cpp/src/cuts/cuts.hpp b/cpp/src/cuts/cuts.hpp index 831e7d6da7..eedef2aea7 100644 --- a/cpp/src/cuts/cuts.hpp +++ b/cpp/src/cuts/cuts.hpp @@ -34,9 +34,6 @@ struct clique_table_t; namespace cuopt::math_optimization::mip { -using namespace cuopt::math_optimization::simplex; // shared simplex types (lp_problem_t, - // etc.) - enum cut_type_t : int8_t { MIXED_INTEGER_GOMORY = 0, MIXED_INTEGER_ROUNDING = 1, @@ -114,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) @@ -190,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()) { @@ -203,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); @@ -254,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); @@ -279,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), @@ -297,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); @@ -317,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_; @@ -380,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; }; @@ -397,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); @@ -520,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); @@ -577,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 @@ -588,12 +587,12 @@ 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) @@ -607,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, @@ -623,63 +622,63 @@ 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_; omp_atomic_t* signal_extend_{nullptr}; @@ -746,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), @@ -762,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, @@ -784,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; @@ -834,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; } } @@ -860,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; } } @@ -882,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); @@ -896,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); @@ -909,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: @@ -920,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, @@ -938,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); @@ -953,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); @@ -972,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, @@ -1008,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::math_optimization::mip diff --git a/cpp/src/cuts/objective_step.hpp b/cpp/src/cuts/objective_step.hpp index 5257a89050..17e59d19b8 100644 --- a/cpp/src/cuts/objective_step.hpp +++ b/cpp/src/cuts/objective_step.hpp @@ -14,9 +14,6 @@ namespace cuopt::math_optimization::mip { -using namespace cuopt::math_optimization::simplex; // shared simplex types (objective_step_t, - // etc.) - // 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 // and not implied-integer). Returns a default-constructed (zero) objective_step_t when no @@ -26,7 +23,7 @@ using namespace cuopt::math_optimization::simplex; // shared simplex types (obj // 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, diff --git a/cpp/src/grpc/server/grpc_server_types.hpp b/cpp/src/grpc/server/grpc_server_types.hpp index b569907884..1eb1ff6878 100644 --- a/cpp/src/grpc/server/grpc_server_types.hpp +++ b/cpp/src/grpc/server/grpc_server_types.hpp @@ -60,8 +60,9 @@ using grpc::ServerWriter; using grpc::Status; using grpc::StatusCode; -using namespace cuopt::math_optimization; -// Note: NOT using "using namespace cuopt::remote" to avoid JobStatus enum conflict +// Note: cuopt::math_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) diff --git a/cpp/src/grpc/server/grpc_service_impl.cpp b/cpp/src/grpc/server/grpc_service_impl.cpp index 6fc363d5ed..33c44c8a13 100644 --- a/cpp/src/grpc/server/grpc_service_impl.cpp +++ b/cpp/src/grpc/server/grpc_service_impl.cpp @@ -9,6 +9,8 @@ #include "grpc_pipe_serialization.hpp" #include "grpc_server_types.hpp" +using namespace cuopt::math_optimization; + class CuOptRemoteServiceImpl final : public cuopt::remote::CuOptRemoteService::Service { public: // Unary submit: the entire problem fits in a single gRPC message. diff --git a/cpp/src/grpc/server/grpc_worker.cpp b/cpp/src/grpc/server/grpc_worker.cpp index 5df602553a..6747a2e796 100644 --- a/cpp/src/grpc/server/grpc_worker.cpp +++ b/cpp/src/grpc/server/grpc_worker.cpp @@ -9,6 +9,8 @@ #include "grpc_pipe_serialization.hpp" #include "grpc_server_types.hpp" +using namespace cuopt::math_optimization; + // --------------------------------------------------------------------------- // Data-transfer structs used to pass results between decomposed functions. // --------------------------------------------------------------------------- From 801d31c63b9df2f474e5f2b1d79685a4382c0444 Mon Sep 17 00:00:00 2001 From: Miles Lubin Date: Mon, 22 Jun 2026 16:00:39 +0000 Subject: [PATCH 11/17] docs: fix stale dual_simplex namespace references in comments The dual_simplex namespace was renamed to simplex; update two barrier explicit-instantiation comments that still named the old namespace. The dual_simplex/ include paths and DUAL_SIMPLEX_* macros are unchanged. Co-Authored-By: Claude Opus 4.8 (1M context) Signed-off-by: Miles Lubin --- cpp/src/barrier/device_sparse_matrix.cu | 4 ++-- cpp/src/barrier/pinned_host_allocator.cu | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/cpp/src/barrier/device_sparse_matrix.cu b/cpp/src/barrier/device_sparse_matrix.cu index c0ed8b3b3a..bae20e58b9 100644 --- a/cpp/src/barrier/device_sparse_matrix.cu +++ b/cpp/src/barrier/device_sparse_matrix.cu @@ -11,9 +11,9 @@ #include // This translation unit provides out-of-line definitions and explicit -// instantiations of shared dual_simplex sparse-matrix templates (csc_matrix_t, +// instantiations of shared simplex sparse-matrix templates (csc_matrix_t, // matrix_transpose_vector_multiply) specialized with barrier's -// PinnedHostAllocator. They must live in the dual_simplex namespace (where the +// PinnedHostAllocator. They must live in the simplex namespace (where the // templates are declared), even though the file resides under barrier/. namespace cuopt::math_optimization::simplex { diff --git a/cpp/src/barrier/pinned_host_allocator.cu b/cpp/src/barrier/pinned_host_allocator.cu index 00e6ef49e4..4f9a7f2393 100644 --- a/cpp/src/barrier/pinned_host_allocator.cu +++ b/cpp/src/barrier/pinned_host_allocator.cu @@ -60,8 +60,8 @@ template class PinnedHostAllocator; namespace cuopt::math_optimization::simplex { -// Explicit instantiation of the shared dual_simplex vector_math template with -// barrier's PinnedHostAllocator must live in dual_simplex (the template's namespace). +// 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>( From 58dc479f1fdd19cc5f89252ab88c388f91c7442d Mon Sep 17 00:00:00 2001 From: Miles Lubin Date: Mon, 22 Jun 2026 18:37:26 +0000 Subject: [PATCH 12/17] refactor: rename cuopt::math_optimization -> cuopt::mathematical_optimization Umbrella namespace + public include path rename (per team naming decision). include/cuopt/math_optimization -> include/cuopt/mathematical_optimization. No structural change; sub-namespaces (pdlp/simplex/barrier/mip/io) ride along. Python package cuopt.linear_programming unchanged; C API shim forward target updated. Co-Authored-By: Claude Opus 4.8 (1M context) Signed-off-by: Miles Lubin --- .coderabbit.yaml | 2 +- .github/.coderabbit_review_guide.md | 6 +- .../cuopt/benchmark_helper.hpp | 26 +- .../cuopt/initial_problem_check.hpp | 2 +- .../linear_programming/cuopt/run_mip.cpp | 42 +- .../linear_programming/cuopt/run_pdlp.cu | 65 +- ci/test_doc_examples.sh | 6 +- cpp/cuopt_cli.cpp | 59 +- cpp/doxygen/Doxyfile | 4 +- cpp/include/cuopt/error.hpp | 2 +- .../cuopt/linear_programming/cuopt_c.h | 10 +- .../backend_selection.hpp | 4 +- .../constants.h | 0 .../cpu_optimization_problem.hpp | 6 +- .../cpu_optimization_problem_solution.hpp | 16 +- .../cpu_pdlp_warm_start_data.hpp | 6 +- .../csr_matrix_utils.hpp | 4 +- .../cuopt_c.h | 2 +- .../io/data_model_view.hpp | 6 +- .../io/mps_data_model.hpp | 4 +- .../io/mps_writer.hpp | 8 +- .../io/parser.hpp | 6 +- .../io/utilities/cython_parser.hpp | 6 +- .../io/writer.hpp | 6 +- .../mip/diving_hyper_params.hpp | 4 +- .../mip/heuristics_hyper_params.hpp | 4 +- .../mip/solver_settings.hpp | 14 +- .../mip/solver_solution.hpp | 10 +- .../mip/solver_stats.hpp | 4 +- .../optimization_problem.hpp | 8 +- .../optimization_problem_interface.hpp | 6 +- .../optimization_problem_solution.hpp | 14 +- ...ptimization_problem_solution_interface.hpp | 14 +- .../optimization_problem_utils.hpp | 16 +- .../pdlp/pdlp_hyper_params.cuh | 4 +- .../pdlp/pdlp_warm_start_data.hpp | 4 +- .../pdlp/solver_settings.hpp | 14 +- .../pdlp/solver_solution.hpp | 12 +- .../solve.hpp | 36 +- .../solve_remote.hpp | 6 +- .../solver_settings.hpp | 14 +- .../utilities/callbacks_implems.hpp | 2 +- .../utilities/cython_solve.hpp | 36 +- .../utilities/cython_types.hpp | 12 +- .../utilities/internals.hpp | 6 +- .../utilities/segmented_sum_handler.cuh | 0 cpp/src/barrier/barrier.cu | 8 +- cpp/src/barrier/barrier.hpp | 4 +- cpp/src/barrier/conjugate_gradient.hpp | 4 +- cpp/src/barrier/cusparse_info.hpp | 4 +- cpp/src/barrier/cusparse_view.cu | 8 +- cpp/src/barrier/cusparse_view.hpp | 4 +- cpp/src/barrier/dense_matrix.hpp | 4 +- cpp/src/barrier/dense_vector.hpp | 4 +- cpp/src/barrier/device_sparse_matrix.cu | 6 +- cpp/src/barrier/device_sparse_matrix.cuh | 4 +- cpp/src/barrier/iterative_refinement.hpp | 4 +- cpp/src/barrier/pinned_host_allocator.cu | 19 +- cpp/src/barrier/pinned_host_allocator.hpp | 4 +- cpp/src/barrier/second_order_cone_kernels.cuh | 4 +- .../barrier/second_order_cone_reduction.cuh | 4 +- cpp/src/barrier/sparse_cholesky.cuh | 4 +- cpp/src/barrier/sparse_matrix_kernels.cuh | 4 +- cpp/src/barrier/translate_soc.hpp | 28 +- cpp/src/branch_and_bound/bb_event.hpp | 4 +- cpp/src/branch_and_bound/branch_and_bound.cpp | 10 +- cpp/src/branch_and_bound/branch_and_bound.hpp | 8 +- cpp/src/branch_and_bound/constants.hpp | 4 +- .../deterministic_workers.hpp | 4 +- .../branch_and_bound/diving_heuristics.cpp | 8 +- .../branch_and_bound/diving_heuristics.hpp | 6 +- cpp/src/branch_and_bound/mip_node.hpp | 4 +- cpp/src/branch_and_bound/node_queue.hpp | 4 +- cpp/src/branch_and_bound/pseudo_costs.cpp | 22 +- cpp/src/branch_and_bound/pseudo_costs.hpp | 4 +- .../shared_strong_branching_context.hpp | 4 +- cpp/src/branch_and_bound/symmetry.hpp | 4 +- cpp/src/branch_and_bound/worker.hpp | 4 +- cpp/src/branch_and_bound/worker_pool.hpp | 4 +- cpp/src/cuts/cuts.cpp | 8 +- cpp/src/cuts/cuts.hpp | 6 +- cpp/src/cuts/objective_step.cpp | 8 +- cpp/src/cuts/objective_step.hpp | 4 +- cpp/src/cuts/rational.hpp | 4 +- cpp/src/dual_simplex/basis_solves.cpp | 4 +- cpp/src/dual_simplex/basis_solves.hpp | 4 +- cpp/src/dual_simplex/basis_updates.cpp | 4 +- cpp/src/dual_simplex/basis_updates.hpp | 4 +- .../bound_flipping_ratio_test.cpp | 4 +- .../bound_flipping_ratio_test.hpp | 4 +- cpp/src/dual_simplex/bounds_strengthening.cpp | 4 +- cpp/src/dual_simplex/bounds_strengthening.hpp | 4 +- cpp/src/dual_simplex/crossover.cpp | 4 +- cpp/src/dual_simplex/crossover.hpp | 4 +- cpp/src/dual_simplex/folding.cpp | 4 +- cpp/src/dual_simplex/folding.hpp | 4 +- cpp/src/dual_simplex/initial_basis.cpp | 4 +- cpp/src/dual_simplex/initial_basis.hpp | 4 +- cpp/src/dual_simplex/logger.hpp | 4 +- cpp/src/dual_simplex/phase1.cpp | 4 +- cpp/src/dual_simplex/phase1.hpp | 4 +- cpp/src/dual_simplex/phase2.cpp | 4 +- cpp/src/dual_simplex/phase2.hpp | 4 +- cpp/src/dual_simplex/presolve.cpp | 4 +- cpp/src/dual_simplex/presolve.hpp | 4 +- cpp/src/dual_simplex/primal.cpp | 4 +- cpp/src/dual_simplex/primal.hpp | 4 +- cpp/src/dual_simplex/random.hpp | 4 +- cpp/src/dual_simplex/right_looking_lu.cpp | 4 +- cpp/src/dual_simplex/right_looking_lu.hpp | 4 +- cpp/src/dual_simplex/scaling.cpp | 4 +- cpp/src/dual_simplex/scaling.hpp | 4 +- .../dual_simplex/simplex_solver_settings.hpp | 10 +- cpp/src/dual_simplex/singletons.cpp | 4 +- cpp/src/dual_simplex/singletons.hpp | 4 +- cpp/src/dual_simplex/solution.hpp | 4 +- cpp/src/dual_simplex/solve.cpp | 4 +- cpp/src/dual_simplex/solve.hpp | 4 +- cpp/src/dual_simplex/sparse_matrix.cpp | 4 +- cpp/src/dual_simplex/sparse_matrix.hpp | 7 +- cpp/src/dual_simplex/sparse_vector.cpp | 4 +- cpp/src/dual_simplex/sparse_vector.hpp | 4 +- cpp/src/dual_simplex/tic_toc.cpp | 4 +- cpp/src/dual_simplex/tic_toc.hpp | 4 +- cpp/src/dual_simplex/triangle_solve.cpp | 4 +- cpp/src/dual_simplex/triangle_solve.hpp | 4 +- cpp/src/dual_simplex/types.hpp | 4 +- cpp/src/dual_simplex/user_problem.hpp | 4 +- cpp/src/dual_simplex/vector_math.cpp | 4 +- cpp/src/dual_simplex/vector_math.cuh | 4 +- cpp/src/dual_simplex/vector_math.hpp | 4 +- cpp/src/grpc/client/grpc_client.cpp | 8 +- cpp/src/grpc/client/grpc_client.hpp | 12 +- cpp/src/grpc/client/solve_remote.cpp | 12 +- cpp/src/grpc/codegen/field_registry.yaml | 2 +- cpp/src/grpc/grpc_chunk_key.hpp | 4 +- cpp/src/grpc/grpc_problem_mapper.cpp | 12 +- cpp/src/grpc/grpc_problem_mapper.hpp | 4 +- cpp/src/grpc/grpc_service_mapper.cpp | 10 +- cpp/src/grpc/grpc_service_mapper.hpp | 4 +- cpp/src/grpc/grpc_settings_mapper.cpp | 12 +- cpp/src/grpc/grpc_settings_mapper.hpp | 4 +- cpp/src/grpc/grpc_solution_mapper.cpp | 12 +- cpp/src/grpc/grpc_solution_mapper.hpp | 10 +- .../grpc/server/grpc_pipe_serialization.hpp | 20 +- cpp/src/grpc/server/grpc_server_types.hpp | 12 +- cpp/src/grpc/server/grpc_service_impl.cpp | 4 +- cpp/src/grpc/server/grpc_worker.cpp | 4 +- cpp/src/io/data_model_view.cpp | 6 +- cpp/src/io/file_to_string.cpp | 10 +- cpp/src/io/file_to_string.hpp | 4 +- cpp/src/io/lp_parser.cpp | 6 +- cpp/src/io/lp_parser.hpp | 6 +- cpp/src/io/mps_data_model.cpp | 6 +- cpp/src/io/mps_parser.cpp | 12 +- cpp/src/io/mps_parser_internal.hpp | 6 +- cpp/src/io/mps_writer.cpp | 10 +- cpp/src/io/parser.cpp | 6 +- cpp/src/io/utilities/cython_parser.cpp | 18 +- cpp/src/io/utilities/error.hpp | 4 +- cpp/src/io/writer.cpp | 8 +- cpp/src/math_optimization/solution_reader.cu | 4 +- cpp/src/math_optimization/solution_reader.hpp | 4 +- cpp/src/math_optimization/solution_writer.cu | 4 +- cpp/src/math_optimization/solution_writer.hpp | 4 +- cpp/src/math_optimization/solver_settings.cu | 6 +- .../diversity/assignment_hash_map.cu | 4 +- .../diversity/assignment_hash_map.cuh | 4 +- .../diversity/diversity_config.hpp | 4 +- .../diversity/diversity_manager.cu | 4 +- .../diversity/diversity_manager.cuh | 8 +- cpp/src/mip_heuristics/diversity/lns/rins.cu | 6 +- cpp/src/mip_heuristics/diversity/lns/rins.cuh | 4 +- .../diversity/multi_armed_bandit.cu | 4 +- .../diversity/multi_armed_bandit.cuh | 4 +- .../mip_heuristics/diversity/population.cu | 4 +- .../mip_heuristics/diversity/population.cuh | 4 +- .../recombiners/bound_prop_recombiner.cuh | 4 +- .../diversity/recombiners/fp_recombiner.cuh | 4 +- .../recombiners/line_segment_recombiner.cuh | 4 +- .../diversity/recombiners/recombiner.cuh | 4 +- .../recombiners/recombiner_configs.hpp | 4 +- .../recombiners/recombiner_stats.hpp | 4 +- .../diversity/recombiners/sub_mip.cuh | 8 +- cpp/src/mip_heuristics/diversity/weights.cuh | 4 +- cpp/src/mip_heuristics/early_heuristic.cuh | 6 +- .../feasibility_jump/cpu_fj_thread.cuh | 4 +- .../feasibility_jump/early_cpufj.cu | 4 +- .../feasibility_jump/early_cpufj.cuh | 4 +- .../feasibility_jump/early_gpufj.cu | 4 +- .../feasibility_jump/early_gpufj.cuh | 4 +- .../feasibility_jump/feasibility_jump.cu | 4 +- .../feasibility_jump/feasibility_jump.cuh | 6 +- .../feasibility_jump_impl_common.cuh | 4 +- .../feasibility_jump_kernels.cu | 4 +- .../feasibility_jump_kernels.cuh | 4 +- .../mip_heuristics/feasibility_jump/fj_cpu.cu | 4 +- .../feasibility_jump/fj_cpu.cuh | 4 +- .../mip_heuristics/feasibility_jump/utils.cuh | 4 +- .../feasibility_pump/feasibility_pump.cu | 6 +- .../feasibility_pump/feasibility_pump.cuh | 4 +- .../local_search/lagrangian.cuh | 4 +- .../line_segment_search.cu | 4 +- .../line_segment_search.cuh | 4 +- .../local_search/local_search.cu | 4 +- .../local_search/local_search.cuh | 6 +- .../local_search/local_search_config.hpp | 4 +- .../local_search/rounding/bounds_repair.cu | 4 +- .../local_search/rounding/bounds_repair.cuh | 4 +- .../local_search/rounding/constraint_prop.cu | 4 +- .../local_search/rounding/constraint_prop.cuh | 4 +- .../local_search/rounding/lb_bounds_repair.cu | 4 +- .../rounding/lb_bounds_repair.cuh | 4 +- .../rounding/lb_constraint_prop.cu | 4 +- .../rounding/lb_constraint_prop.cuh | 4 +- .../local_search/rounding/simple_rounding.cu | 4 +- .../local_search/rounding/simple_rounding.cuh | 4 +- .../rounding/simple_rounding_kernels.cuh | 4 +- cpp/src/mip_heuristics/logger.cuh | 4 +- cpp/src/mip_heuristics/mip_constants.hpp | 2 +- .../mip_heuristics/mip_scaling_strategy.cu | 31 +- .../mip_heuristics/mip_scaling_strategy.cuh | 9 +- .../presolve/bounds_presolve.cu | 6 +- .../presolve/bounds_presolve.cuh | 4 +- .../presolve/bounds_presolve_helpers.cuh | 4 +- .../presolve/bounds_update_data.cu | 4 +- .../presolve/bounds_update_data.cuh | 4 +- .../presolve/bounds_update_helpers.cuh | 4 +- .../conditional_bound_strengthening.cu | 4 +- .../conditional_bound_strengthening.cuh | 4 +- .../presolve/conflict_graph/clique_table.cu | 4 +- .../presolve/conflict_graph/clique_table.cuh | 6 +- .../mip_heuristics/presolve/gf2_presolve.cpp | 4 +- .../mip_heuristics/presolve/gf2_presolve.hpp | 4 +- .../presolve/lb_probing_cache.cu | 4 +- .../presolve/load_balanced_bounds_presolve.cu | 4 +- .../load_balanced_bounds_presolve.cuh | 4 +- .../load_balanced_bounds_presolve_helpers.cuh | 4 +- .../load_balanced_bounds_presolve_kernels.cuh | 4 +- .../load_balanced_partition_helpers.cuh | 4 +- .../mip_heuristics/presolve/multi_probe.cu | 4 +- .../mip_heuristics/presolve/multi_probe.cuh | 4 +- .../mip_heuristics/presolve/probing_cache.cu | 4 +- .../mip_heuristics/presolve/probing_cache.cuh | 4 +- .../presolve/semi_continuous.cu | 4 +- .../presolve/semi_continuous.cuh | 8 +- .../presolve/third_party_presolve.cpp | 17 +- .../presolve/third_party_presolve.hpp | 28 +- .../presolve/trivial_presolve.cu | 4 +- .../presolve/trivial_presolve.cuh | 4 +- .../presolve/trivial_presolve_helpers.cuh | 4 +- cpp/src/mip_heuristics/presolve/utils.cuh | 4 +- .../mip_heuristics/problem/host_helper.cuh | 6 +- .../problem/load_balanced_problem.cu | 4 +- .../problem/load_balanced_problem.cuh | 8 +- .../mip_heuristics/problem/presolve_data.cu | 22 +- .../mip_heuristics/problem/presolve_data.cuh | 6 +- cpp/src/mip_heuristics/problem/problem.cu | 17 +- cpp/src/mip_heuristics/problem/problem.cuh | 20 +- .../mip_heuristics/problem/problem_fixing.cuh | 4 +- .../problem/problem_helpers.cuh | 4 +- .../problem/problem_kernels.cuh | 4 +- cpp/src/mip_heuristics/problem/write_mps.cu | 4 +- .../mip_heuristics/relaxed_lp/lp_state.cuh | 4 +- .../mip_heuristics/relaxed_lp/relaxed_lp.cu | 4 +- .../mip_heuristics/relaxed_lp/relaxed_lp.cuh | 8 +- .../solution/feasibility_test.cuh | 4 +- cpp/src/mip_heuristics/solution/solution.cu | 27 +- cpp/src/mip_heuristics/solution/solution.cuh | 15 +- .../solution/solution_kernels.cuh | 4 +- cpp/src/mip_heuristics/solve.cu | 58 +- cpp/src/mip_heuristics/solver.cu | 12 +- cpp/src/mip_heuristics/solver.cuh | 10 +- cpp/src/mip_heuristics/solver_context.cuh | 8 +- cpp/src/mip_heuristics/solver_settings.cu | 6 +- cpp/src/mip_heuristics/solver_solution.cu | 6 +- cpp/src/mip_heuristics/utilities/sort_csr.cuh | 4 +- cpp/src/mip_heuristics/utils.cuh | 6 +- cpp/src/pdlp/backend_selection.cpp | 6 +- cpp/src/pdlp/cpu_optimization_problem.cpp | 20 +- cpp/src/pdlp/cpu_pdlp_warm_start_data.cu | 8 +- cpp/src/pdlp/cuopt_c.cpp | 24 +- cpp/src/pdlp/cuopt_c_internal.hpp | 18 +- cpp/src/pdlp/cusparse_view.cu | 4 +- cpp/src/pdlp/cusparse_view.hpp | 6 +- .../initial_scaling.cu | 8 +- .../initial_scaling.cuh | 6 +- .../optimal_batch_size_handler.cu | 4 +- .../optimal_batch_size_handler.hpp | 4 +- cpp/src/pdlp/optimization_problem.cu | 20 +- cpp/src/pdlp/pdhg.cu | 4 +- cpp/src/pdlp/pdhg.hpp | 6 +- cpp/src/pdlp/pdlp.cu | 12 +- cpp/src/pdlp/pdlp.cuh | 8 +- cpp/src/pdlp/pdlp_constants.hpp | 4 +- cpp/src/pdlp/pdlp_warm_start_data.cu | 8 +- .../localized_duality_gap_container.cu | 6 +- .../localized_duality_gap_container.hpp | 6 +- .../restart_strategy/pdlp_restart_strategy.cu | 6 +- .../pdlp_restart_strategy.cuh | 6 +- .../weighted_average_solution.cu | 4 +- .../weighted_average_solution.hpp | 4 +- cpp/src/pdlp/saddle_point.cu | 4 +- cpp/src/pdlp/saddle_point.hpp | 6 +- cpp/src/pdlp/solution_conversion.cu | 10 +- cpp/src/pdlp/solve.cu | 53 +- cpp/src/pdlp/solve.cuh | 21 +- cpp/src/pdlp/solver_settings.cu | 8 +- cpp/src/pdlp/solver_solution.cu | 6 +- .../adaptive_step_size_strategy.cu | 6 +- .../adaptive_step_size_strategy.hpp | 6 +- cpp/src/pdlp/swap_and_resize_helper.cuh | 4 +- .../convergence_information.cu | 6 +- .../convergence_information.hpp | 10 +- .../infeasibility_information.cu | 6 +- .../infeasibility_information.hpp | 8 +- .../termination_strategy.cu | 10 +- .../termination_strategy.hpp | 10 +- cpp/src/pdlp/translate.hpp | 26 +- cpp/src/pdlp/utilities/cython_solve.cu | 104 ++- cpp/src/pdlp/utilities/ping_pong_graph.cu | 4 +- cpp/src/pdlp/utilities/ping_pong_graph.cuh | 4 +- cpp/src/pdlp/utilities/problem_checking.cu | 6 +- cpp/src/pdlp/utilities/problem_checking.cuh | 10 +- cpp/src/pdlp/utils.cuh | 4 +- .../unit_tests/right_looking_ldlt.cpp | 4 +- cpp/tests/dual_simplex/unit_tests/solve.cpp | 36 +- .../dual_simplex/unit_tests/solve_barrier.cu | 22 +- .../c_api_tests/c_api_test.c | 2 +- .../c_api_tests/c_api_tests.cpp | 10 +- .../c_api_tests/c_api_tests.h | 2 +- .../grpc/grpc_client_test.cpp | 14 +- .../grpc/grpc_client_test_helper.hpp | 4 +- .../grpc/grpc_integration_test.cpp | 20 +- .../grpc/grpc_pipe_serialization_test.cpp | 2 +- .../grpc/grpc_test_log_capture.hpp | 4 +- cpp/tests/linear_programming/parser_test.cpp | 8 +- cpp/tests/linear_programming/pdlp_test.cu | 857 ++++++++++-------- .../unit_tests/optimization_problem_test.cu | 10 +- .../unit_tests/presolve_test.cu | 48 +- .../unit_tests/solution_interface_test.cu | 22 +- .../unit_tests/solver_settings_test.cu | 22 +- .../utilities/pdlp_test_utilities.cuh | 47 +- cpp/tests/mip/bounds_standardization_test.cu | 16 +- cpp/tests/mip/cuts_test.cu | 15 +- cpp/tests/mip/determinism_test.cu | 12 +- cpp/tests/mip/doc_example_test.cu | 14 +- cpp/tests/mip/elim_var_remap_test.cu | 14 +- cpp/tests/mip/empty_fixed_problems_test.cu | 6 +- cpp/tests/mip/feasibility_jump_tests.cu | 14 +- cpp/tests/mip/heuristics_hyper_params_test.cu | 8 +- cpp/tests/mip/incumbent_callback_test.cu | 25 +- cpp/tests/mip/integer_with_real_bounds.cu | 10 +- cpp/tests/mip/load_balancing_test.cu | 10 +- cpp/tests/mip/mip_utils.cuh | 26 +- cpp/tests/mip/miplib_test.cu | 22 +- cpp/tests/mip/multi_probe_test.cu | 10 +- cpp/tests/mip/presolve_test.cu | 16 +- cpp/tests/mip/problem_test.cu | 24 +- cpp/tests/mip/semi_continuous_test.cu | 8 +- cpp/tests/mip/server_test.cu | 26 +- cpp/tests/mip/termination_test.cu | 8 +- cpp/tests/mip/unit_test.cu | 81 +- .../qp/unit_tests/lp_parser_solve_test.cu | 12 +- cpp/tests/qp/unit_tests/mps_writer_test.cpp | 21 +- cpp/tests/qp/unit_tests/no_constraints.cu | 8 +- cpp/tests/qp/unit_tests/two_variable_test.cu | 8 +- cpp/tests/socp/general_quadratic_test.cu | 26 +- cpp/tests/socp/second_order_cone_kernels.cu | 4 +- cpp/tests/socp/solve_barrier_socp.cu | 32 +- cpp/tests/utilities/inline_lp_test_utils.hpp | 6 +- cpp/tests/utilities/inline_mps_test_utils.hpp | 6 +- .../source/cuopt-c/convex/convex-examples.rst | 2 +- .../examples/general_quadratic_example.c | 2 +- .../cuopt-c/convex/examples/lp_file_example.c | 2 +- .../convex/examples/mps_file_example.c | 2 +- .../convex/examples/rotated_socp_example.c | 2 +- .../convex/examples/simple_lp_example.c | 2 +- .../convex/examples/simple_qp_example.c | 2 +- .../convex/examples/simple_socp_example.c | 2 +- .../cuopt-c/mip/examples/milp_mps_example.c | 2 +- .../mip/examples/simple_milp_example.c | 2 +- docs/cuopt/source/cuopt-cli/cli-examples.rst | 2 +- .../data_model/data_model.pxd | 6 +- .../internals/internals.pyx | 2 +- .../cuopt/linear_programming/io/parser.pxd | 4 +- .../linear_programming/solver/solver.pxd | 68 +- .../solver/solver_wrapper.pyx | 2 +- .../solver_settings/solver_settings.pxd | 34 +- .../references/python_bindings.md | 10 +- .../references/verification_examples.md | 2 +- .../SKILL.md | 4 +- .../assets/lp_basic/lp_simple.c | 4 +- .../assets/lp_duals/lp_duals.c | 4 +- .../assets/milp_basic/milp_simple.c | 4 +- .../milp_production.c | 4 +- .../assets/mps_solver/mps_solver.c | 4 +- .../evals/evals.json | 2 +- .../references/examples.md | 18 +- 399 files changed, 2205 insertions(+), 2107 deletions(-) rename cpp/include/cuopt/{math_optimization => mathematical_optimization}/backend_selection.hpp (94%) rename cpp/include/cuopt/{math_optimization => mathematical_optimization}/constants.h (100%) rename cpp/include/cuopt/{math_optimization => mathematical_optimization}/cpu_optimization_problem.hpp (98%) rename cpp/include/cuopt/{math_optimization => mathematical_optimization}/cpu_optimization_problem_solution.hpp (96%) rename cpp/include/cuopt/{math_optimization => mathematical_optimization}/cpu_pdlp_warm_start_data.hpp (96%) rename cpp/include/cuopt/{math_optimization => mathematical_optimization}/csr_matrix_utils.hpp (97%) rename cpp/include/cuopt/{math_optimization => mathematical_optimization}/cuopt_c.h (99%) rename cpp/include/cuopt/{math_optimization => mathematical_optimization}/io/data_model_view.hpp (99%) rename cpp/include/cuopt/{math_optimization => mathematical_optimization}/io/mps_data_model.hpp (99%) rename cpp/include/cuopt/{math_optimization => mathematical_optimization}/io/mps_writer.hpp (87%) rename cpp/include/cuopt/{math_optimization => mathematical_optimization}/io/parser.hpp (97%) rename cpp/include/cuopt/{math_optimization => mathematical_optimization}/io/utilities/cython_parser.hpp (62%) rename cpp/include/cuopt/{math_optimization => mathematical_optimization}/io/writer.hpp (79%) rename cpp/include/cuopt/{math_optimization => mathematical_optimization}/mip/diving_hyper_params.hpp (95%) rename cpp/include/cuopt/{math_optimization => mathematical_optimization}/mip/heuristics_hyper_params.hpp (95%) rename cpp/include/cuopt/{math_optimization => mathematical_optimization}/mip/solver_settings.hpp (95%) rename cpp/include/cuopt/{math_optimization => mathematical_optimization}/mip/solver_solution.hpp (92%) rename cpp/include/cuopt/{math_optimization => mathematical_optimization}/mip/solver_stats.hpp (93%) rename cpp/include/cuopt/{math_optimization => mathematical_optimization}/optimization_problem.hpp (98%) rename cpp/include/cuopt/{math_optimization => mathematical_optimization}/optimization_problem_interface.hpp (99%) rename cpp/include/cuopt/{math_optimization => mathematical_optimization}/optimization_problem_solution.hpp (97%) rename cpp/include/cuopt/{math_optimization => mathematical_optimization}/optimization_problem_solution_interface.hpp (96%) rename cpp/include/cuopt/{math_optimization => mathematical_optimization}/optimization_problem_utils.hpp (96%) rename cpp/include/cuopt/{math_optimization => mathematical_optimization}/pdlp/pdlp_hyper_params.cuh (96%) rename cpp/include/cuopt/{math_optimization => mathematical_optimization}/pdlp/pdlp_warm_start_data.hpp (97%) rename cpp/include/cuopt/{math_optimization => mathematical_optimization}/pdlp/solver_settings.hpp (97%) rename cpp/include/cuopt/{math_optimization => mathematical_optimization}/pdlp/solver_solution.hpp (97%) rename cpp/include/cuopt/{math_optimization => mathematical_optimization}/solve.hpp (88%) rename cpp/include/cuopt/{math_optimization => mathematical_optimization}/solve_remote.hpp (88%) rename cpp/include/cuopt/{math_optimization => mathematical_optimization}/solver_settings.hpp (91%) rename cpp/include/cuopt/{math_optimization => mathematical_optimization}/utilities/callbacks_implems.hpp (98%) rename cpp/include/cuopt/{math_optimization => mathematical_optimization}/utilities/cython_solve.hpp (54%) rename cpp/include/cuopt/{math_optimization => mathematical_optimization}/utilities/cython_types.hpp (88%) rename cpp/include/cuopt/{math_optimization => mathematical_optimization}/utilities/internals.hpp (96%) rename cpp/include/cuopt/{math_optimization => mathematical_optimization}/utilities/segmented_sum_handler.cuh (100%) diff --git a/.coderabbit.yaml b/.coderabbit.yaml index 73e1043905..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/math_optimization/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 94d39210c8..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/math_optimization/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/math_optimization/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/math_optimization/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 84b0f57797..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 @@ -58,7 +58,7 @@ void parse_value(std::istringstream& iss, bool& value) } void fill_pdlp_hyper_params(const std::string& pdlp_hyper_params_path, - cuopt::math_optimization::pdlp::pdlp_hyper_params_t& params) + 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; @@ -204,8 +204,9 @@ std::vector read_vector_from_file(const std::string& filename) } template -void write_problem_info(const cuopt::math_optimization::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) { @@ -221,8 +222,9 @@ void write_problem_info(const cuopt::math_optimization::io::mps_data_model_t -void read_problem_info(cuopt::math_optimization::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) { @@ -273,8 +275,8 @@ void mps_file_to_binary(const std::filesystem::path& filename) std::string p = std::string(filename); - cuopt::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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 9bc43a0d1e..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::math_optimization::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 64f88d885e..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::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::presolver_t::Default; + settings.presolver = cuopt::mathematical_optimization::presolver_t::Default; settings.reliability_branching = reliability_branching; settings.clique_cuts = -1; settings.seed = 42; - cuopt::math_optimization::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::math_optimization::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::math_optimization::mip_termination_status_t::FeasibleFound || + cuopt::mathematical_optimization::mip_termination_status_t::FeasibleFound || solution.get_termination_status() == - cuopt::math_optimization::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::math_optimization::mip_termination_status_t::Optimal: + case cuopt::mathematical_optimization::mip_termination_status_t::Optimal: _status_str = "Optimal"; break; - case cuopt::math_optimization::mip_termination_status_t::FeasibleFound: + case cuopt::mathematical_optimization::mip_termination_status_t::FeasibleFound: _status_str = "FeasibleFound"; break; - case cuopt::math_optimization::mip_termination_status_t::TimeLimit: + case cuopt::mathematical_optimization::mip_termination_status_t::TimeLimit: _status_str = "TimeLimit"; break; - case cuopt::math_optimization::mip_termination_status_t::Infeasible: + case cuopt::mathematical_optimization::mip_termination_status_t::Infeasible: _status_str = "Infeasible"; break; default: _status_str = "Other"; break; @@ -280,10 +280,10 @@ int run_single_file(std::string file_path, std::stringstream ss; int decimal_places = 2; double mip_gap = solution.get_mip_gap(); - int is_optimal = - solution.get_termination_status() == cuopt::math_optimization::mip_termination_status_t::Optimal - ? 1 - : 0; + int is_optimal = solution.get_termination_status() == + cuopt::mathematical_optimization::mip_termination_status_t::Optimal + ? 1 + : 0; ss << std::fixed << std::setprecision(decimal_places) << base_filename << "," << sol_found << "," << obj_val << "," << benchmark_info.objective_of_initial_population << "," << benchmark_info.last_improvement_of_best_feasible << "," diff --git a/benchmarks/linear_programming/cuopt/run_pdlp.cu b/benchmarks/linear_programming/cuopt/run_pdlp.cu index 467e7b16fa..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::math_optimization::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::math_optimization::presolver_t::None; - if (presolver == "Papilo") return cuopt::math_optimization::presolver_t::Papilo; - if (presolver == "PSLP") return cuopt::math_optimization::presolver_t::PSLP; - if (presolver == "Default") return cuopt::math_optimization::presolver_t::Default; - return cuopt::math_optimization::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::math_optimization::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::math_optimization::pdlp_precision_t::SinglePrecision; - if (precision == "double") return cuopt::math_optimization::pdlp_precision_t::DoublePrecision; - if (precision == "mixed") return cuopt::math_optimization::pdlp_precision_t::MixedPrecision; - return cuopt::math_optimization::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::math_optimization::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::math_optimization::pdlp_solver_mode_t::Stable1; + if (mode == "Stable1") return cuopt::mathematical_optimization::pdlp_solver_mode_t::Stable1; if (mode == "Stable2") - return cuopt::math_optimization::pdlp_solver_mode_t::Stable2; + return cuopt::mathematical_optimization::pdlp_solver_mode_t::Stable2; else if (mode == "Methodical1") - return cuopt::math_optimization::pdlp_solver_mode_t::Methodical1; + return cuopt::mathematical_optimization::pdlp_solver_mode_t::Methodical1; else if (mode == "Fast1") - return cuopt::math_optimization::pdlp_solver_mode_t::Fast1; + return cuopt::mathematical_optimization::pdlp_solver_mode_t::Fast1; else if (mode == "Stable3") - return cuopt::math_optimization::pdlp_solver_mode_t::Stable3; - return cuopt::math_optimization::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::math_optimization::pdlp_solver_settings_t create_solver_settings( +static cuopt::mathematical_optimization::pdlp_solver_settings_t create_solver_settings( const argparse::ArgumentParser& program) { - cuopt::math_optimization::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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::optimization_problem_solution_t solution = - cuopt::math_optimization::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 aae968a058..325205840b 100755 --- a/ci/test_doc_examples.sh +++ b/ci/test_doc_examples.sh @@ -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 "*/math_optimization/*" 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/math_optimization/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/math_optimization/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 28cc508fb1..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::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::problem_category_t::MIP || + cuopt::mathematical_optimization::problem_category_t::MIP || problem_interface->get_problem_category() == - cuopt::math_optimization::problem_category_t::IP) && + cuopt::mathematical_optimization::problem_category_t::IP) && !solve_relaxation; try { auto initial_solution = initial_solution_file.empty() ? std::vector() - : cuopt::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::get_memory_backend_type(); + auto memory_backend = cuopt::mathematical_optimization::get_memory_backend_type(); std::vector memory_resources; - if (memory_backend == cuopt::math_optimization::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 9e126686f7..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/math_optimization/cuopt_c.h \ - ../include/cuopt/math_optimization/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 b0bd95373a..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/math_optimization/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 083755a59d..9b0e01f6e6 100644 --- a/cpp/include/cuopt/linear_programming/cuopt_c.h +++ b/cpp/include/cuopt/linear_programming/cuopt_c.h @@ -8,20 +8,20 @@ /* * Compatibility forwarder. * - * The cuOpt C API header moved to as part of - * the cuopt::linear_programming -> cuopt::math_optimization rename. The C API + * 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. * * This shim keeps the legacy include path working. Please update includes to - * ; this forwarder may be removed in a future + * ; this forwarder may be removed in a future * release. */ #ifndef CUOPT_LINEAR_PROGRAMMING_C_API_COMPAT_H #define CUOPT_LINEAR_PROGRAMMING_C_API_COMPAT_H #pragma message( \ - " is deprecated; include instead.") + " is deprecated; include instead.") -#include +#include #endif /* CUOPT_LINEAR_PROGRAMMING_C_API_COMPAT_H */ diff --git a/cpp/include/cuopt/math_optimization/backend_selection.hpp b/cpp/include/cuopt/mathematical_optimization/backend_selection.hpp similarity index 94% rename from cpp/include/cuopt/math_optimization/backend_selection.hpp rename to cpp/include/cuopt/mathematical_optimization/backend_selection.hpp index 3c86e906cd..4f684e3756 100644 --- a/cpp/include/cuopt/math_optimization/backend_selection.hpp +++ b/cpp/include/cuopt/mathematical_optimization/backend_selection.hpp @@ -7,7 +7,7 @@ #pragma once -namespace cuopt::math_optimization { +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::math_optimization +} // namespace cuopt::mathematical_optimization diff --git a/cpp/include/cuopt/math_optimization/constants.h b/cpp/include/cuopt/mathematical_optimization/constants.h similarity index 100% rename from cpp/include/cuopt/math_optimization/constants.h rename to cpp/include/cuopt/mathematical_optimization/constants.h diff --git a/cpp/include/cuopt/math_optimization/cpu_optimization_problem.hpp b/cpp/include/cuopt/mathematical_optimization/cpu_optimization_problem.hpp similarity index 98% rename from cpp/include/cuopt/math_optimization/cpu_optimization_problem.hpp rename to cpp/include/cuopt/mathematical_optimization/cpu_optimization_problem.hpp index 9dc38ba5b3..fd4c50fa75 100644 --- a/cpp/include/cuopt/math_optimization/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::math_optimization { +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::math_optimization +} // namespace cuopt::mathematical_optimization diff --git a/cpp/include/cuopt/math_optimization/cpu_optimization_problem_solution.hpp b/cpp/include/cuopt/mathematical_optimization/cpu_optimization_problem_solution.hpp similarity index 96% rename from cpp/include/cuopt/math_optimization/cpu_optimization_problem_solution.hpp rename to cpp/include/cuopt/mathematical_optimization/cpu_optimization_problem_solution.hpp index 45978e7320..b4e5edec44 100644 --- a/cpp/include/cuopt/math_optimization/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::math_optimization { +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::math_optimization +} // namespace cuopt::mathematical_optimization diff --git a/cpp/include/cuopt/math_optimization/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/math_optimization/cpu_pdlp_warm_start_data.hpp rename to cpp/include/cuopt/mathematical_optimization/cpu_pdlp_warm_start_data.hpp index 21f0a5d65f..9cf4740c96 100644 --- a/cpp/include/cuopt/math_optimization/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::math_optimization { +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::math_optimization +} // namespace cuopt::mathematical_optimization diff --git a/cpp/include/cuopt/math_optimization/csr_matrix_utils.hpp b/cpp/include/cuopt/mathematical_optimization/csr_matrix_utils.hpp similarity index 97% rename from cpp/include/cuopt/math_optimization/csr_matrix_utils.hpp rename to cpp/include/cuopt/mathematical_optimization/csr_matrix_utils.hpp index 9b1726d1b7..9615d828dc 100644 --- a/cpp/include/cuopt/math_optimization/csr_matrix_utils.hpp +++ b/cpp/include/cuopt/mathematical_optimization/csr_matrix_utils.hpp @@ -12,7 +12,7 @@ #include #include -namespace cuopt::math_optimization { +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::math_optimization +} // namespace cuopt::mathematical_optimization diff --git a/cpp/include/cuopt/math_optimization/cuopt_c.h b/cpp/include/cuopt/mathematical_optimization/cuopt_c.h similarity index 99% rename from cpp/include/cuopt/math_optimization/cuopt_c.h rename to cpp/include/cuopt/mathematical_optimization/cuopt_c.h index ccc12850f5..4589859aa4 100644 --- a/cpp/include/cuopt/math_optimization/cuopt_c.h +++ b/cpp/include/cuopt/mathematical_optimization/cuopt_c.h @@ -8,7 +8,7 @@ #ifndef CUOPT_C_API_H #define CUOPT_C_API_H -#include +#include #include diff --git a/cpp/include/cuopt/math_optimization/io/data_model_view.hpp b/cpp/include/cuopt/mathematical_optimization/io/data_model_view.hpp similarity index 99% rename from cpp/include/cuopt/math_optimization/io/data_model_view.hpp rename to cpp/include/cuopt/mathematical_optimization/io/data_model_view.hpp index 9784524dbf..d6bed10d51 100644 --- a/cpp/include/cuopt/math_optimization/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::math_optimization::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::math_optimization::io +} // namespace cuopt::mathematical_optimization::io diff --git a/cpp/include/cuopt/math_optimization/io/mps_data_model.hpp b/cpp/include/cuopt/mathematical_optimization/io/mps_data_model.hpp similarity index 99% rename from cpp/include/cuopt/math_optimization/io/mps_data_model.hpp rename to cpp/include/cuopt/mathematical_optimization/io/mps_data_model.hpp index c857ed08b5..9d33e37d58 100644 --- a/cpp/include/cuopt/math_optimization/io/mps_data_model.hpp +++ b/cpp/include/cuopt/mathematical_optimization/io/mps_data_model.hpp @@ -13,7 +13,7 @@ #include #include -namespace cuopt::math_optimization::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::math_optimization::io +} // namespace cuopt::mathematical_optimization::io diff --git a/cpp/include/cuopt/math_optimization/io/mps_writer.hpp b/cpp/include/cuopt/mathematical_optimization/io/mps_writer.hpp similarity index 87% rename from cpp/include/cuopt/math_optimization/io/mps_writer.hpp rename to cpp/include/cuopt/mathematical_optimization/io/mps_writer.hpp index f75f8fd4a0..6184ce56b6 100644 --- a/cpp/include/cuopt/math_optimization/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::math_optimization::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::math_optimization::io +} // namespace cuopt::mathematical_optimization::io diff --git a/cpp/include/cuopt/math_optimization/io/parser.hpp b/cpp/include/cuopt/mathematical_optimization/io/parser.hpp similarity index 97% rename from cpp/include/cuopt/math_optimization/io/parser.hpp rename to cpp/include/cuopt/mathematical_optimization/io/parser.hpp index dfe7a6445c..bbdaa1a819 100644 --- a/cpp/include/cuopt/math_optimization/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::math_optimization::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::math_optimization::io +} // namespace cuopt::mathematical_optimization::io diff --git a/cpp/include/cuopt/math_optimization/io/utilities/cython_parser.hpp b/cpp/include/cuopt/mathematical_optimization/io/utilities/cython_parser.hpp similarity index 62% rename from cpp/include/cuopt/math_optimization/io/utilities/cython_parser.hpp rename to cpp/include/cuopt/mathematical_optimization/io/utilities/cython_parser.hpp index a195e0c426..a7863199df 100644 --- a/cpp/include/cuopt/math_optimization/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/math_optimization/io/writer.hpp b/cpp/include/cuopt/mathematical_optimization/io/writer.hpp similarity index 79% rename from cpp/include/cuopt/math_optimization/io/writer.hpp rename to cpp/include/cuopt/mathematical_optimization/io/writer.hpp index dfdb288085..032865220e 100644 --- a/cpp/include/cuopt/math_optimization/io/writer.hpp +++ b/cpp/include/cuopt/mathematical_optimization/io/writer.hpp @@ -7,9 +7,9 @@ #pragma once -#include +#include -namespace cuopt::math_optimization::io { +namespace cuopt::mathematical_optimization::io { /** * @brief Writes the problem to an MPS formatted file @@ -23,4 +23,4 @@ namespace cuopt::math_optimization::io { template void write_mps(const data_model_view_t& problem, const std::string& mps_file_path); -} // namespace cuopt::math_optimization::io +} // namespace cuopt::mathematical_optimization::io diff --git a/cpp/include/cuopt/math_optimization/mip/diving_hyper_params.hpp b/cpp/include/cuopt/mathematical_optimization/mip/diving_hyper_params.hpp similarity index 95% rename from cpp/include/cuopt/math_optimization/mip/diving_hyper_params.hpp rename to cpp/include/cuopt/mathematical_optimization/mip/diving_hyper_params.hpp index 0dd20d49bc..ec08fe48dd 100644 --- a/cpp/include/cuopt/math_optimization/mip/diving_hyper_params.hpp +++ b/cpp/include/cuopt/mathematical_optimization/mip/diving_hyper_params.hpp @@ -7,7 +7,7 @@ #pragma once -namespace cuopt::math_optimization { +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::math_optimization +} // namespace cuopt::mathematical_optimization diff --git a/cpp/include/cuopt/math_optimization/mip/heuristics_hyper_params.hpp b/cpp/include/cuopt/mathematical_optimization/mip/heuristics_hyper_params.hpp similarity index 95% rename from cpp/include/cuopt/math_optimization/mip/heuristics_hyper_params.hpp rename to cpp/include/cuopt/mathematical_optimization/mip/heuristics_hyper_params.hpp index 582b4b5ba6..e3fd891e83 100644 --- a/cpp/include/cuopt/math_optimization/mip/heuristics_hyper_params.hpp +++ b/cpp/include/cuopt/mathematical_optimization/mip/heuristics_hyper_params.hpp @@ -7,7 +7,7 @@ #pragma once -namespace cuopt::math_optimization { +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::math_optimization +} // namespace cuopt::mathematical_optimization diff --git a/cpp/include/cuopt/math_optimization/mip/solver_settings.hpp b/cpp/include/cuopt/mathematical_optimization/mip/solver_settings.hpp similarity index 95% rename from cpp/include/cuopt/math_optimization/mip/solver_settings.hpp rename to cpp/include/cuopt/mathematical_optimization/mip/solver_settings.hpp index 0909c8eb75..ba4dce20dc 100644 --- a/cpp/include/cuopt/math_optimization/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::math_optimization { +namespace cuopt::mathematical_optimization { struct benchmark_info_t { double last_improvement_of_best_feasible = 0; @@ -229,4 +229,4 @@ struct mip_solver_settings_accessor { } }; -} // namespace cuopt::math_optimization +} // namespace cuopt::mathematical_optimization diff --git a/cpp/include/cuopt/math_optimization/mip/solver_solution.hpp b/cpp/include/cuopt/mathematical_optimization/mip/solver_solution.hpp similarity index 92% rename from cpp/include/cuopt/math_optimization/mip/solver_solution.hpp rename to cpp/include/cuopt/mathematical_optimization/mip/solver_solution.hpp index c5cc9b72c5..19a8e5e531 100644 --- a/cpp/include/cuopt/math_optimization/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::math_optimization { +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::math_optimization +} // namespace cuopt::mathematical_optimization diff --git a/cpp/include/cuopt/math_optimization/mip/solver_stats.hpp b/cpp/include/cuopt/mathematical_optimization/mip/solver_stats.hpp similarity index 93% rename from cpp/include/cuopt/math_optimization/mip/solver_stats.hpp rename to cpp/include/cuopt/mathematical_optimization/mip/solver_stats.hpp index b29b9efafe..3434c1a420 100644 --- a/cpp/include/cuopt/math_optimization/mip/solver_stats.hpp +++ b/cpp/include/cuopt/mathematical_optimization/mip/solver_stats.hpp @@ -8,7 +8,7 @@ #include #include -namespace cuopt::math_optimization { +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::math_optimization +} // namespace cuopt::mathematical_optimization diff --git a/cpp/include/cuopt/math_optimization/optimization_problem.hpp b/cpp/include/cuopt/mathematical_optimization/optimization_problem.hpp similarity index 98% rename from cpp/include/cuopt/math_optimization/optimization_problem.hpp rename to cpp/include/cuopt/mathematical_optimization/optimization_problem.hpp index a7f39bc4b3..5c755281ca 100644 --- a/cpp/include/cuopt/math_optimization/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::math_optimization { +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::math_optimization +} // namespace cuopt::mathematical_optimization diff --git a/cpp/include/cuopt/math_optimization/optimization_problem_interface.hpp b/cpp/include/cuopt/mathematical_optimization/optimization_problem_interface.hpp similarity index 99% rename from cpp/include/cuopt/math_optimization/optimization_problem_interface.hpp rename to cpp/include/cuopt/mathematical_optimization/optimization_problem_interface.hpp index 43b008c62f..c1ac8c1869 100644 --- a/cpp/include/cuopt/math_optimization/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::math_optimization { +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::math_optimization +} // namespace cuopt::mathematical_optimization diff --git a/cpp/include/cuopt/math_optimization/optimization_problem_solution.hpp b/cpp/include/cuopt/mathematical_optimization/optimization_problem_solution.hpp similarity index 97% rename from cpp/include/cuopt/math_optimization/optimization_problem_solution.hpp rename to cpp/include/cuopt/mathematical_optimization/optimization_problem_solution.hpp index 5929421296..822bd54de3 100644 --- a/cpp/include/cuopt/math_optimization/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::math_optimization { +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::math_optimization +} // namespace cuopt::mathematical_optimization diff --git a/cpp/include/cuopt/math_optimization/optimization_problem_solution_interface.hpp b/cpp/include/cuopt/mathematical_optimization/optimization_problem_solution_interface.hpp similarity index 96% rename from cpp/include/cuopt/math_optimization/optimization_problem_solution_interface.hpp rename to cpp/include/cuopt/mathematical_optimization/optimization_problem_solution_interface.hpp index 77b6b07bfd..e30474538d 100644 --- a/cpp/include/cuopt/math_optimization/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::math_optimization { +namespace cuopt::mathematical_optimization { // Forward declarations template @@ -486,4 +486,4 @@ class gpu_mip_solution_t; template class cpu_mip_solution_t; -} // namespace cuopt::math_optimization +} // namespace cuopt::mathematical_optimization diff --git a/cpp/include/cuopt/math_optimization/optimization_problem_utils.hpp b/cpp/include/cuopt/mathematical_optimization/optimization_problem_utils.hpp similarity index 96% rename from cpp/include/cuopt/math_optimization/optimization_problem_utils.hpp rename to cpp/include/cuopt/mathematical_optimization/optimization_problem_utils.hpp index ba04d56ed9..8e2f565337 100644 --- a/cpp/include/cuopt/math_optimization/optimization_problem_utils.hpp +++ b/cpp/include/cuopt/mathematical_optimization/optimization_problem_utils.hpp @@ -8,13 +8,13 @@ #pragma once #include -#include -#include -#include -#include -#include +#include +#include +#include +#include +#include -namespace cuopt::math_optimization { +namespace cuopt::mathematical_optimization { inline constexpr bool is_valid_public_var_type_code(char variable_type) { @@ -152,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::math_optimization::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) { @@ -296,4 +296,4 @@ void populate_from_data_model_view( } } -} // namespace cuopt::math_optimization +} // namespace cuopt::mathematical_optimization diff --git a/cpp/include/cuopt/math_optimization/pdlp/pdlp_hyper_params.cuh b/cpp/include/cuopt/mathematical_optimization/pdlp/pdlp_hyper_params.cuh similarity index 96% rename from cpp/include/cuopt/math_optimization/pdlp/pdlp_hyper_params.cuh rename to cpp/include/cuopt/mathematical_optimization/pdlp/pdlp_hyper_params.cuh index 322a69a1bd..6aee5213a7 100644 --- a/cpp/include/cuopt/math_optimization/pdlp/pdlp_hyper_params.cuh +++ b/cpp/include/cuopt/mathematical_optimization/pdlp/pdlp_hyper_params.cuh @@ -7,7 +7,7 @@ #pragma once -namespace cuopt::math_optimization::pdlp { +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::math_optimization::pdlp +} // namespace cuopt::mathematical_optimization::pdlp diff --git a/cpp/include/cuopt/math_optimization/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/math_optimization/pdlp/pdlp_warm_start_data.hpp rename to cpp/include/cuopt/mathematical_optimization/pdlp/pdlp_warm_start_data.hpp index 75603544bb..07f54672f2 100644 --- a/cpp/include/cuopt/math_optimization/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::math_optimization { +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::math_optimization +} // namespace cuopt::mathematical_optimization diff --git a/cpp/include/cuopt/math_optimization/pdlp/solver_settings.hpp b/cpp/include/cuopt/mathematical_optimization/pdlp/solver_settings.hpp similarity index 97% rename from cpp/include/cuopt/math_optimization/pdlp/solver_settings.hpp rename to cpp/include/cuopt/mathematical_optimization/pdlp/solver_settings.hpp index ca00b17393..96f548ec32 100644 --- a/cpp/include/cuopt/math_optimization/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::math_optimization { +namespace cuopt::mathematical_optimization { // Forward declare solver_settings_t for friend class template @@ -351,4 +351,4 @@ class pdlp_solver_settings_t { friend class solver_settings_t; }; -} // namespace cuopt::math_optimization +} // namespace cuopt::mathematical_optimization diff --git a/cpp/include/cuopt/math_optimization/pdlp/solver_solution.hpp b/cpp/include/cuopt/mathematical_optimization/pdlp/solver_solution.hpp similarity index 97% rename from cpp/include/cuopt/math_optimization/pdlp/solver_solution.hpp rename to cpp/include/cuopt/mathematical_optimization/pdlp/solver_solution.hpp index 5140f0e1cd..5bacff1101 100644 --- a/cpp/include/cuopt/math_optimization/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::math_optimization { +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::math_optimization +} // namespace cuopt::mathematical_optimization diff --git a/cpp/include/cuopt/math_optimization/solve.hpp b/cpp/include/cuopt/mathematical_optimization/solve.hpp similarity index 88% rename from cpp/include/cuopt/math_optimization/solve.hpp rename to cpp/include/cuopt/mathematical_optimization/solve.hpp index 4ee90feb2e..961fcd29b6 100644 --- a/cpp/include/cuopt/math_optimization/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::math_optimization { +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::math_optimization::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); @@ -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::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization +} // namespace cuopt::mathematical_optimization diff --git a/cpp/include/cuopt/math_optimization/solve_remote.hpp b/cpp/include/cuopt/mathematical_optimization/solve_remote.hpp similarity index 88% rename from cpp/include/cuopt/math_optimization/solve_remote.hpp rename to cpp/include/cuopt/mathematical_optimization/solve_remote.hpp index 109e2d14df..3636195660 100644 --- a/cpp/include/cuopt/math_optimization/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::math_optimization { +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::math_optimization +} // namespace cuopt::mathematical_optimization diff --git a/cpp/include/cuopt/math_optimization/solver_settings.hpp b/cpp/include/cuopt/mathematical_optimization/solver_settings.hpp similarity index 91% rename from cpp/include/cuopt/math_optimization/solver_settings.hpp rename to cpp/include/cuopt/mathematical_optimization/solver_settings.hpp index 1d3972567f..df373b209d 100644 --- a/cpp/include/cuopt/math_optimization/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::math_optimization { +namespace cuopt::mathematical_optimization { template class solver_settings_t { @@ -109,4 +109,4 @@ class solver_settings_t { std::vector> string_parameters; }; -} // namespace cuopt::math_optimization +} // namespace cuopt::mathematical_optimization diff --git a/cpp/include/cuopt/math_optimization/utilities/callbacks_implems.hpp b/cpp/include/cuopt/mathematical_optimization/utilities/callbacks_implems.hpp similarity index 98% rename from cpp/include/cuopt/math_optimization/utilities/callbacks_implems.hpp rename to cpp/include/cuopt/mathematical_optimization/utilities/callbacks_implems.hpp index 5c5892e853..69abbb46a3 100644 --- a/cpp/include/cuopt/math_optimization/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/math_optimization/utilities/cython_solve.hpp b/cpp/include/cuopt/mathematical_optimization/utilities/cython_solve.hpp similarity index 54% rename from cpp/include/cuopt/math_optimization/utilities/cython_solve.hpp rename to cpp/include/cuopt/mathematical_optimization/utilities/cython_solve.hpp index 24c4b5c699..79ef572d9c 100644 --- a/cpp/include/cuopt/math_optimization/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 { - math_optimization::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. -math_optimization::lp_solution_interface_t* call_solve_lp( - math_optimization::optimization_problem_interface_t* problem_interface, - math_optimization::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 -math_optimization::mip_solution_interface_t* call_solve_mip( - math_optimization::optimization_problem_interface_t* problem_interface, - math_optimization::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::math_optimization::io::data_model_view_t*, - math_optimization::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*>, - math_optimization::solver_settings_t*); + std::vector*>, + mathematical_optimization::solver_settings_t*); std::pair>, double> call_batch_solve( - std::vector*>, - math_optimization::solver_settings_t*); + std::vector*>, + mathematical_optimization::solver_settings_t*); } // namespace cython } // namespace cuopt diff --git a/cpp/include/cuopt/math_optimization/utilities/cython_types.hpp b/cpp/include/cuopt/mathematical_optimization/utilities/cython_types.hpp similarity index 88% rename from cpp/include/cuopt/math_optimization/utilities/cython_types.hpp rename to cpp/include/cuopt/mathematical_optimization/utilities/cython_types.hpp index f9f071bac2..966018bd9f 100644 --- a/cpp/include/cuopt/math_optimization/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 -- */ - math_optimization::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_{}; - math_optimization::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_; - math_optimization::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/math_optimization/utilities/internals.hpp b/cpp/include/cuopt/mathematical_optimization/utilities/internals.hpp similarity index 96% rename from cpp/include/cuopt/math_optimization/utilities/internals.hpp rename to cpp/include/cuopt/mathematical_optimization/utilities/internals.hpp index b22bfca868..aaec8ef842 100644 --- a/cpp/include/cuopt/math_optimization/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 math_optimization { +namespace mathematical_optimization { class base_solution_t { public: @@ -142,5 +142,5 @@ enum presolver_t : int { PSLP = CUOPT_PRESOLVE_PSLP }; -} // namespace math_optimization +} // namespace mathematical_optimization } // namespace cuopt diff --git a/cpp/include/cuopt/math_optimization/utilities/segmented_sum_handler.cuh b/cpp/include/cuopt/mathematical_optimization/utilities/segmented_sum_handler.cuh similarity index 100% rename from cpp/include/cuopt/math_optimization/utilities/segmented_sum_handler.cuh rename to cpp/include/cuopt/mathematical_optimization/utilities/segmented_sum_handler.cuh diff --git a/cpp/src/barrier/barrier.cu b/cpp/src/barrier/barrier.cu index faf0097a25..ecc4300a09 100644 --- a/cpp/src/barrier/barrier.cu +++ b/cpp/src/barrier/barrier.cu @@ -50,10 +50,10 @@ #include #include -namespace cuopt::math_optimization::barrier { +namespace cuopt::mathematical_optimization::barrier { -using namespace cuopt::math_optimization::simplex; // shared simplex types (lp_problem_t, inf, - // etc.) +using namespace cuopt::mathematical_optimization::simplex; // shared simplex types (lp_problem_t, + // inf, etc.) template bool validate_barrier_cone_layout(const lp_problem_t& problem, @@ -4455,4 +4455,4 @@ template class sparse_cholesky_cudss_t; template class iteration_data_t; #endif -} // namespace cuopt::math_optimization::barrier +} // namespace cuopt::mathematical_optimization::barrier diff --git a/cpp/src/barrier/barrier.hpp b/cpp/src/barrier/barrier.hpp index a0caaef12b..bdf3ba3f83 100644 --- a/cpp/src/barrier/barrier.hpp +++ b/cpp/src/barrier/barrier.hpp @@ -16,7 +16,7 @@ #include #include -namespace cuopt::math_optimization::barrier { +namespace cuopt::mathematical_optimization::barrier { /** Validates SOC layout on an simplex::lp_problem_t before barrier presolve/solve. */ template @@ -116,4 +116,4 @@ class barrier_solver_t { rmm::cuda_stream_view stream_view_; }; -} // namespace cuopt::math_optimization::barrier +} // namespace cuopt::mathematical_optimization::barrier diff --git a/cpp/src/barrier/conjugate_gradient.hpp b/cpp/src/barrier/conjugate_gradient.hpp index ff85140bf1..21fe33ba3d 100644 --- a/cpp/src/barrier/conjugate_gradient.hpp +++ b/cpp/src/barrier/conjugate_gradient.hpp @@ -16,7 +16,7 @@ #include #include -namespace cuopt::math_optimization::barrier { +namespace cuopt::mathematical_optimization::barrier { template i_t preconditioned_conjugate_gradient(const T& op, @@ -120,4 +120,4 @@ i_t preconditioned_conjugate_gradient(const T& op, return iter; } -} // namespace cuopt::math_optimization::barrier +} // namespace cuopt::mathematical_optimization::barrier diff --git a/cpp/src/barrier/cusparse_info.hpp b/cpp/src/barrier/cusparse_info.hpp index 109dc2e3b8..d88522e79a 100644 --- a/cpp/src/barrier/cusparse_info.hpp +++ b/cpp/src/barrier/cusparse_info.hpp @@ -17,7 +17,7 @@ #include -namespace cuopt::math_optimization::barrier { +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::math_optimization::barrier +} // namespace cuopt::mathematical_optimization::barrier diff --git a/cpp/src/barrier/cusparse_view.cu b/cpp/src/barrier/cusparse_view.cu index a69a014931..fb71747034 100644 --- a/cpp/src/barrier/cusparse_view.cu +++ b/cpp/src/barrier/cusparse_view.cu @@ -22,10 +22,10 @@ #include -namespace cuopt::math_optimization::barrier { +namespace cuopt::mathematical_optimization::barrier { -using namespace cuopt::math_optimization::simplex; // shared simplex types (lp_problem_t, inf, - // etc.) +using namespace cuopt::mathematical_optimization::simplex; // shared simplex types (lp_problem_t, + // inf, etc.) #define CUDA_VER_12_4_UP (CUDART_VERSION >= 12040) @@ -426,4 +426,4 @@ cusparse_view_t::transpose_spmv, std::alloca double beta, std::vector>& y); -} // namespace cuopt::math_optimization::barrier +} // namespace cuopt::mathematical_optimization::barrier diff --git a/cpp/src/barrier/cusparse_view.hpp b/cpp/src/barrier/cusparse_view.hpp index f302173727..6af4813bc2 100644 --- a/cpp/src/barrier/cusparse_view.hpp +++ b/cpp/src/barrier/cusparse_view.hpp @@ -21,7 +21,7 @@ // 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::math_optimization::barrier { +namespace cuopt::mathematical_optimization::barrier { template class cusparse_view_t { @@ -73,4 +73,4 @@ class cusparse_view_t { rmm::device_scalar d_minus_one_; rmm::device_scalar d_zero_; }; -} // namespace cuopt::math_optimization::barrier +} // namespace cuopt::mathematical_optimization::barrier diff --git a/cpp/src/barrier/dense_matrix.hpp b/cpp/src/barrier/dense_matrix.hpp index 58dffbfbfe..260c4a2957 100644 --- a/cpp/src/barrier/dense_matrix.hpp +++ b/cpp/src/barrier/dense_matrix.hpp @@ -12,7 +12,7 @@ #pragma once -namespace cuopt::math_optimization::barrier { +namespace cuopt::mathematical_optimization::barrier { template class dense_matrix_t { @@ -242,4 +242,4 @@ class dense_matrix_t { std::vector values; }; -} // namespace cuopt::math_optimization::barrier +} // namespace cuopt::mathematical_optimization::barrier diff --git a/cpp/src/barrier/dense_vector.hpp b/cpp/src/barrier/dense_vector.hpp index a31ded0551..c444bbc8f0 100644 --- a/cpp/src/barrier/dense_vector.hpp +++ b/cpp/src/barrier/dense_vector.hpp @@ -12,7 +12,7 @@ #include #include -namespace cuopt::math_optimization::barrier { +namespace cuopt::mathematical_optimization::barrier { template > class dense_vector_t : public std::vector { @@ -246,4 +246,4 @@ std::vector copy(const std::vector& src) return std::vector(src.begin(), src.end()); } -} // namespace cuopt::math_optimization::barrier +} // namespace cuopt::mathematical_optimization::barrier diff --git a/cpp/src/barrier/device_sparse_matrix.cu b/cpp/src/barrier/device_sparse_matrix.cu index bae20e58b9..8016b3466f 100644 --- a/cpp/src/barrier/device_sparse_matrix.cu +++ b/cpp/src/barrier/device_sparse_matrix.cu @@ -15,9 +15,9 @@ // 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::math_optimization::simplex { +namespace cuopt::mathematical_optimization::simplex { -using cuopt::math_optimization::barrier::PinnedHostAllocator; +using cuopt::mathematical_optimization::barrier::PinnedHostAllocator; template template @@ -72,4 +72,4 @@ template void csc_matrix_t::scale_columns #include -namespace cuopt::math_optimization::barrier { +namespace cuopt::mathematical_optimization::barrier { template class device_csr_matrix_t; @@ -388,4 +388,4 @@ void device_csc_matrix_t::to_compressed_row(device_csr_matrix_t #include -namespace cuopt::math_optimization::barrier { +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::math_optimization::barrier +} // namespace cuopt::mathematical_optimization::barrier diff --git a/cpp/src/barrier/pinned_host_allocator.cu b/cpp/src/barrier/pinned_host_allocator.cu index 4f9a7f2393..a74b5c525d 100644 --- a/cpp/src/barrier/pinned_host_allocator.cu +++ b/cpp/src/barrier/pinned_host_allocator.cu @@ -10,10 +10,10 @@ #include #include -namespace cuopt::math_optimization::barrier { +namespace cuopt::mathematical_optimization::barrier { -using namespace cuopt::math_optimization::simplex; // shared simplex types (lp_problem_t, inf, - // etc.) +using namespace cuopt::mathematical_optimization::simplex; // shared simplex types (lp_problem_t, + // inf, etc.) template struct PinnedHostAllocator { @@ -56,16 +56,19 @@ template bool operator!=(const PinnedHostAllocator&, #endif template class PinnedHostAllocator; -} // namespace cuopt::math_optimization::barrier +} // namespace cuopt::mathematical_optimization::barrier -namespace cuopt::math_optimization::simplex { +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); +vector_norm_inf>( + const std::vector>& + x); #endif -} // namespace cuopt::math_optimization::simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/barrier/pinned_host_allocator.hpp b/cpp/src/barrier/pinned_host_allocator.hpp index d62fabe1f0..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::math_optimization::barrier { +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::math_optimization::barrier +} // 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 a9f037a5e0..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::math_optimization::barrier { +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::math_optimization::barrier +} // 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 328e3fd9c8..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::math_optimization::barrier { +namespace cuopt::mathematical_optimization::barrier { template class sparse_cholesky_base_t { @@ -894,4 +894,4 @@ class sparse_cholesky_cudss_t : public sparse_cholesky_base_t { void* cuGetErrorString_func; }; -} // namespace cuopt::math_optimization::barrier +} // namespace cuopt::mathematical_optimization::barrier diff --git a/cpp/src/barrier/sparse_matrix_kernels.cuh b/cpp/src/barrier/sparse_matrix_kernels.cuh index 5825ebd42b..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::math_optimization::barrier { +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::math_optimization::barrier +} // namespace cuopt::mathematical_optimization::barrier diff --git a/cpp/src/barrier/translate_soc.hpp b/cpp/src/barrier/translate_soc.hpp index 117a963df5..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::math_optimization::barrier { +namespace cuopt::mathematical_optimization::barrier { /** Convert MPS >= ('G') quadratic row to <= ('L') form on a working copy for SOC conversion. */ template @@ -818,8 +818,8 @@ void convert_quadratic_constraints_to_second_order_cones( user_problem.objective.resize(n_aug, 0); user_problem.lower.resize(n_aug, -inf); user_problem.upper.resize(n_aug, inf); - user_problem.var_types.resize(n_aug, - cuopt::math_optimization::simplex::variable_type_t::CONTINUOUS); + user_problem.var_types.resize( + 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) { @@ -890,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::math_optimization::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::math_optimization::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::math_optimization::simplex::variable_type_t::CONTINUOUS, + cuopt::mathematical_optimization::simplex::variable_type_t::CONTINUOUS, error_type_t::ValidationError, "Rotated SOC tail variables must be continuous"); } @@ -922,8 +922,8 @@ void convert_quadratic_constraints_to_second_order_cones( user_problem.objective.resize(n_prob, 0); user_problem.lower.resize(n_prob, -inf); user_problem.upper.resize(n_prob, inf); - user_problem.var_types.resize(n_prob, - cuopt::math_optimization::simplex::variable_type_t::CONTINUOUS); + user_problem.var_types.resize( + 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) { @@ -1063,8 +1063,8 @@ void convert_quadratic_constraints_to_second_order_cones( user_problem.objective.resize(n_new, 0); 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::math_optimization::simplex::variable_type_t::CONTINUOUS); + user_problem.var_types.resize( + 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) { @@ -1150,8 +1150,8 @@ void convert_quadratic_constraints_to_second_order_cones( user_problem.objective.resize(n_new, 0); user_problem.lower.resize(n_new, neg_inf); user_problem.upper.resize(n_new, pos_inf); - user_problem.var_types.resize(n_new, - cuopt::math_optimization::simplex::variable_type_t::CONTINUOUS); + user_problem.var_types.resize( + 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) { @@ -1350,4 +1350,4 @@ void project_barrier_solution_to_model_variables( solution.z = std::move(model_z); } -} // namespace cuopt::math_optimization::barrier +} // 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 c9d5b65ffa..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::math_optimization::mip { +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::math_optimization::mip +} // 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 f2583a75ba..3f3d332186 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,10 +44,10 @@ #include #include -namespace cuopt::math_optimization::mip { +namespace cuopt::mathematical_optimization::mip { -using namespace cuopt::math_optimization::simplex; // shared simplex types (lp_problem_t, - // etc.) +using namespace cuopt::mathematical_optimization::simplex; // shared simplex types (lp_problem_t, + // etc.) namespace { template @@ -4191,4 +4191,4 @@ template class branch_and_bound_t; #endif -} // namespace cuopt::math_optimization::mip +} // 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 0e79d0311b..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::math_optimization::mip { +namespace cuopt::mathematical_optimization::mip { template struct clique_table_t; } -namespace cuopt::math_optimization::mip { +namespace cuopt::mathematical_optimization::mip { template struct mip_symmetry_t; @@ -475,4 +475,4 @@ class branch_and_bound_t { heap_t diving_heap_; }; -} // namespace cuopt::math_optimization::mip +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/branch_and_bound/constants.hpp b/cpp/src/branch_and_bound/constants.hpp index b91968dd85..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::math_optimization::mip { +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::math_optimization::mip +} // 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 2698e8b8a4..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::math_optimization::mip { +namespace cuopt::mathematical_optimization::mip { template struct backlog_node_compare_t { @@ -457,4 +457,4 @@ class deterministic_diving_worker_pool_t } }; -} // namespace cuopt::math_optimization::mip +} // 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 6b77396983..cdd1241a13 100644 --- a/cpp/src/branch_and_bound/diving_heuristics.cpp +++ b/cpp/src/branch_and_bound/diving_heuristics.cpp @@ -7,10 +7,10 @@ #include -namespace cuopt::math_optimization::mip { +namespace cuopt::mathematical_optimization::mip { -using namespace cuopt::math_optimization::simplex; // shared simplex types (lp_problem_t, - // etc.) +using namespace cuopt::mathematical_optimization::simplex; // shared simplex types (lp_problem_t, + // etc.) template branch_variable_t line_search_diving(const std::vector& fractional, @@ -410,4 +410,4 @@ template branch_variable_t vector_length_diving(const lp_problem_t +#include #include @@ -16,7 +16,7 @@ #include -namespace cuopt::math_optimization::mip { +namespace cuopt::mathematical_optimization::mip { // When `log_diving_type` is true, each diving strategy gets its own letter; // otherwise every dive collapses to 'D'. @@ -100,4 +100,4 @@ branch_variable_t vector_length_diving(const simplex::lp_problem_t& solution, simplex::logger_t& log); -} // namespace cuopt::math_optimization::mip +} // 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 dfb52ad1e3..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::math_optimization::mip { +namespace cuopt::mathematical_optimization::mip { enum class node_status_t : int { PENDING = 0, // Node is still in the tree, waiting to be solved @@ -459,4 +459,4 @@ class search_tree_t { static constexpr bool write_graphviz = false; }; -} // namespace cuopt::math_optimization::mip +} // 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 672c7c60f9..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::math_optimization::mip { +namespace cuopt::mathematical_optimization::mip { // This is a generic heap implementation based // on the STL functions. The main benefit here is @@ -209,4 +209,4 @@ class node_queue_t { omp_atomic_t lower_bound_{std::numeric_limits::infinity()}; }; -} // namespace cuopt::math_optimization::mip +} // 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 4f8b37c16f..da35a1392c 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,10 +25,10 @@ #include -namespace cuopt::math_optimization::mip { +namespace cuopt::mathematical_optimization::mip { -using namespace cuopt::math_optimization::simplex; // shared simplex types (lp_problem_t, - // etc.) +using namespace cuopt::mathematical_optimization::simplex; // shared simplex types (lp_problem_t, + // etc.) namespace { static bool is_dual_simplex_done(dual_status_t status) @@ -533,11 +533,11 @@ std::pair trial_branching(const lp_problem_t& orig } // namespace template -static cuopt::math_optimization::io::mps_data_model_t simplex_problem_to_mps_data_model( - const 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 simplex::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 @@ -552,7 +552,7 @@ static cuopt::math_optimization::io::mps_data_model_t simplex_problem_ // subject to lb <= A*x <= ub // l <= x <= u - cuopt::math_optimization::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); @@ -1996,4 +1996,4 @@ template void strong_branching(const lp_problem_t& ori #endif -} // namespace cuopt::math_optimization::mip +} // 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 553ce8a198..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::math_optimization::mip { +namespace cuopt::mathematical_optimization::mip { template struct mip_symmetry_t; @@ -291,4 +291,4 @@ void strong_branching(const simplex::lp_problem_t& original_lp, mip_symmetry_t* symmetry, pseudo_costs_t& pc); -} // namespace cuopt::math_optimization::mip +} // 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 0c786358bc..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::math_optimization::mip { +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::math_optimization::mip +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/branch_and_bound/symmetry.hpp b/cpp/src/branch_and_bound/symmetry.hpp index faba88868a..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::math_optimization::mip { +namespace cuopt::mathematical_optimization::mip { // permutation_t stores a dense permutation plus its support (non-identity entries). template @@ -1138,4 +1138,4 @@ std::unique_ptr> detect_symmetry( return result; } -} // namespace cuopt::math_optimization::mip +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/branch_and_bound/worker.hpp b/cpp/src/branch_and_bound/worker.hpp index 28f58e1a45..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::math_optimization::mip { +namespace cuopt::mathematical_optimization::mip { template struct branch_and_bound_stats_t { @@ -256,4 +256,4 @@ class diving_worker_t : public branch_and_bound_worker_t { bfs_worker_t* bfs_worker{nullptr}; }; -} // namespace cuopt::math_optimization::mip +} // 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 c2867568fb..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::math_optimization::mip { +namespace cuopt::mathematical_optimization::mip { template class worker_pool_t { @@ -106,4 +106,4 @@ using bfs_worker_pool_t = worker_pool_t>; template using diving_worker_pool_t = worker_pool_t>; -} // namespace cuopt::math_optimization::mip +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/cuts/cuts.cpp b/cpp/src/cuts/cuts.cpp index a90f435c5c..aa0379605a 100644 --- a/cpp/src/cuts/cuts.cpp +++ b/cpp/src/cuts/cuts.cpp @@ -27,10 +27,10 @@ #include #include -namespace cuopt::math_optimization::mip { +namespace cuopt::mathematical_optimization::mip { -using namespace cuopt::math_optimization::simplex; // shared simplex types (lp_problem_t, - // etc.) +using namespace cuopt::mathematical_optimization::simplex; // shared simplex types (lp_problem_t, + // etc.) namespace { @@ -5602,4 +5602,4 @@ template void verify_cuts_against_saved_solution( const std::vector& saved_solution); #endif -} // namespace cuopt::math_optimization::mip +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/cuts/cuts.hpp b/cpp/src/cuts/cuts.hpp index eedef2aea7..e8dfba4ccd 100644 --- a/cpp/src/cuts/cuts.hpp +++ b/cpp/src/cuts/cuts.hpp @@ -27,12 +27,12 @@ #include #include -namespace cuopt::math_optimization::mip { +namespace cuopt::mathematical_optimization::mip { template struct clique_table_t; } -namespace cuopt::math_optimization::mip { +namespace cuopt::mathematical_optimization::mip { enum cut_type_t : int8_t { MIXED_INTEGER_GOMORY = 0, @@ -1077,4 +1077,4 @@ i_t remove_cuts(simplex::lp_problem_t& lp, std::vector& nonbasic_list, simplex::basis_update_mpf_t& basis_update); -} // namespace cuopt::math_optimization::mip +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/cuts/objective_step.cpp b/cpp/src/cuts/objective_step.cpp index d55a77cafa..7b579ea7a7 100644 --- a/cpp/src/cuts/objective_step.cpp +++ b/cpp/src/cuts/objective_step.cpp @@ -14,10 +14,10 @@ #include #include -namespace cuopt::math_optimization::mip { +namespace cuopt::mathematical_optimization::mip { -using namespace cuopt::math_optimization::simplex; // shared simplex types (objective_step_t, - // etc.) +using namespace cuopt::mathematical_optimization::simplex; // shared simplex types + // (objective_step_t, etc.) namespace { @@ -411,4 +411,4 @@ template objective_step_t compute_objective_step_info(const s const std::vector&, const std::vector&); -} // namespace cuopt::math_optimization::mip +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/cuts/objective_step.hpp b/cpp/src/cuts/objective_step.hpp index 17e59d19b8..180be642a4 100644 --- a/cpp/src/cuts/objective_step.hpp +++ b/cpp/src/cuts/objective_step.hpp @@ -12,7 +12,7 @@ #include #include -namespace cuopt::math_optimization::mip { +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 @@ -52,4 +52,4 @@ bool propagate_lattice(i_t n_vars, const std::vector& obj_coefs, std::vector& lattice_step); -} // namespace cuopt::math_optimization::mip +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/cuts/rational.hpp b/cpp/src/cuts/rational.hpp index 1d83276af8..014546ff3e 100644 --- a/cpp/src/cuts/rational.hpp +++ b/cpp/src/cuts/rational.hpp @@ -13,7 +13,7 @@ #include #include -namespace cuopt::math_optimization::mip { +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::math_optimization::mip +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/dual_simplex/basis_solves.cpp b/cpp/src/dual_simplex/basis_solves.cpp index aa7379fec0..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::math_optimization::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::math_optimization::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 c50a6e1230..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::math_optimization::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::math_optimization::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 d5306e4615..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::math_optimization::simplex { +namespace cuopt::mathematical_optimization::simplex { template i_t basis_update_t::b_solve(const std::vector& rhs, std::vector& solution) const @@ -2455,4 +2455,4 @@ template class basis_update_t; template class basis_update_mpf_t; #endif -} // namespace cuopt::math_optimization::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 efac680770..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::math_optimization::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::math_optimization::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 258694461f..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::math_optimization::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::math_optimization::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 506a97a3b8..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::math_optimization::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::math_optimization::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 9edc8af71a..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::math_optimization::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::math_optimization::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 1261e3f278..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::math_optimization::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::math_optimization::simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/crossover.cpp b/cpp/src/dual_simplex/crossover.cpp index 8594c97602..068166cc5e 100644 --- a/cpp/src/dual_simplex/crossover.cpp +++ b/cpp/src/dual_simplex/crossover.cpp @@ -19,7 +19,7 @@ #include -namespace cuopt::math_optimization::simplex { +namespace cuopt::mathematical_optimization::simplex { namespace { @@ -1636,4 +1636,4 @@ template crossover_status_t crossover( #endif -} // namespace cuopt::math_optimization::simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/crossover.hpp b/cpp/src/dual_simplex/crossover.hpp index 9684f439ec..1b0b0ba823 100644 --- a/cpp/src/dual_simplex/crossover.hpp +++ b/cpp/src/dual_simplex/crossover.hpp @@ -13,7 +13,7 @@ #include #include -namespace cuopt::math_optimization::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::math_optimization::simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/folding.cpp b/cpp/src/dual_simplex/folding.cpp index bee839328d..8e6724a07f 100644 --- a/cpp/src/dual_simplex/folding.cpp +++ b/cpp/src/dual_simplex/folding.cpp @@ -15,7 +15,7 @@ #include #include -namespace cuopt::math_optimization::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::math_optimization::simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/folding.hpp b/cpp/src/dual_simplex/folding.hpp index c4ff8558cd..74dd2e8d61 100644 --- a/cpp/src/dual_simplex/folding.hpp +++ b/cpp/src/dual_simplex/folding.hpp @@ -11,11 +11,11 @@ #include #include -namespace cuopt::math_optimization::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::math_optimization::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 57453e4819..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::math_optimization::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::math_optimization::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 72c0fd069c..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::math_optimization::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::math_optimization::simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/logger.hpp b/cpp/src/dual_simplex/logger.hpp index 80ad55287a..c35712fc26 100644 --- a/cpp/src/dual_simplex/logger.hpp +++ b/cpp/src/dual_simplex/logger.hpp @@ -17,7 +17,7 @@ #include #include -namespace cuopt::math_optimization::simplex { +namespace cuopt::mathematical_optimization::simplex { class logger_t { public: @@ -128,4 +128,4 @@ class logger_t { std::FILE* log_file; }; -} // namespace cuopt::math_optimization::simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/phase1.cpp b/cpp/src/dual_simplex/phase1.cpp index 895b496b48..96b941d992 100644 --- a/cpp/src/dual_simplex/phase1.cpp +++ b/cpp/src/dual_simplex/phase1.cpp @@ -15,7 +15,7 @@ #include #include -namespace cuopt::math_optimization::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::math_optimization::simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/phase1.hpp b/cpp/src/dual_simplex/phase1.hpp index c5a78e64f3..e180746bef 100644 --- a/cpp/src/dual_simplex/phase1.hpp +++ b/cpp/src/dual_simplex/phase1.hpp @@ -14,9 +14,9 @@ #include #include -namespace cuopt::math_optimization::simplex { +namespace cuopt::mathematical_optimization::simplex { template i_t create_phase1_problem(const lp_problem_t& lp, lp_problem_t& out); -} // namespace cuopt::math_optimization::simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/phase2.cpp b/cpp/src/dual_simplex/phase2.cpp index 5412c592cc..75083ddb19 100644 --- a/cpp/src/dual_simplex/phase2.cpp +++ b/cpp/src/dual_simplex/phase2.cpp @@ -42,7 +42,7 @@ #include #include -namespace cuopt::math_optimization::simplex { +namespace cuopt::mathematical_optimization::simplex { constexpr int FEATURE_LOG_INTERVAL = 100; @@ -3791,4 +3791,4 @@ template void compute_initial_nonbasic_end(const std::vector& std::vector& nonbasic_end); #endif -} // namespace cuopt::math_optimization::simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/phase2.hpp b/cpp/src/dual_simplex/phase2.hpp index e2cfaa377a..294c2b63bc 100644 --- a/cpp/src/dual_simplex/phase2.hpp +++ b/cpp/src/dual_simplex/phase2.hpp @@ -21,7 +21,7 @@ namespace cuopt { struct work_limit_context_t; } -namespace cuopt::math_optimization::simplex { +namespace cuopt::mathematical_optimization::simplex { enum class dual_status_t { OPTIMAL = 0, @@ -107,4 +107,4 @@ void compute_initial_nonbasic_end(const std::vector& basic_mark, csr_matrix_t& Arow, std::vector& nonbasic_end); -} // namespace cuopt::math_optimization::simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/presolve.cpp b/cpp/src/dual_simplex/presolve.cpp index 8ae227becd..9c55185c6d 100644 --- a/cpp/src/dual_simplex/presolve.cpp +++ b/cpp/src/dual_simplex/presolve.cpp @@ -17,7 +17,7 @@ #include #include -namespace cuopt::math_optimization::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::math_optimization::simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/presolve.hpp b/cpp/src/dual_simplex/presolve.hpp index 176e7bfa18..855a4e6145 100644 --- a/cpp/src/dual_simplex/presolve.hpp +++ b/cpp/src/dual_simplex/presolve.hpp @@ -20,7 +20,7 @@ #include #include -namespace cuopt::math_optimization::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::math_optimization::simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/primal.cpp b/cpp/src/dual_simplex/primal.cpp index 77f4241e33..5451a57f08 100644 --- a/cpp/src/dual_simplex/primal.cpp +++ b/cpp/src/dual_simplex/primal.cpp @@ -14,7 +14,7 @@ #include #include -namespace cuopt::math_optimization::simplex { +namespace cuopt::mathematical_optimization::simplex { namespace { @@ -558,4 +558,4 @@ template primal_status_t primal_phase2( #endif -} // namespace cuopt::math_optimization::simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/primal.hpp b/cpp/src/dual_simplex/primal.hpp index 7b36b375db..33bcfa722d 100644 --- a/cpp/src/dual_simplex/primal.hpp +++ b/cpp/src/dual_simplex/primal.hpp @@ -15,7 +15,7 @@ #include -namespace cuopt::math_optimization::simplex { +namespace cuopt::mathematical_optimization::simplex { enum class primal_status_t { OPTIMAL = 0, @@ -36,4 +36,4 @@ primal_status_t primal_phase2(i_t phase, lp_solution_t& sol, i_t& iter); -} // namespace cuopt::math_optimization::simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/random.hpp b/cpp/src/dual_simplex/random.hpp index 1c79058594..3d084d2acf 100644 --- a/cpp/src/dual_simplex/random.hpp +++ b/cpp/src/dual_simplex/random.hpp @@ -9,7 +9,7 @@ #include -namespace cuopt::math_optimization::simplex { +namespace cuopt::mathematical_optimization::simplex { template class random_t { @@ -34,4 +34,4 @@ class random_t { std::mt19937 gen; }; -} // namespace cuopt::math_optimization::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 94088985e5..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::math_optimization::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::math_optimization::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 64595fe95f..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::math_optimization::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::math_optimization::simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/scaling.cpp b/cpp/src/dual_simplex/scaling.cpp index efcdfc0f15..ac96496ec6 100644 --- a/cpp/src/dual_simplex/scaling.cpp +++ b/cpp/src/dual_simplex/scaling.cpp @@ -10,7 +10,7 @@ #include -namespace cuopt::math_optimization::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::math_optimization::simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/scaling.hpp b/cpp/src/dual_simplex/scaling.hpp index 4eaf810959..eab60c486b 100644 --- a/cpp/src/dual_simplex/scaling.hpp +++ b/cpp/src/dual_simplex/scaling.hpp @@ -14,7 +14,7 @@ #include -namespace cuopt::math_optimization::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::math_optimization::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 8c6a87ed1c..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::math_optimization { +namespace cuopt::mathematical_optimization { struct benchmark_info_t; } -namespace cuopt::math_optimization::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::math_optimization::benchmark_info_t* benchmark_info_ptr = nullptr; + cuopt::mathematical_optimization::benchmark_info_t* benchmark_info_ptr = nullptr; }; -} // namespace cuopt::math_optimization::simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/singletons.cpp b/cpp/src/dual_simplex/singletons.cpp index 834c1a797b..4d686b2ac1 100644 --- a/cpp/src/dual_simplex/singletons.cpp +++ b/cpp/src/dual_simplex/singletons.cpp @@ -11,7 +11,7 @@ #include -namespace cuopt::math_optimization::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::math_optimization::simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/singletons.hpp b/cpp/src/dual_simplex/singletons.hpp index 34007b7fed..59964fc428 100644 --- a/cpp/src/dual_simplex/singletons.hpp +++ b/cpp/src/dual_simplex/singletons.hpp @@ -12,7 +12,7 @@ #include #include -namespace cuopt::math_optimization::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::math_optimization::simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/solution.hpp b/cpp/src/dual_simplex/solution.hpp index 2079d2224e..435e9a9fce 100644 --- a/cpp/src/dual_simplex/solution.hpp +++ b/cpp/src/dual_simplex/solution.hpp @@ -12,7 +12,7 @@ #include #include -namespace cuopt::math_optimization::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::math_optimization::simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/solve.cpp b/cpp/src/dual_simplex/solve.cpp index 06ef949bff..7c4f13d8c5 100644 --- a/cpp/src/dual_simplex/solve.cpp +++ b/cpp/src/dual_simplex/solve.cpp @@ -33,7 +33,7 @@ #include #include -namespace cuopt::math_optimization::simplex { +namespace cuopt::mathematical_optimization::simplex { namespace { @@ -846,4 +846,4 @@ template int solve_mip_with_guess( #endif -} // namespace cuopt::math_optimization::simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/solve.hpp b/cpp/src/dual_simplex/solve.hpp index f5fd7833cf..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::math_optimization::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::math_optimization::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 4a1873cbc4..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::math_optimization::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::math_optimization::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 5edcd1ec0b..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::math_optimization::simplex { +namespace cuopt::mathematical_optimization::simplex { template class csr_matrix_t; // Forward declaration of CSR matrix needed to define CSC @@ -55,7 +55,8 @@ class csc_matrix_t { i_t col_length(i_t j) const { return col_start[j + 1] - col_start[j]; } // Convert the CSC matrix to a CSR matrix - i_t to_compressed_row(cuopt::math_optimization::simplex::csr_matrix_t& Arow) const; + i_t to_compressed_row( + 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; @@ -311,4 +312,4 @@ i_t matrix_vector_multiply( return 0; } -} // namespace cuopt::math_optimization::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 9ef07754a4..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::math_optimization::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::math_optimization::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 3f0e0dbd50..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::math_optimization::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::math_optimization::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 c113a8da00..5c27c4bc65 100644 --- a/cpp/src/dual_simplex/tic_toc.cpp +++ b/cpp/src/dual_simplex/tic_toc.cpp @@ -9,7 +9,7 @@ #include -namespace cuopt::math_optimization::simplex { +namespace cuopt::mathematical_optimization::simplex { double tic() { @@ -24,4 +24,4 @@ double toc(double start) return (now - start); } -} // namespace cuopt::math_optimization::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 2e8bae608c..23463d63ae 100644 --- a/cpp/src/dual_simplex/tic_toc.hpp +++ b/cpp/src/dual_simplex/tic_toc.hpp @@ -9,8 +9,8 @@ #include -namespace cuopt::math_optimization::simplex { +namespace cuopt::mathematical_optimization::simplex { double tic(); double toc(double start); -} // namespace cuopt::math_optimization::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 ba210a2f67..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::math_optimization::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::math_optimization::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::math_optimization::simplex +} // namespace cuopt::mathematical_optimization::simplex diff --git a/cpp/src/dual_simplex/types.hpp b/cpp/src/dual_simplex/types.hpp index 59094569cd..df45c733c6 100644 --- a/cpp/src/dual_simplex/types.hpp +++ b/cpp/src/dual_simplex/types.hpp @@ -10,7 +10,7 @@ #include #include -namespace cuopt::math_optimization::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::math_optimization::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 bbbcfafbc6..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::math_optimization::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::math_optimization::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 93f65f1b0a..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::math_optimization::simplex { +namespace cuopt::mathematical_optimization::simplex { template f_t vector_norm2_squared(const std::vector& x) @@ -211,4 +211,4 @@ template int inverse_permutation(const std::vector& p, std::vector #include -namespace cuopt::math_optimization::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::math_optimization::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 5547c0a352..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::math_optimization::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::math_optimization::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 319299656f..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::math_optimization { +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::math_optimization +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/grpc/client/grpc_client.hpp b/cpp/src/grpc/client/grpc_client.hpp index 433f48e1e0..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::math_optimization { +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::math_optimization +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/grpc/client/solve_remote.cpp b/cpp/src/grpc/client/solve_remote.cpp index 5d8af78f4b..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::math_optimization { +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::math_optimization +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/grpc/codegen/field_registry.yaml b/cpp/src/grpc/codegen/field_registry.yaml index 4c3c60e2c1..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/math_optimization/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 3412d76234..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::math_optimization { +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::math_optimization +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/grpc/grpc_problem_mapper.cpp b/cpp/src/grpc/grpc_problem_mapper.cpp index f828334e7e..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::math_optimization { +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::math_optimization +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/grpc/grpc_problem_mapper.hpp b/cpp/src/grpc/grpc_problem_mapper.hpp index b8be14e6bb..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::math_optimization { +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::math_optimization +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/grpc/grpc_service_mapper.cpp b/cpp/src/grpc/grpc_service_mapper.cpp index 28b7b77f64..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::math_optimization { +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::math_optimization +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/grpc/grpc_service_mapper.hpp b/cpp/src/grpc/grpc_service_mapper.hpp index 06a314e1a6..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::math_optimization { +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::math_optimization +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/grpc/grpc_settings_mapper.cpp b/cpp/src/grpc/grpc_settings_mapper.cpp index 7dc4ba1b56..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::math_optimization { +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::math_optimization +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/grpc/grpc_settings_mapper.hpp b/cpp/src/grpc/grpc_settings_mapper.hpp index 77320c09ff..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::math_optimization { +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::math_optimization +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/grpc/grpc_solution_mapper.cpp b/cpp/src/grpc/grpc_solution_mapper.cpp index ed3792690b..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::math_optimization { +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::math_optimization +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/grpc/grpc_solution_mapper.hpp b/cpp/src/grpc/grpc_solution_mapper.hpp index b20ff460dd..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::math_optimization { +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::math_optimization +} // 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 94036f0d16..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::math_optimization::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); @@ -336,11 +337,12 @@ inline PipeWriteStatus write_chunked_request_to_pipe( return PipeWriteStatus::Success; } -inline bool read_chunked_request_from_pipe(int fd, - cuopt::remote::ChunkedProblemHeader& header_out, - std::map>& arrays_out, - std::map>& container_arrays_out) +inline bool read_chunked_request_from_pipe( + int fd, + cuopt::remote::ChunkedProblemHeader& header_out, + std::map>& arrays_out, + std::map>& + container_arrays_out) { // dest.resize(total_bytes) can throw std::bad_alloc if the wire claims an // allocation larger than the worker can satisfy. Catch it here so the @@ -385,8 +387,8 @@ inline bool read_chunked_request_from_pipe(int fd, 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::math_optimization::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 1eb1ff6878..8390953350 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,7 +60,7 @@ using grpc::ServerWriter; using grpc::Status; using grpc::StatusCode; -// Note: cuopt::math_optimization names are fully qualified below to avoid leaking +// 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. @@ -217,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 33c44c8a13..5f35640241 100644 --- a/cpp/src/grpc/server/grpc_service_impl.cpp +++ b/cpp/src/grpc/server/grpc_service_impl.cpp @@ -9,7 +9,7 @@ #include "grpc_pipe_serialization.hpp" #include "grpc_server_types.hpp" -using namespace cuopt::math_optimization; +using namespace cuopt::mathematical_optimization; class CuOptRemoteServiceImpl final : public cuopt::remote::CuOptRemoteService::Service { public: @@ -166,7 +166,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::math_optimization::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 { diff --git a/cpp/src/grpc/server/grpc_worker.cpp b/cpp/src/grpc/server/grpc_worker.cpp index 6747a2e796..e686d12974 100644 --- a/cpp/src/grpc/server/grpc_worker.cpp +++ b/cpp/src/grpc/server/grpc_worker.cpp @@ -9,7 +9,7 @@ #include "grpc_pipe_serialization.hpp" #include "grpc_server_types.hpp" -using namespace cuopt::math_optimization; +using namespace cuopt::mathematical_optimization; // --------------------------------------------------------------------------- // Data-transfer structs used to pass results between decomposed functions. @@ -220,7 +220,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; diff --git a/cpp/src/io/data_model_view.cpp b/cpp/src/io/data_model_view.cpp index 70ef2e7745..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::math_optimization::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::math_optimization::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 7d9f7572de..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::math_optimization::io::error_type_t; -using cuopt::math_optimization::io::mps_parser_expects; -using cuopt::math_optimization::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::math_optimization::io { +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::math_optimization::io +} // namespace cuopt::mathematical_optimization::io diff --git a/cpp/src/io/file_to_string.hpp b/cpp/src/io/file_to_string.hpp index 6d0d82b631..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::math_optimization::io { +namespace cuopt::mathematical_optimization::io { // Reads `file` into a buffer and appends a trailing '\0'. // @@ -21,4 +21,4 @@ namespace cuopt::math_optimization::io { // The returned buffer's size includes the null terminator. std::vector file_to_string(const std::string& file); -} // namespace cuopt::math_optimization::io +} // namespace cuopt::mathematical_optimization::io diff --git a/cpp/src/io/lp_parser.cpp b/cpp/src/io/lp_parser.cpp index 48a5f81d3c..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::math_optimization::io { +namespace cuopt::mathematical_optimization::io { namespace { @@ -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::math_optimization::io +} // namespace cuopt::mathematical_optimization::io diff --git a/cpp/src/io/lp_parser.hpp b/cpp/src/io/lp_parser.hpp index 6eb3e0d879..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::math_optimization::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::math_optimization::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 39689cfcd2..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::math_optimization::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::math_optimization::io +} // namespace cuopt::mathematical_optimization::io diff --git a/cpp/src/io/mps_parser.cpp b/cpp/src/io/mps_parser.cpp index f455cd6dd4..7d3a52ee48 100644 --- a/cpp/src/io/mps_parser.cpp +++ b/cpp/src/io/mps_parser.cpp @@ -23,10 +23,10 @@ #include namespace { -using cuopt::math_optimization::io::coo_entries_t; -using cuopt::math_optimization::io::error_type_t; -using cuopt::math_optimization::io::mps_parser_expects; -using cuopt::math_optimization::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::math_optimization::io { +namespace cuopt::mathematical_optimization::io { template std::string_view get_next_string(std::string_view line, i_t& pos, i_t& end) @@ -1538,4 +1538,4 @@ template class mps_parser_t; template class mps_parser_t; -} // namespace cuopt::math_optimization::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 4e04f95a74..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::math_optimization::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::math_optimization::io +} // namespace cuopt::mathematical_optimization::io diff --git a/cpp/src/io/mps_writer.cpp b/cpp/src/io/mps_writer.cpp index 9b8829d041..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::math_optimization::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::math_optimization::io +} // namespace cuopt::mathematical_optimization::io diff --git a/cpp/src/io/parser.cpp b/cpp/src/io/parser.cpp index 0684b1751c..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::math_optimization::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::math_optimization::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 9ba5567492..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::math_optimization::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::math_optimization::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 5bdc849c5e..a0d1813856 100644 --- a/cpp/src/io/utilities/error.hpp +++ b/cpp/src/io/utilities/error.hpp @@ -11,7 +11,7 @@ #include #include -namespace cuopt::math_optimization::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::math_optimization::io +} // namespace cuopt::mathematical_optimization::io diff --git a/cpp/src/io/writer.cpp b/cpp/src/io/writer.cpp index 7cab17f9cf..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::math_optimization::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::math_optimization::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 3897fec829..cbc3389ae4 100644 --- a/cpp/src/math_optimization/solution_reader.cu +++ b/cpp/src/math_optimization/solution_reader.cu @@ -16,7 +16,7 @@ #include #include -namespace cuopt::math_optimization { +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::math_optimization +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/math_optimization/solution_reader.hpp b/cpp/src/math_optimization/solution_reader.hpp index efc85aaa77..dd0976028a 100644 --- a/cpp/src/math_optimization/solution_reader.hpp +++ b/cpp/src/math_optimization/solution_reader.hpp @@ -10,7 +10,7 @@ #include #include -namespace cuopt::math_optimization { +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::math_optimization +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/math_optimization/solution_writer.cu b/cpp/src/math_optimization/solution_writer.cu index 94400d2a54..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::math_optimization { +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::math_optimization +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/math_optimization/solution_writer.hpp b/cpp/src/math_optimization/solution_writer.hpp index d4acf2a776..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::math_optimization { +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::math_optimization +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/math_optimization/solver_settings.cu b/cpp/src/math_optimization/solver_settings.cu index 9c86e169f9..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::math_optimization { +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::math_optimization +} // 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 6d5f0548f0..c9d20c97fe 100644 --- a/cpp/src/mip_heuristics/diversity/assignment_hash_map.cu +++ b/cpp/src/mip_heuristics/diversity/assignment_hash_map.cu @@ -15,7 +15,7 @@ #include namespace cuopt { -namespace math_optimization { +namespace mathematical_optimization { namespace mip { struct combine_hash { @@ -158,5 +158,5 @@ template class assignment_hash_map_t; #endif } // namespace mip -} // namespace math_optimization +} // 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 0c62fe1745..50a002b2e3 100644 --- a/cpp/src/mip_heuristics/diversity/assignment_hash_map.cuh +++ b/cpp/src/mip_heuristics/diversity/assignment_hash_map.cuh @@ -10,7 +10,7 @@ #include namespace cuopt { -namespace math_optimization { +namespace mathematical_optimization { namespace mip { template @@ -31,5 +31,5 @@ class assignment_hash_map_t { }; } // namespace mip -} // namespace math_optimization +} // 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 1a9ea8d3ce..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::math_optimization::mip { +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::math_optimization::mip +} // 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 57fc82a29b..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::math_optimization::mip { +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; @@ -966,4 +966,4 @@ template class diversity_manager_t; template class diversity_manager_t; #endif -} // namespace cuopt::math_optimization::mip +} // 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 1e9c404902..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::math_optimization::mip { +namespace cuopt::mathematical_optimization::mip { template class diversity_manager_t { @@ -110,4 +110,4 @@ class diversity_manager_t { bool run_only_sub_mip_recombiner{false}; }; -} // namespace cuopt::math_optimization::mip +} // 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 627f7cce2a..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::math_optimization::mip { +namespace cuopt::mathematical_optimization::mip { template rins_t::rins_t(mip_solver_context_t& context_, diversity_manager_t& dm_, @@ -234,7 +234,7 @@ void rins_t::run_rins() f_t current_mip_gap = compute_rel_mip_gap(prev_obj, lower_bound); // run sub-mip - namespace simplex = cuopt::math_optimization::simplex; + 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); @@ -351,4 +351,4 @@ template class rins_t; template class rins_t; #endif -} // namespace cuopt::math_optimization::mip +} // 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 e78f871f69..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::math_optimization::mip { +namespace cuopt::mathematical_optimization::mip { // forward declare template @@ -84,4 +84,4 @@ class rins_t { omp_atomic_t launch_new_task{true}; }; -} // namespace cuopt::math_optimization::mip +} // 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 c175ef5178..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::math_optimization::mip { +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::math_optimization::mip +} // 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 81aa55aca9..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::math_optimization::mip { +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::math_optimization::mip +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/diversity/population.cu b/cpp/src/mip_heuristics/diversity/population.cu index de47d455b8..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::math_optimization::mip { +namespace cuopt::mathematical_optimization::mip { constexpr double weight_increase_ratio = 2.; constexpr double weight_decrease_ratio = 0.9; @@ -902,4 +902,4 @@ template class population_t; template class population_t; #endif -} // namespace cuopt::math_optimization::mip +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/diversity/population.cuh b/cpp/src/mip_heuristics/diversity/population.cuh index c02f1d3c19..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::math_optimization::mip { +namespace cuopt::mathematical_optimization::mip { // forward declare template @@ -214,4 +214,4 @@ class population_t { cuopt::timer_t timer; }; -} // namespace cuopt::math_optimization::mip +} // 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 f3b1b63b61..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::math_optimization::mip { +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::math_optimization::mip +} // 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 62d5b28fbc..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::math_optimization::mip { +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::math_optimization::mip +} // 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 fc0c1552bf..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::math_optimization::mip { +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::math_optimization::mip +} // 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 de5e5a8031..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::math_optimization::mip { +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::math_optimization::mip +} // 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 c1ad82a89d..5abe9f5141 100644 --- a/cpp/src/mip_heuristics/diversity/recombiners/recombiner_configs.hpp +++ b/cpp/src/mip_heuristics/diversity/recombiners/recombiner_configs.hpp @@ -7,7 +7,7 @@ #pragma once -namespace cuopt::math_optimization::mip { +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::math_optimization::mip +} // 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 768e12fd32..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::math_optimization::mip { +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::math_optimization::mip +} // 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 0ca102ca82..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/math_optimization/mip/solver_settings.hpp" +#include "cuopt/mathematical_optimization/mip/solver_settings.hpp" #include "recombiner.cuh" #include @@ -16,7 +16,7 @@ #include #include -namespace cuopt::math_optimization::mip { +namespace cuopt::mathematical_optimization::mip { template class sub_mip_recombiner_t : public recombiner_t { @@ -96,7 +96,7 @@ class sub_mip_recombiner_t : public recombiner_t { simplex::mip_solution_t branch_and_bound_solution(1); if (run_sub_mip) { // run sub-mip - namespace simplex = cuopt::math_optimization::simplex; + 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); @@ -205,4 +205,4 @@ class sub_mip_recombiner_t : public recombiner_t { population_t& population; }; -} // namespace cuopt::math_optimization::mip +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/diversity/weights.cuh b/cpp/src/mip_heuristics/diversity/weights.cuh index 7993817894..f0c5facb6a 100644 --- a/cpp/src/mip_heuristics/diversity/weights.cuh +++ b/cpp/src/mip_heuristics/diversity/weights.cuh @@ -12,7 +12,7 @@ #include #include -namespace cuopt::math_optimization::mip { +namespace cuopt::mathematical_optimization::mip { template struct weight_t { @@ -29,4 +29,4 @@ struct weight_t { rmm::device_scalar objective_weight; }; -} // namespace cuopt::math_optimization::mip +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/early_heuristic.cuh b/cpp/src/mip_heuristics/early_heuristic.cuh index 74e5583ecb..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::math_optimization::mip { +namespace cuopt::mathematical_optimization::mip { template using early_incumbent_callback_t = std::function #include -namespace cuopt::math_optimization::mip { +namespace cuopt::mathematical_optimization::mip { template struct fj_cpu_climber_t; @@ -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::math_optimization::mip +} // 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 f3c40e3ffb..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::math_optimization::mip { +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::math_optimization::mip +} // 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 8a0d487f64..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::math_optimization::mip { +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::math_optimization::mip +} // 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 e12642485b..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::math_optimization::mip { +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::math_optimization::mip +} // 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 1a868fee69..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::math_optimization::mip { +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::math_optimization::mip +} // 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 d6186130e5..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::math_optimization::mip { +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::math_optimization::mip +} // 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 423b5fa214..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::math_optimization::mip { +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::math_optimization::mip +} // 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 f7057b7c72..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::math_optimization::mip { +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::math_optimization::mip +} // 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 93fc982be3..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::math_optimization::mip { +namespace cuopt::mathematical_optimization::mip { template DI thrust::pair move_objective_score( @@ -1805,4 +1805,4 @@ CUOPT_INSTANTIATE(double) #undef CUOPT_INSTANTIATE -} // namespace cuopt::math_optimization::mip +} // 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 7eb1057efa..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::math_optimization::mip { +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::math_optimization::mip +} // 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 0a6f537f40..db4dfc012a 100644 --- a/cpp/src/mip_heuristics/feasibility_jump/fj_cpu.cu +++ b/cpp/src/mip_heuristics/feasibility_jump/fj_cpu.cu @@ -46,7 +46,7 @@ #define CPUFJ_NVTX_RANGE(name) ((void)0) #endif -namespace cuopt::math_optimization::mip { +namespace cuopt::mathematical_optimization::mip { template void finalize_fj_cpu_host_initialization( @@ -1893,4 +1893,4 @@ template void finalize_fj_cpu_host_initialization( const typename mip_solver_settings_t::tolerances_t& tolerances); #endif -} // namespace cuopt::math_optimization::mip +} // 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 8d58b03a63..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::math_optimization::mip { +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::math_optimization::mip +} // 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 2564020cde..a24e4b6a7f 100644 --- a/cpp/src/mip_heuristics/feasibility_jump/utils.cuh +++ b/cpp/src/mip_heuristics/feasibility_jump/utils.cuh @@ -19,7 +19,7 @@ #include #include -namespace cuopt::math_optimization::mip { +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::math_optimization::mip +} // 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 9bfbc52a16..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::math_optimization::mip { +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::math_optimization::mip +} // 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 51ee8c8078..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::math_optimization::mip { +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::math_optimization::mip +} // 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 7331d5ddfd..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::math_optimization::mip { +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::math_optimization::mip +} // 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 5d0fdf52d1..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::math_optimization::mip { +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::math_optimization::mip +} // 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 c6ac3e6194..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::math_optimization::mip { +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::math_optimization::mip +} // 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 3cc82225de..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::math_optimization::mip { +namespace cuopt::mathematical_optimization::mip { template local_search_t::local_search_t(mip_solver_context_t& context_, @@ -902,4 +902,4 @@ template class local_search_t; template class local_search_t; #endif -} // namespace cuopt::math_optimization::mip +} // 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 e00aafaa46..f786dceed1 100644 --- a/cpp/src/mip_heuristics/local_search/local_search.cuh +++ b/cpp/src/mip_heuristics/local_search/local_search.cuh @@ -15,12 +15,12 @@ #include #include -namespace cuopt::math_optimization::simplex { +namespace cuopt::mathematical_optimization::simplex { template class branch_and_bound_t; } -namespace cuopt::math_optimization::mip { +namespace cuopt::mathematical_optimization::mip { // make sure RANDOM is always the last enum class ls_method_t : int { @@ -131,4 +131,4 @@ class local_search_t { population_t* pop_ptr{nullptr}; }; -} // namespace cuopt::math_optimization::mip +} // 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 6251d659af..1ea4dd292b 100644 --- a/cpp/src/mip_heuristics/local_search/local_search_config.hpp +++ b/cpp/src/mip_heuristics/local_search/local_search_config.hpp @@ -7,7 +7,7 @@ #pragma once -namespace cuopt::math_optimization::mip { +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::math_optimization::mip +} // 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 c5440dd976..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::math_optimization::mip { +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::math_optimization::mip +}; // 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 a1e7aee46c..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::math_optimization::mip { +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::math_optimization::mip +} // 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 ef3da385a6..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::math_optimization::mip { +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::math_optimization::mip +} // 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 2eff0d38a6..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::math_optimization::mip { +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::math_optimization::mip +} // 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 438a62fe7d..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::math_optimization::mip { +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::math_optimization::mip +} // 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 d9839f6d72..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::math_optimization::mip { +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::math_optimization::mip +} // 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 f654628d70..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::math_optimization::mip { +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::math_optimization::mip +} // 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 7fe92d4b28..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::math_optimization::mip { +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::math_optimization::mip +} // 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 e7d5eb7f9f..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::math_optimization::mip { +namespace cuopt::mathematical_optimization::mip { template bool check_brute_force_rounding(solution_t& solution) @@ -189,4 +189,4 @@ INSTANTIATE(double) #undef INSTANTIATE -} // namespace cuopt::math_optimization::mip +} // 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 62e25d75cc..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::math_optimization::mip { +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::math_optimization::mip +} // 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 2b0fb2ee2c..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::math_optimization::mip { +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::math_optimization::mip +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/logger.cuh b/cpp/src/mip_heuristics/logger.cuh index 066fb141cf..d202fe5a1f 100644 --- a/cpp/src/mip_heuristics/logger.cuh +++ b/cpp/src/mip_heuristics/logger.cuh @@ -9,7 +9,7 @@ #include -namespace cuopt::math_optimization::mip { +namespace cuopt::mathematical_optimization::mip { // Default to info level if not specified. #if !defined(CUOPT_LOG_ACTIVE_LEVEL) @@ -53,4 +53,4 @@ namespace cuopt::math_optimization::mip { #define DEVICE_LOG_CRITICAL(...) void(0) #endif -} // namespace cuopt::math_optimization::mip +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/mip_constants.hpp b/cpp/src/mip_heuristics/mip_constants.hpp index 22e507d107..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 eece2171a8..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::math_optimization::mip { +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::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::optimization_problem_t& template rmm::device_uvector capture_pre_scaling_integer_gcd( - const cuopt::math_optimization::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::math_optimization::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::math_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) +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::math_optimization::mip +} // 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 bfc1f92052..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::math_optimization::mip { +namespace cuopt::mathematical_optimization::mip { template class mip_scaling_strategy_t { public: - using optimization_problem_type_t = cuopt::math_optimization::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::math_optimization::mip +} // 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 642888985f..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::math_optimization::mip { +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::math_optimization::mip +} // 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 780e1f6c7a..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::math_optimization::mip { +namespace cuopt::mathematical_optimization::mip { template class probing_cache_t; @@ -84,4 +84,4 @@ class bound_presolve_t { i_t solve_iter; }; -} // namespace cuopt::math_optimization::mip +} // 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 1b00f6a36f..ed25e1a2c1 100644 --- a/cpp/src/mip_heuristics/presolve/bounds_presolve_helpers.cuh +++ b/cpp/src/mip_heuristics/presolve/bounds_presolve_helpers.cuh @@ -15,7 +15,7 @@ #include "bounds_update_data.cuh" -namespace cuopt::math_optimization::mip { +namespace cuopt::mathematical_optimization::mip { template struct tuple_plus_t { @@ -35,4 +35,4 @@ struct tuple_plus_t { } }; -} // namespace cuopt::math_optimization::mip +} // 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 d701ad03d3..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::math_optimization::mip { +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::math_optimization::mip +} // 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 69cabf0ef7..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::math_optimization::mip { +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::math_optimization::mip +} // 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 87445596ed..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::math_optimization::mip { +namespace cuopt::mathematical_optimization::mip { // Activity calculation @@ -398,4 +398,4 @@ __global__ void update_bounds_kernel(typename problem_t::view_t pb, } } -} // namespace cuopt::math_optimization::mip +} // 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 b2674a2482..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::math_optimization::mip { +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::math_optimization::mip +} // 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 dafcbbed87..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::math_optimization::mip { +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::math_optimization::mip +} // 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 1a33a3fe38..a14f8057e2 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,7 @@ #include #include -namespace cuopt::math_optimization::mip { +namespace cuopt::mathematical_optimization::mip { // do constraints with only binary variables. template @@ -785,4 +785,4 @@ INSTANTIATE(double) #endif #undef INSTANTIATE -} // namespace cuopt::math_optimization::mip +} // 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 58f330a9e9..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::math_optimization::mip { +namespace cuopt::mathematical_optimization::mip { struct clique_config_t { int min_clique_size = 512; @@ -222,7 +222,7 @@ void build_clique_table(const simplex::user_problem_t& problem, template void fill_var_clique_maps(clique_table_t& clique_table); -} // namespace cuopt::math_optimization::mip +} // 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 c5799137e4..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::math_optimization::mip { +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::math_optimization::mip +} // 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 6bfda7a3ee..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::math_optimization::mip { +namespace cuopt::mathematical_optimization::mip { template class GF2Presolve : public papilo::PresolveMethod { @@ -66,4 +66,4 @@ class GF2Presolve : public papilo::PresolveMethod { } }; -} // namespace cuopt::math_optimization::mip +} // 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 7ba04c53d1..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::math_optimization::mip { +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::math_optimization::mip +} // 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 c0dbf0ec13..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::math_optimization::mip { +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::math_optimization::mip +} // 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 ad0dfa459d..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::math_optimization::mip { +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::math_optimization::mip +} // 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 437cbd202c..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::math_optimization::mip { +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::math_optimization::mip +} // 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 6a8a83f4b9..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::math_optimization::mip { +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::math_optimization::mip +} // 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 c17d03a1ba..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::math_optimization::mip { +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::math_optimization::mip +} // 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 b5f2c54575..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::math_optimization::mip { +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::math_optimization::mip +} // 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 cd022027a3..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::math_optimization::mip { +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::math_optimization::mip +} // 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 fa2fc3f989..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::math_optimization::mip { +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::math_optimization::mip +} // 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 787defd7e8..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::math_optimization::mip { +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::math_optimization::mip +} // 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 af20d18c38..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::math_optimization::mip { +namespace cuopt::mathematical_optimization::mip { namespace { @@ -415,4 +415,4 @@ template void expand_initial_solutions_for_semi_continuous(mip_solver_settings_t rmm::cuda_stream_view); #endif -} // namespace cuopt::math_optimization::mip +} // 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 567978c651..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::math_optimization::mip { +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::math_optimization::mip +} // 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 302454b72a..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::math_optimization::mip { +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::math_optimization::mip::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::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::mip +} // 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 39bf5938a9..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::math_optimization::mip { +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::math_optimization::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::math_optimization::presolver_t presolver_ = cuopt::math_optimization::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::math_optimization::mip +} // 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 efb8761389..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::math_optimization::mip { +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::math_optimization::mip +} // 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 566d9ff7d4..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::math_optimization::mip { +namespace cuopt::mathematical_optimization::mip { template void test_renumbered_coo(raft::device_span coo_major, const problem_t& pb) @@ -371,4 +371,4 @@ void trivial_presolve(problem_t& problem, bool remap_cache_ids = false problem.check_problem_representation(true); } -} // namespace cuopt::math_optimization::mip +} // 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 f2e3bcf03e..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::math_optimization::mip { +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::math_optimization::mip +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/presolve/utils.cuh b/cpp/src/mip_heuristics/presolve/utils.cuh index 6f295fb1e7..e7ef92637f 100644 --- a/cpp/src/mip_heuristics/presolve/utils.cuh +++ b/cpp/src/mip_heuristics/presolve/utils.cuh @@ -7,7 +7,7 @@ #pragma once -namespace cuopt::math_optimization::mip { +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::math_optimization::mip +} // 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 366e467d53..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::math_optimization::mip { +namespace cuopt::mathematical_optimization::mip { template struct constraints_delta_t { @@ -65,4 +65,4 @@ struct variables_delta_t { } }; -} // namespace cuopt::math_optimization::mip +} // 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 72153dee2c..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::math_optimization::mip { +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::math_optimization::mip +} // 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 b96c8fc169..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::math_optimization::mip { +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::math_optimization::mip +} // 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 7501a4fe45..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 math_optimization::mip { +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::math_optimization::mip::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,20 @@ bool presolve_data_t::pre_process_assignment(problem_t& prob assignment.begin()); problem.handle_ptr->sync_stream(); - auto has_integrality_discrepancy = cuopt::math_optimization::mip::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::math_optimization::mip::has_variable_bounds_violation( - problem.handle_ptr, assignment, &problem); + auto 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"); return false; @@ -249,5 +251,5 @@ template class presolve_data_t; template class presolve_data_t; #endif -} // namespace math_optimization::mip +} // 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 63c8754759..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 math_optimization::mip { +namespace mathematical_optimization::mip { template class problem_t; @@ -133,5 +133,5 @@ class presolve_data_t { std::vector> variable_substitutions; }; -} // namespace math_optimization::mip +} // 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 f41e8c7f8c..b789c05cbc 100644 --- a/cpp/src/mip_heuristics/problem/problem.cu +++ b/cpp/src/mip_heuristics/problem/problem.cu @@ -48,7 +48,7 @@ #include -namespace cuopt::math_optimization::mip { +namespace cuopt::mathematical_optimization::mip { template void problem_t::op_problem_cstr_body(const optimization_problem_t& problem_) @@ -1363,7 +1363,7 @@ void problem_t::set_implied_integers(const std::vector& implied_i template void problem_t::recompute_objective_integrality() { - using cuopt::math_optimization::mip::is_integer; + using cuopt::mathematical_optimization::mip::is_integer; objective_is_integral = thrust::all_of(handle_ptr->get_thrust_policy(), @@ -2153,7 +2153,7 @@ void problem_t::preprocess_problem() template void problem_t::set_constraints_from_host_user_problem( - const cuopt::math_optimization::simplex::user_problem_t& user_problem) + const cuopt::mathematical_optimization::simplex::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"); @@ -2274,7 +2274,7 @@ void problem_t::papilo_uncrush_assignment(rmm::device_uvector& as template void problem_t::get_host_user_problem( - cuopt::math_optimization::simplex::user_problem_t& user_problem) const + cuopt::mathematical_optimization::simplex::user_problem_t& user_problem) const { raft::common::nvtx::range fun_scope("get_host_user_problem"); // std::lock_guard lock(problem_mutex); @@ -2361,9 +2361,10 @@ 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::math_optimization::simplex::variable_type_t::CONTINUOUS - : cuopt::math_optimization::simplex::variable_type_t::INTEGER; + user_problem.var_types[j] = + model_variable_types[j] == var_t::CONTINUOUS + ? cuopt::mathematical_optimization::simplex::variable_type_t::CONTINUOUS + : cuopt::mathematical_optimization::simplex::variable_type_t::INTEGER; } } @@ -2495,4 +2496,4 @@ template class problem_t; template class problem_t; #endif -} // namespace cuopt::math_optimization::mip +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/problem/problem.cuh b/cpp/src/mip_heuristics/problem/problem.cuh index 20a885a62e..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 math_optimization::mip { +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::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::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 math_optimization::mip +} // 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 bb5445ee36..734822e265 100644 --- a/cpp/src/mip_heuristics/problem/problem_fixing.cuh +++ b/cpp/src/mip_heuristics/problem/problem_fixing.cuh @@ -10,7 +10,7 @@ #include namespace cuopt { -namespace math_optimization::mip { +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 math_optimization::mip +} // 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 840077c2ba..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::math_optimization::mip { +namespace cuopt::mathematical_optimization::mip { template struct transform_bounds_functor { __device__ thrust::tuple operator()(const thrust::tuple& input) const @@ -424,4 +424,4 @@ static void convert_greater_to_less(mip::problem_t& problem) handle_ptr->sync_stream(); } -} // namespace cuopt::math_optimization::mip +} // 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 316794b6e4..f7578a275a 100644 --- a/cpp/src/mip_heuristics/problem/problem_kernels.cuh +++ b/cpp/src/mip_heuristics/problem/problem_kernels.cuh @@ -11,7 +11,7 @@ #include "problem.cuh" -namespace cuopt::math_optimization::mip { +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::math_optimization::mip +} // 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 3f298287dc..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::math_optimization::mip { +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::math_optimization::mip +} // 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 9b6a7307b5..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::math_optimization::mip { +namespace cuopt::mathematical_optimization::mip { template class problem_t; @@ -68,4 +68,4 @@ class lp_state_t { rmm::device_uvector prev_dual; }; -} // namespace cuopt::math_optimization::mip +} // 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 f676b4ab3e..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::math_optimization::mip { +namespace cuopt::mathematical_optimization::mip { template optimization_problem_solution_t get_relaxed_lp_solution( @@ -228,4 +228,4 @@ INSTANTIATE(double) #undef INSTANTIATE -} // namespace cuopt::math_optimization::mip +} // 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 ef71ca78e2..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::math_optimization::mip { +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::math_optimization::mip +} // 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 17f01f0801..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::math_optimization::mip { +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::math_optimization::mip +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/solution/solution.cu b/cpp/src/mip_heuristics/solution/solution.cu index fdfc6a901a..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::math_optimization::mip { +namespace cuopt::mathematical_optimization::mip { template rmm::device_uvector get_lower_bounds( @@ -599,7 +599,7 @@ f_t solution_t::compute_max_variable_violation() // returns the solution after applying the conversions template -cuopt::math_optimization::mip_solution_t solution_t::get_solution( +cuopt::mathematical_optimization::mip_solution_t solution_t::get_solution( bool output_feasible, solver_stats_t stats, bool log_stats) { cuopt::default_logger().flush(); @@ -623,19 +623,20 @@ cuopt::math_optimization::mip_solution_t solution_t::get_sol 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 = cuopt::math_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); + 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 cuopt::math_optimization::mip_solution_t{ + return cuopt::mathematical_optimization::mip_solution_t{ is_problem_fully_reduced ? mip_termination_status_t::Infeasible : mip_termination_status_t::TimeLimit, stats, @@ -651,4 +652,4 @@ template class solution_t; template class solution_t; #endif -} // namespace cuopt::math_optimization::mip +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/solution/solution.cuh b/cpp/src/mip_heuristics/solution/solution.cuh index 39828184d9..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::math_optimization::mip { +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(); - cuopt::math_optimization::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::math_optimization::mip +} // 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 4c3d3e5ef0..e0625ee530 100644 --- a/cpp/src/mip_heuristics/solution/solution_kernels.cuh +++ b/cpp/src/mip_heuristics/solution/solution_kernels.cuh @@ -11,7 +11,7 @@ #include -namespace cuopt::math_optimization::mip { +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::math_optimization::mip +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/solve.cu b/cpp/src/mip_heuristics/solve.cu index 38230d0c8b..0e6609f5b2 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,7 @@ #include #include -namespace cuopt::math_optimization { +namespace cuopt::mathematical_optimization { // 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) @@ -555,7 +555,7 @@ mip_solution_t solve_mip_helper(optimization_problem_t& op_p } presolver = std::make_unique>(); auto result = presolver->apply(op_problem, - cuopt::math_optimization::problem_category_t::MIP, + cuopt::mathematical_optimization::problem_category_t::MIP, settings.presolver, dual_postsolve, settings.tolerances.absolute_tolerance, @@ -644,7 +644,7 @@ mip_solution_t solve_mip_helper(optimization_problem_t& op_p presolver->undo(primal_solution, dual_solution, reduced_costs, - cuopt::math_optimization::problem_category_t::MIP, + cuopt::mathematical_optimization::problem_category_t::MIP, status_to_skip, dual_postsolve, op_problem.get_handle_ptr()->get_stream()); @@ -911,20 +911,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::math_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( \ +#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 @@ -935,4 +935,4 @@ INSTANTIATE(float) INSTANTIATE(double) #endif -} // namespace cuopt::math_optimization +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/mip_heuristics/solver.cu b/cpp/src/mip_heuristics/solver.cu index 8031aa1278..e2b5ab9dfb 100644 --- a/cpp/src/mip_heuristics/solver.cu +++ b/cpp/src/mip_heuristics/solver.cu @@ -33,7 +33,7 @@ #include #include -namespace cuopt::math_optimization::mip { +namespace cuopt::mathematical_optimization::mip { // 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) @@ -296,19 +296,19 @@ 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::math_optimization::simplex::simplex_solver_settings_t simplex_settings; + cuopt::mathematical_optimization::simplex::simplex_solver_settings_t simplex_settings; simplex_settings.set_log(true); simplex_settings.time_limit = context.settings.time_limit; - cuopt::math_optimization::simplex::user_problem_t post_presolve_problem = + cuopt::mathematical_optimization::simplex::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::math_optimization::mip::detect_symmetry( + context.symmetry = cuopt::mathematical_optimization::mip::detect_symmetry( post_presolve_problem, simplex_settings, has_symmetry_post); } #endif - namespace simplex = cuopt::math_optimization::simplex; + namespace simplex = cuopt::mathematical_optimization::simplex; mip::mip_status_t branch_and_bound_status = mip::mip_status_t::UNSET; simplex::user_problem_t branch_and_bound_problem(context.problem_ptr->handle_ptr); context.problem_ptr->recompute_objective_integrality(); @@ -541,4 +541,4 @@ template class mip_solver_t; template class mip_solver_t; #endif -} // namespace cuopt::math_optimization::mip +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/solver.cuh b/cpp/src/mip_heuristics/solver.cuh index 0d8fd35640..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::math_optimization::mip { +namespace cuopt::mathematical_optimization::mip { template class mip_solver_t { @@ -32,4 +32,4 @@ class mip_solver_t { timer_t timer_; }; -} // namespace cuopt::math_optimization::mip +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/solver_context.cuh b/cpp/src/mip_heuristics/solver_context.cuh index 269c298d01..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::math_optimization::mip { +namespace cuopt::mathematical_optimization::mip { template class branch_and_bound_t; } #include -namespace cuopt::math_optimization::mip { +namespace cuopt::mathematical_optimization::mip { template class diversity_manager_t; @@ -79,4 +79,4 @@ struct mip_solver_context_t { std::unique_ptr> symmetry; }; -} // namespace cuopt::math_optimization::mip +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/mip_heuristics/solver_settings.cu b/cpp/src/mip_heuristics/solver_settings.cu index f051f71520..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::math_optimization { +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::math_optimization +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/mip_heuristics/solver_solution.cu b/cpp/src/mip_heuristics/solver_solution.cu index 540c5edd7a..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::math_optimization { +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::math_optimization +} // 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 68cba1b1ab..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 math_optimization::mip { +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 math_optimization::mip +} // namespace mathematical_optimization::mip } // namespace cuopt diff --git a/cpp/src/mip_heuristics/utils.cuh b/cpp/src/mip_heuristics/utils.cuh index 45fb4e8acc..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::math_optimization::mip { +namespace cuopt::mathematical_optimization::mip { // TODO templatize as needed constexpr double default_cont_upper = std::numeric_limits::infinity(); @@ -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::math_optimization::mip +} // namespace cuopt::mathematical_optimization::mip diff --git a/cpp/src/pdlp/backend_selection.cpp b/cpp/src/pdlp/backend_selection.cpp index aa79915e7d..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::math_optimization { +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::math_optimization +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/pdlp/cpu_optimization_problem.cpp b/cpp/src/pdlp/cpu_optimization_problem.cpp index 7dc5856fd2..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::math_optimization { +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::math_optimization::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_); @@ -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::math_optimization::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::math_optimization +} // 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 fdde802405..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::math_optimization { +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::math_optimization +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/pdlp/cuopt_c.cpp b/cpp/src/pdlp/cuopt_c.cpp index 3412b477b1..66a21ca3a3 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,8 @@ #include #include -using namespace cuopt::math_optimization::io; -using namespace cuopt::math_optimization; +using namespace cuopt::mathematical_optimization::io; +using namespace cuopt::mathematical_optimization; class c_get_solution_callback_t : public cuopt::internals::get_solution_callback_t { public: @@ -824,7 +824,7 @@ 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); diff --git a/cpp/src/pdlp/cuopt_c_internal.hpp b/cpp/src/pdlp/cuopt_c_internal.hpp index ebfcbb8f45..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::math_optimization { +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::math_optimization +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/pdlp/cusparse_view.cu b/cpp/src/pdlp/cusparse_view.cu index c04f592bbd..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::math_optimization::pdlp { +namespace cuopt::mathematical_optimization::pdlp { // cusparse_sp_mat_descr_wrapper_t implementation template @@ -1542,4 +1542,4 @@ template void my_cusparsespmm_preprocess(cusparseHandle_t, #endif #endif -} // namespace cuopt::math_optimization::pdlp +} // namespace cuopt::mathematical_optimization::pdlp diff --git a/cpp/src/pdlp/cusparse_view.hpp b/cpp/src/pdlp/cusparse_view.hpp index bbd531d1e2..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::math_optimization::pdlp { +namespace cuopt::mathematical_optimization::pdlp { template class cusparse_sp_mat_descr_wrapper_t { @@ -373,4 +373,4 @@ void cusparse_spmvop_run(cusparseHandle_t handle, cudaStream_t stream); #endif // CUOPT_CUSPARSE_VER_12_7_UP -} // namespace cuopt::math_optimization::pdlp +} // 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 7d3beec97d..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::math_optimization::pdlp { +namespace cuopt::mathematical_optimization::pdlp { template struct weighted_square_op { @@ -972,4 +972,4 @@ INSTANTIATE(float) INSTANTIATE(double) #endif -} // namespace cuopt::math_optimization::pdlp +} // 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 6d2ee94188..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::math_optimization::pdlp { +namespace cuopt::mathematical_optimization::pdlp { template class pdlp_initial_scaling_strategy_t { @@ -125,4 +125,4 @@ class pdlp_initial_scaling_strategy_t { const pdlp::pdlp_hyper_params_t& hyper_params_; bool running_mip_; }; -} // namespace cuopt::math_optimization::pdlp +} // 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 1316c692d4..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::math_optimization::pdlp { +namespace cuopt::mathematical_optimization::pdlp { template struct SpMM_benchmarks_context_t { @@ -443,4 +443,4 @@ template int optimal_batch_size_handler( const optimization_problem_t& op_problem, int max_batch_size); #endif -} // namespace cuopt::math_optimization::pdlp +} // 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 53b2a2ff69..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::math_optimization::pdlp { +#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 ada49ea390..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::math_optimization { +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::math_optimization::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()); @@ -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::math_optimization::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::math_optimization +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/pdlp/pdhg.cu b/cpp/src/pdlp/pdhg.cu index fb8a18647a..89fc01faeb 100644 --- a/cpp/src/pdlp/pdhg.cu +++ b/cpp/src/pdlp/pdhg.cu @@ -38,7 +38,7 @@ #include #include -namespace cuopt::math_optimization::pdlp { +namespace cuopt::mathematical_optimization::pdlp { template pdhg_solver_t::pdhg_solver_t( @@ -1502,4 +1502,4 @@ template class pdhg_solver_t; template class pdhg_solver_t; #endif -} // namespace cuopt::math_optimization::pdlp +} // namespace cuopt::mathematical_optimization::pdlp diff --git a/cpp/src/pdlp/pdhg.hpp b/cpp/src/pdlp/pdhg.hpp index d5fad2f514..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,7 +23,7 @@ #include #include -namespace cuopt::math_optimization::pdlp { +namespace cuopt::mathematical_optimization::pdlp { template class pdhg_solver_t { public: @@ -152,4 +152,4 @@ class pdhg_solver_t { cuda::fast_mod_div batch_size_divisor_; }; -} // namespace cuopt::math_optimization::pdlp +} // namespace cuopt::mathematical_optimization::pdlp diff --git a/cpp/src/pdlp/pdlp.cu b/cpp/src/pdlp/pdlp.cu index 8f15e8f2c2..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/math_optimization/pdlp/solver_solution.hpp" +#include "cuopt/mathematical_optimization/pdlp/solver_solution.hpp" #include #include @@ -45,7 +45,7 @@ #include #include -namespace cuopt::math_optimization::pdlp { +namespace cuopt::mathematical_optimization::pdlp { // Templated wrapper for cuBLAS geam function // cublasSgeam for float, cublasDgeam for double @@ -3225,4 +3225,4 @@ template __global__ void compute_weights_initial_primal_weight_from_squared_norm const pdlp::pdlp_hyper_params_t hyper_params); #endif -} // namespace cuopt::math_optimization::pdlp +} // namespace cuopt::mathematical_optimization::pdlp diff --git a/cpp/src/pdlp/pdlp.cuh b/cpp/src/pdlp/pdlp.cuh index e4e9deee21..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::math_optimization::pdlp { +namespace cuopt::mathematical_optimization::pdlp { /** * @brief Solver for an optimization problem (Currently only linear program) to be solved, * pdlp_parameters and pdlp_internal_state @@ -248,4 +248,4 @@ class pdlp_solver_t { bool inside_mip_{false}; }; -} // namespace cuopt::math_optimization::pdlp +} // namespace cuopt::mathematical_optimization::pdlp diff --git a/cpp/src/pdlp/pdlp_constants.hpp b/cpp/src/pdlp/pdlp_constants.hpp index fe1c5d90d0..1651fd4212 100644 --- a/cpp/src/pdlp/pdlp_constants.hpp +++ b/cpp/src/pdlp/pdlp_constants.hpp @@ -9,7 +9,7 @@ #include -namespace cuopt::math_optimization::pdlp { +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::math_optimization::pdlp +} // 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 1711105f56..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::math_optimization { +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::math_optimization +} // 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 332afdc8e3..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,9 +13,9 @@ #include -#include +#include -namespace cuopt::math_optimization::pdlp { +namespace cuopt::mathematical_optimization::pdlp { template localized_duality_gap_container_t::localized_duality_gap_container_t( raft::handle_t const* handle_ptr, @@ -151,4 +151,4 @@ template struct localized_duality_gap_container_t; template struct localized_duality_gap_container_t; #endif -} // namespace cuopt::math_optimization::pdlp +} // 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 38f24deee9..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::math_optimization::pdlp { +namespace cuopt::mathematical_optimization::pdlp { template struct localized_duality_gap_container_t { public: @@ -77,4 +77,4 @@ struct localized_duality_gap_container_t { rmm::device_uvector primal_solution_tr_; rmm::device_uvector dual_solution_tr_; }; -} // namespace cuopt::math_optimization::pdlp +} // 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 11c7393e13..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,7 +50,7 @@ namespace cg = cooperative_groups; -namespace cuopt::math_optimization::pdlp { +namespace cuopt::mathematical_optimization::pdlp { template __global__ void solve_bound_constrained_trust_region_kernel( @@ -2539,4 +2539,4 @@ INSTANTIATE(float) INSTANTIATE(double) #endif -} // namespace cuopt::math_optimization::pdlp +} // 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 334a0866a0..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::math_optimization::pdlp { +namespace cuopt::mathematical_optimization::pdlp { template class pdlp_restart_strategy_t { public: @@ -411,4 +411,4 @@ bool is_cupdlpx_restart(const pdlp::pdlp_hyper_params_t& hyper_params) static_cast(pdlp_restart_strategy_t::restart_strategy_t::CUPDLPX_RESTART); } -} // namespace cuopt::math_optimization::pdlp +} // 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 c3aff1ebc4..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::math_optimization::pdlp { +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::math_optimization::pdlp +} // 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 51faa57f35..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::math_optimization::pdlp { +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::math_optimization::pdlp +} // namespace cuopt::mathematical_optimization::pdlp diff --git a/cpp/src/pdlp/saddle_point.cu b/cpp/src/pdlp/saddle_point.cu index 601777c6bb..9267a7ced6 100644 --- a/cpp/src/pdlp/saddle_point.cu +++ b/cpp/src/pdlp/saddle_point.cu @@ -15,7 +15,7 @@ #include -namespace cuopt::math_optimization::pdlp { +namespace cuopt::mathematical_optimization::pdlp { template saddle_point_state_t::saddle_point_state_t(raft::handle_t const* handle_ptr, @@ -178,4 +178,4 @@ template class saddle_point_state_t; template class saddle_point_state_t; #endif -} // namespace cuopt::math_optimization::pdlp +} // namespace cuopt::mathematical_optimization::pdlp diff --git a/cpp/src/pdlp/saddle_point.hpp b/cpp/src/pdlp/saddle_point.hpp index 99977f5718..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::math_optimization::pdlp { +namespace cuopt::mathematical_optimization::pdlp { /** * @brief Structure to hold the current solution to the saddle point problem * @@ -115,4 +115,4 @@ class saddle_point_state_t { rmm::device_uvector next_AtY_; }; -} // namespace cuopt::math_optimization::pdlp +} // namespace cuopt::mathematical_optimization::pdlp diff --git a/cpp/src/pdlp/solution_conversion.cu b/cpp/src/pdlp/solution_conversion.cu index e0127c9490..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::math_optimization { +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::math_optimization +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/pdlp/solve.cu b/cpp/src/pdlp/solve.cu index 633d2c1ad7..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::math_optimization { +namespace cuopt::mathematical_optimization { template extern rmm::device_uvector gpu_cast(const rmm::device_uvector& src, @@ -1009,7 +1009,7 @@ static void apply_batch_settings_overrides( return given_value == default_value ? override_value : given_value; }; - batch_settings.method = cuopt::math_optimization::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; @@ -1451,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::math_optimization::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) @@ -1955,7 +1955,7 @@ optimization_problem_solution_t solve_lp( std::max(1.0, std::min(0.1 * lp_timer.remaining_time(), 60.0)); presolver = std::make_unique>(); result = presolver->apply(op_problem, - cuopt::math_optimization::problem_category_t::LP, + cuopt::mathematical_optimization::problem_category_t::LP, settings.presolver, settings.dual_postsolve, settings.tolerances.absolute_primal_tolerance, @@ -1994,7 +1994,7 @@ optimization_problem_solution_t solve_lp( presolver->undo(empty_primal, empty_dual, empty_reduced_costs, - cuopt::math_optimization::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()); @@ -2065,7 +2065,7 @@ optimization_problem_solution_t solve_lp( presolver->undo(primal_solution, dual_solution, reduced_costs, - cuopt::math_optimization::problem_category_t::LP, + cuopt::mathematical_optimization::problem_category_t::LP, status_to_skip, settings.dual_postsolve, op_problem.get_handle_ptr()->get_stream()); @@ -2106,14 +2106,15 @@ optimization_problem_solution_t solve_lp( } template -cuopt::math_optimization::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::math_optimization::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::math_optimization::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) { @@ -2198,7 +2199,7 @@ cuopt::math_optimization::optimization_problem_t mps_data_model_to_opt template optimization_problem_solution_t solve_lp( raft::handle_t const* handle_ptr, - const cuopt::math_optimization::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) @@ -2303,7 +2304,7 @@ std::unique_ptr> solve_lp( \ template optimization_problem_solution_t solve_lp( \ raft::handle_t const* handle_ptr, \ - const cuopt::math_optimization::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); \ @@ -2330,7 +2331,7 @@ std::unique_ptr> solve_lp( \ template optimization_problem_solution_t batch_pdlp_solve( \ raft::handle_t const* handle_ptr, \ - const cuopt::math_optimization::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); \ @@ -2346,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::math_optimization::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 @@ -2357,4 +2358,4 @@ INSTANTIATE(float) INSTANTIATE(double) #endif -} // namespace cuopt::math_optimization +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/pdlp/solve.cuh b/cpp/src/pdlp/solve.cuh index af6fd4acc2..dd249a825d 100644 --- a/cpp/src/pdlp/solve.cuh +++ b/cpp/src/pdlp/solve.cuh @@ -7,13 +7,13 @@ #pragma once -#include +#include -#include +#include #include -namespace cuopt::math_optimization { +namespace cuopt::mathematical_optimization { namespace mip { template @@ -21,12 +21,13 @@ class problem_t; } // namespace mip template -cuopt::math_optimization::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::math_optimization::io::mps_data_model_t& data_model); + const cuopt::mathematical_optimization::io::mps_data_model_t& data_model); template -cuopt::math_optimization::optimization_problem_solution_t solve_lp_with_method( +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, @@ -82,8 +83,8 @@ cuopt::math_optimization::optimization_problem_solution_t solve_lp_wit * @endcode */ template -cuopt::math_optimization::optimization_problem_solution_t run_batch_pdlp( - cuopt::math_optimization::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::math_optimization::optimization_problem_solution_t run_batch_pd */ template size_t compute_optimal_batch_size( - const cuopt::math_optimization::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::math_optimization +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/pdlp/solver_settings.cu b/cpp/src/pdlp/solver_settings.cu index 78b45ef46a..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::math_optimization { +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::math_optimization +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/pdlp/solver_solution.cu b/cpp/src/pdlp/solver_solution.cu index 559a1604e3..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::math_optimization { +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::math_optimization +} // 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 802cf7bb7f..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::math_optimization::pdlp { +namespace cuopt::mathematical_optimization::pdlp { template adaptive_step_size_strategy_t::adaptive_step_size_strategy_t( @@ -585,4 +585,4 @@ INSTANTIATE(float) INSTANTIATE(double) #endif -} // namespace cuopt::math_optimization::pdlp +} // 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 b163a86088..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::math_optimization::pdlp { +namespace cuopt::mathematical_optimization::pdlp { template class adaptive_step_size_strategy_t { public: @@ -120,4 +120,4 @@ class adaptive_step_size_strategy_t { const std::vector& climber_strategies_; const pdlp::pdlp_hyper_params_t& hyper_params_; }; -} // namespace cuopt::math_optimization::pdlp +} // 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 fa484a79c5..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::math_optimization::pdlp { +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::math_optimization::pdlp +} // 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 ad9e1ee70b..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,7 +33,7 @@ #include -namespace cuopt::math_optimization::pdlp { +namespace cuopt::mathematical_optimization::pdlp { template convergence_information_t::convergence_information_t( raft::handle_t const* handle_ptr, @@ -1027,4 +1027,4 @@ template __global__ void compute_remaining_stats_kernel( int batch_size); #endif -} // namespace cuopt::math_optimization::pdlp +} // 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 28d800b721..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,7 +25,7 @@ #include #include -namespace cuopt::math_optimization::pdlp { +namespace cuopt::mathematical_optimization::pdlp { template class convergence_information_t { public: @@ -209,4 +209,4 @@ class convergence_information_t { const std::vector& climber_strategies_; const pdlp::pdlp_hyper_params_t& hyper_params_; }; -} // namespace cuopt::math_optimization::pdlp +} // 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 07fde352ba..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,7 +34,7 @@ #include #include -namespace cuopt::math_optimization::pdlp { +namespace cuopt::mathematical_optimization::pdlp { template infeasibility_information_t::infeasibility_information_t( raft::handle_t const* handle_ptr, @@ -769,4 +769,4 @@ template __global__ void compute_remaining_stats_kernel( typename infeasibility_information_t::view_t infeasibility_information_view); #endif -} // namespace cuopt::math_optimization::pdlp +} // 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 83ecd89866..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,7 +23,7 @@ #include #include -namespace cuopt::math_optimization::pdlp { +namespace cuopt::mathematical_optimization::pdlp { template class infeasibility_information_t { public: @@ -136,4 +136,4 @@ class infeasibility_information_t { const std::vector& climber_strategies_; const pdlp::pdlp_hyper_params_t& hyper_params_; }; -} // namespace cuopt::math_optimization::pdlp +} // 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 e08748a29a..1218c60fa4 100644 --- a/cpp/src/pdlp/termination_strategy/termination_strategy.cu +++ b/cpp/src/pdlp/termination_strategy/termination_strategy.cu @@ -12,15 +12,15 @@ #include -#include -#include -#include +#include +#include +#include #include #include #include -namespace cuopt::math_optimization::pdlp { +namespace cuopt::mathematical_optimization::pdlp { template pdlp_termination_strategy_t::pdlp_termination_strategy_t( raft::handle_t const* handle_ptr, @@ -710,4 +710,4 @@ INSTANTIATE(double) #undef INSTANTIATE -} // namespace cuopt::math_optimization::pdlp +} // 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 c1347c3c39..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,7 +27,7 @@ #include -namespace cuopt::math_optimization::pdlp { +namespace cuopt::mathematical_optimization::pdlp { template class pdlp_termination_strategy_t { public: @@ -235,4 +235,4 @@ class pdlp_termination_strategy_t { const std::vector& climber_strategies_; }; -} // namespace cuopt::math_optimization::pdlp +} // namespace cuopt::mathematical_optimization::pdlp diff --git a/cpp/src/pdlp/translate.hpp b/cpp/src/pdlp/translate.hpp index 913fbaffeb..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,7 +23,7 @@ #include #include -namespace cuopt::math_optimization { +namespace cuopt::mathematical_optimization { template static simplex::user_problem_t cuopt_problem_to_user_problem( @@ -86,9 +86,10 @@ static simplex::user_problem_t cuopt_problem_to_user_problem( auto variable_types = problem.get_variable_types_host(); for (int j = 0; j < n; ++j) { - user_problem.var_types[j] = variable_types[j] == var_t::CONTINUOUS - ? cuopt::math_optimization::simplex::variable_type_t::CONTINUOUS - : cuopt::math_optimization::simplex::variable_type_t::INTEGER; + user_problem.var_types[j] = + variable_types[j] == var_t::CONTINUOUS + ? 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(); @@ -179,9 +180,10 @@ static simplex::user_problem_t cuopt_problem_to_user_problem( auto model_variable_types = cuopt::host_copy(model.variable_types, handle_ptr->get_stream()); for (int j = 0; j < n; ++j) { - user_problem.var_types[j] = model_variable_types[j] == var_t::CONTINUOUS - ? cuopt::math_optimization::simplex::variable_type_t::CONTINUOUS - : cuopt::math_optimization::simplex::variable_type_t::INTEGER; + user_problem.var_types[j] = + model_variable_types[j] == var_t::CONTINUOUS + ? cuopt::mathematical_optimization::simplex::variable_type_t::CONTINUOUS + : cuopt::mathematical_optimization::simplex::variable_type_t::INTEGER; } user_problem.Q_offsets = model.Q_offsets; @@ -302,8 +304,8 @@ static simplex::user_problem_t cuopt_optimization_problem_to_user_prob user_problem.var_types[j] = model_variable_types.empty() || model_variable_types[static_cast(j)] == var_t::CONTINUOUS - ? cuopt::math_optimization::simplex::variable_type_t::CONTINUOUS - : cuopt::math_optimization::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(); @@ -412,4 +414,4 @@ void translate_to_crossover_problem(const mip::problem_t& problem, CUOPT_LOG_DEBUG("Finished translating"); } -} // namespace cuopt::math_optimization +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/pdlp/utilities/cython_solve.cu b/cpp/src/pdlp/utilities/cython_solve.cu index cb7e72606d..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::math_optimization::lp_solution_interface_t* call_solve_lp( - cuopt::math_optimization::optimization_problem_interface_t* problem_interface, - cuopt::math_optimization::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::math_optimization::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::math_optimization::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,57 +71,59 @@ cuopt::math_optimization::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::math_optimization::mip_solution_interface_t* call_solve_mip( - cuopt::math_optimization::optimization_problem_interface_t* problem_interface, - cuopt::math_optimization::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::math_optimization::problem_category_t::MIP) or + cuopt::mathematical_optimization::problem_category_t::MIP) or (problem_interface->get_problem_category() == - cuopt::math_optimization::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::math_optimization::solve_mip(problem_interface, solver_settings); + auto solution_interface = + 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::math_optimization::io::data_model_view_t* data_model, - cuopt::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::optimization_problem_t(&handle_); - cuopt::math_optimization::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() == math_optimization::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 = math_optimization::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. @@ -142,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 = math_optimization::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_); @@ -174,26 +177,26 @@ std::unique_ptr call_solve( } else { // CPU memory backend: pure data container, no CUDA resources needed - auto cpu_problem = cuopt::math_optimization::cpu_optimization_problem_t(); - cuopt::math_optimization::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() == math_optimization::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 = math_optimization::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 = math_optimization::problem_category_t::MIP; + response.problem_type = mathematical_optimization::problem_category_t::MIP; } } @@ -201,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; @@ -237,8 +241,8 @@ static int compute_max_thread( } std::pair>, double> solve_batch_remote( - std::vector*> data_models, - cuopt::math_optimization::solver_settings_t* solver_settings) + std::vector*> data_models, + cuopt::mathematical_optimization::solver_settings_t* solver_settings) { cuopt_expects( false, @@ -249,12 +253,12 @@ std::pair>, double> solve_batch_remote } std::pair>, double> call_batch_solve( - std::vector*> data_models, - cuopt::math_optimization::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::math_optimization::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 a8399084c3..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::math_optimization::pdlp { +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::math_optimization::pdlp +} // 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 be9d2252ea..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::math_optimization::pdlp { +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::math_optimization::pdlp +} // namespace cuopt::mathematical_optimization::pdlp diff --git a/cpp/src/pdlp/utilities/problem_checking.cu b/cpp/src/pdlp/utilities/problem_checking.cu index 6307e2f283..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::math_optimization { +namespace cuopt::mathematical_optimization { template void problem_checking_t::check_csr_representation( @@ -386,4 +386,4 @@ INSTANTIATE(double) #undef INSTANTIATE -} // namespace cuopt::math_optimization +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/pdlp/utilities/problem_checking.cuh b/cpp/src/pdlp/utilities/problem_checking.cuh index 15f7423e8c..217080356c 100644 --- a/cpp/src/pdlp/utilities/problem_checking.cuh +++ b/cpp/src/pdlp/utilities/problem_checking.cuh @@ -6,16 +6,16 @@ /* clang-format on */ #pragma once -#include -#include -#include +#include +#include +#include namespace rmm { template class device_uvector; } // namespace rmm -namespace cuopt::math_optimization { +namespace cuopt::mathematical_optimization { namespace mip { template @@ -48,4 +48,4 @@ class problem_checking_t { const mip_solver_settings_t& settings); }; -} // namespace cuopt::math_optimization +} // namespace cuopt::mathematical_optimization diff --git a/cpp/src/pdlp/utils.cuh b/cpp/src/pdlp/utils.cuh index 1dd22df1cb..adc1432b39 100644 --- a/cpp/src/pdlp/utils.cuh +++ b/cpp/src/pdlp/utils.cuh @@ -30,7 +30,7 @@ #include #include -namespace cuopt::math_optimization::pdlp { +namespace cuopt::mathematical_optimization::pdlp { template DI f_t deterministic_block_reduce(raft::device_span shared, f_t val) @@ -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::math_optimization::pdlp +} // namespace cuopt::mathematical_optimization::pdlp 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 d5bf854d42..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::math_optimization::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::math_optimization::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 72785e3bad..33d5392a9b 100644 --- a/cpp/tests/dual_simplex/unit_tests/solve.cpp +++ b/cpp/tests/dual_simplex/unit_tests/solve.cpp @@ -16,15 +16,15 @@ #include #include -#include +#include #include -namespace cuopt::math_optimization::simplex::test { +namespace cuopt::mathematical_optimization::simplex::test { TEST(dual_simplex, chess_set) { cuopt::init_logger_t log("", true); - namespace simplex = cuopt::math_optimization::simplex; + namespace simplex = cuopt::mathematical_optimization::simplex; raft::handle_t handle{}; simplex::user_problem_t user_problem(&handle); // maximize 5*xs + 20*xl @@ -109,7 +109,7 @@ TEST(dual_simplex, burglar) // take[i] binary for all i raft::handle_t handle{}; - cuopt::math_optimization::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::math_optimization::simplex::variable_type_t::INTEGER; + user_problem.var_types[j] = cuopt::mathematical_optimization::simplex::variable_type_t::INTEGER; } - cuopt::math_optimization::simplex::simplex_solver_settings_t settings; + cuopt::mathematical_optimization::simplex::simplex_solver_settings_t settings; std::vector solution(num_items); - EXPECT_EQ((cuopt::math_optimization::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::math_optimization::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; @@ -232,16 +233,17 @@ TEST(dual_simplex, empty_columns) 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::math_optimization::simplex::variable_type_t::CONTINUOUS; + user_problem.var_types[j] = + cuopt::mathematical_optimization::simplex::variable_type_t::CONTINUOUS; } - cuopt::math_optimization::simplex::simplex_solver_settings_t settings; + cuopt::mathematical_optimization::simplex::simplex_solver_settings_t settings; - cuopt::math_optimization::simplex::lp_solution_t solution(user_problem.num_rows, - user_problem.num_cols); - EXPECT_EQ( - (cuopt::math_optimization::simplex::solve_linear_program(user_problem, settings, solution)), - cuopt::math_optimization::simplex::lp_status_t::OPTIMAL); + cuopt::mathematical_optimization::simplex::lp_solution_t solution( + user_problem.num_rows, user_problem.num_cols); + EXPECT_EQ((cuopt::mathematical_optimization::simplex::solve_linear_program( + user_problem, settings, solution)), + 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]; @@ -267,7 +269,7 @@ TEST(dual_simplex, dual_variable_greater_than) // x0, x1 >= 0 raft::handle_t handle{}; - cuopt::math_optimization::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; @@ -330,4 +332,4 @@ TEST(dual_simplex, dual_variable_greater_than) EXPECT_NEAR(solution.z[1], 0.0, 1e-6); } -} // namespace cuopt::math_optimization::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 ecad27016c..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::math_optimization::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,7 +42,7 @@ static void init_handler(const raft::handle_t* handle_ptr) TEST(barrier, chess_set) { cuopt::init_logger_t log("", true); - namespace simplex = cuopt::math_optimization::simplex; + namespace simplex = cuopt::mathematical_optimization::simplex; raft::handle_t handle{}; init_handler(&handle); simplex::user_problem_t user_problem(&handle); @@ -119,7 +119,7 @@ TEST(barrier, dual_variable_greater_than) raft::handle_t handle{}; init_handler(&handle); - cuopt::math_optimization::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; @@ -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::math_optimization::io::read_mps(path); + auto mps_data = cuopt::mathematical_optimization::io::read_mps(path); - auto settings = cuopt::math_optimization::pdlp_solver_settings_t{}; + auto settings = cuopt::mathematical_optimization::pdlp_solver_settings_t{}; - auto solution = cuopt::math_optimization::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::math_optimization::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 60fa09bf84..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 808353023f..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::math_optimization::pdlp { +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::math_optimization::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::math_optimization::pdlp; + 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 (!cuopt::math_optimization::pdlp::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 80ae599ae5..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 a2a2f5e2d5..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::math_optimization; +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 e4738e5c44..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::math_optimization { +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::math_optimization +} // 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 cf7970b692..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::math_optimization; -using cuopt::math_optimization::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::math_optimization::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 f82545883d..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::math_optimization::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 ea38de6016..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::math_optimization::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::math_optimization::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 c57a34715c..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::math_optimization::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::math_optimization::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 057d3e235f..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::math_optimization::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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::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::math_optimization::pdlp; + 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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::method_t::PDLP; - settings.pdlp_precision = cuopt::math_optimization::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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::method_t::PDLP; - settings_mixed.pdlp_precision = cuopt::math_optimization::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::math_optimization::method_t::PDLP; - settings_full.pdlp_precision = cuopt::math_optimization::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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::method_t::Concurrent; - settings.presolver = cuopt::math_optimization::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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::io::read_mps(path, true); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path, true); - cuopt::math_optimization::pdlp_solver_settings_t settings = - cuopt::math_optimization::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::math_optimization::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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::io::read_mps(path, true); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path, true); - cuopt::math_optimization::pdlp_solver_settings_t settings = - cuopt::math_optimization::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::math_optimization::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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::io::read_mps(path); + cuopt::mathematical_optimization::io::mps_data_model_t op_problem = + cuopt::mathematical_optimization::io::read_mps(path); - cuopt::math_optimization::pdlp_solver_settings_t settings = - cuopt::math_optimization::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::math_optimization::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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::pdlp_solver_mode_t::Stable3, - cuopt::math_optimization::pdlp_solver_mode_t::Stable2, - cuopt::math_optimization::pdlp_solver_mode_t::Stable1, - cuopt::math_optimization::pdlp_solver_mode_t::Methodical1, - cuopt::math_optimization::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::math_optimization::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::math_optimization::io::mps_data_model_t mps_data_model = - cuopt::math_optimization::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::math_optimization::mps_data_model_to_optimization_problem( - &handle_, mps_data_model); - cuopt::math_optimization::mip::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::math_optimization::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::math_optimization::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::math_optimization::pdlp::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::math_optimization::pdlp::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::math_optimization::pdlp::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::math_optimization::pdlp::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::math_optimization::pdlp::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::math_optimization::pdlp::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::math_optimization::pdlp::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::math_optimization::pdlp::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::math_optimization::pdlp::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::math_optimization::pdlp::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::math_optimization::pdlp::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::math_optimization::pdlp::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::math_optimization::pdlp::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::math_optimization::pdlp::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::math_optimization::pdlp::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::math_optimization::pdlp::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::math_optimization::pdlp::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::math_optimization::pdlp::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::math_optimization::io::mps_data_model_t mps_data_model = - cuopt::math_optimization::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::math_optimization::mps_data_model_to_optimization_problem( - &handle_, mps_data_model); - cuopt::math_optimization::mip::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::math_optimization::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::math_optimization::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::math_optimization::pdlp::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::math_optimization::pdlp::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::math_optimization::pdlp::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::math_optimization::pdlp::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::math_optimization::mip::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::math_optimization::method_t::PDLP; - solver_settings.pdlp_solver_mode = cuopt::math_optimization::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::math_optimization::pdlp::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::math_optimization::pdlp::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::math_optimization::method_t::PDLP; - solver_settings.pdlp_solver_mode = cuopt::math_optimization::pdlp_solver_mode_t::Stable2; - cuopt::math_optimization::io::mps_data_model_t op_problem1 = - cuopt::math_optimization::io::read_mps(path); - cuopt::math_optimization::io::mps_data_model_t op_problem2 = - cuopt::math_optimization::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::math_optimization::pdlp_solver_mode_t::Stable1; - solver_settings.method = cuopt::math_optimization::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::math_optimization::io::mps_data_model_t op_problem1 = - cuopt::math_optimization::io::read_mps(path); - cuopt::math_optimization::io::mps_data_model_t op_problem2 = - cuopt::math_optimization::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::math_optimization::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; - cuopt::math_optimization::io::mps_data_model_t op_problem1 = - cuopt::math_optimization::io::read_mps(path); - cuopt::math_optimization::io::mps_data_model_t op_problem2 = - cuopt::math_optimization::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::math_optimization::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; - cuopt::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; - cuopt::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; - cuopt::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::io::read_mps(path); - auto climber1_problem = cuopt::math_optimization::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::math_optimization::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; solver_settings.presolver = presolver_t::None; - cuopt::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::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::math_optimization::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; - cuopt::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::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,18 +1888,19 @@ 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::math_optimization::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::math_optimization::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; solver_settings.presolver = presolver_t::None; - cuopt::math_optimization::io::mps_data_model_t mps_data_model = - cuopt::math_optimization::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::math_optimization::mps_data_model_to_optimization_problem(&handle, - mps_data_model); + cuopt::mathematical_optimization::mps_data_model_to_optimization_problem( + &handle, mps_data_model); // Solving from scratch until 1e-2 optimization_problem_solution_t solution1 = solve_lp(op_problem1, solver_settings); @@ -1877,15 +1908,15 @@ 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::math_optimization::mps_data_model_to_optimization_problem(&handle, - mps_data_model); + 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::math_optimization::mps_data_model_to_optimization_problem(&handle, - mps_data_model); + 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::math_optimization::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::math_optimization::method_t::PDLP; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; solver_settings.presolver = presolver_t::None; - cuopt::math_optimization::io::mps_data_model_t mps_data_model = - cuopt::math_optimization::io::read_mps(path); - auto op_problem = cuopt::math_optimization::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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::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::math_optimization::pdlp_solver_settings_t settings = - cuopt::math_optimization::pdlp_solver_settings_t{}; - settings.method = cuopt::math_optimization::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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::method_t::PDLP; - solver_settings.pdlp_solver_mode = cuopt::math_optimization::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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::method_t::PDLP; - solver_settings.pdlp_solver_mode = pdlp_solver_mode_t::Stable3; - solver_settings.presolver = cuopt::math_optimization::presolver_t::None; + auto solver_settings = pdlp_solver_settings_t{}; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; + solver_settings.pdlp_solver_mode = pdlp_solver_mode_t::Stable3; + 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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::method_t::PDLP; - solver_settings.pdlp_solver_mode = pdlp_solver_mode_t::Stable3; - solver_settings.presolver = cuopt::math_optimization::presolver_t::None; + auto solver_settings = pdlp_solver_settings_t{}; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; + solver_settings.pdlp_solver_mode = pdlp_solver_mode_t::Stable3; + 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::math_optimization::mps_data_model_to_optimization_problem( - &handle_, op_problem); - auto batch_sol = cuopt::math_optimization::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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::method_t::PDLP; - solver_settings.pdlp_solver_mode = pdlp_solver_mode_t::Stable3; - solver_settings.presolver = cuopt::math_optimization::presolver_t::None; + auto solver_settings = pdlp_solver_settings_t{}; + solver_settings.method = cuopt::mathematical_optimization::method_t::PDLP; + solver_settings.pdlp_solver_mode = pdlp_solver_mode_t::Stable3; + 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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::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::math_optimization::mps_data_model_to_optimization_problem( - &handle_, op_problem); - auto batch_solution = cuopt::math_optimization::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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::method_t::PDLP; - solver_settings.pdlp_precision = cuopt::math_optimization::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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::method_t::PDLP; - solver_settings.pdlp_precision = cuopt::math_optimization::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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::method_t::Concurrent; - solver_settings.pdlp_precision = cuopt::math_optimization::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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::method_t::PDLP; - solver_settings.pdlp_precision = cuopt::math_optimization::pdlp_precision_t::SinglePrecision; - solver_settings.presolver = cuopt::math_optimization::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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::method_t::PDLP; - solver_settings.pdlp_precision = cuopt::math_optimization::pdlp_precision_t::SinglePrecision; - solver_settings.presolver = cuopt::math_optimization::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::math_optimization::mip; + 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::math_optimization::mip; + using namespace cuopt::mathematical_optimization::mip; const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/afiro_original.mps"); - cuopt::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::mip; + using namespace cuopt::mathematical_optimization::mip; const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/afiro_original.mps"); - cuopt::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::mip; + using namespace cuopt::mathematical_optimization::mip; const raft::handle_t handle_{}; auto path = make_path_absolute("linear_programming/afiro_original.mps"); - cuopt::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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,8 +4515,9 @@ 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::math_optimization::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); @@ -4474,8 +4528,8 @@ TEST(pdlp_class, batch_bound_objective_rescaling_factors_match_input_expansion) hyper_params.do_pock_chambolle_scaling = false; hyper_params.bound_objective_rescaling = true; - cuopt::math_optimization::mip::problem_t problem(gpu_op); - cuopt::math_optimization::pdlp::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::math_optimization::io::mps_data_model_t op_problem = - cuopt::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::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 a6321f3445..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::math_optimization { +namespace cuopt::mathematical_optimization { -cuopt::math_optimization::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::math_optimization::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::math_optimization +} // 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 b1a96655eb..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::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::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 57e1741cb7..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::math_optimization { +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::math_optimization::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::math_optimization +} // 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 4f75f53302..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::math_optimization { +namespace cuopt::mathematical_optimization { TEST(SolverSettingsTest, TestSetGet) { - cuopt::math_optimization::pdlp_solver_settings_t solver_settings = - cuopt::math_optimization::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::math_optimization::pdlp_solver_mode_t::Stable3; - auto Fast1 = cuopt::math_optimization::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::math_optimization::pdlp_solver_settings_t solver_settings = - cuopt::math_optimization::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::math_optimization::pdlp_solver_settings_t solver_settings = - cuopt::math_optimization::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::math_optimization +} // 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 dffc0dbff7..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::math_optimization::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::math_optimization::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::math_optimization::io::mps_data_model_t& mps_data_model, - const cuopt::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::io::mps_data_model_t& mps_data_model, - cuopt::math_optimization::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::math_optimization::optimization_problem_solution_t solve const std::vector& per_climber_objective_offsets = {}, bool use_direct_api = false) { - auto gpu_op = cuopt::math_optimization::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::math_optimization::optimization_problem_solution_t solve settings.generate_batch_primal_dual_solution = true; settings.fixed_batch_size = batch_size; - if (use_direct_api) { return cuopt::math_optimization::solve_lp(gpu_op, settings, false); } - return cuopt::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::pdlp::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::math_optimization::pdlp::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::math_optimization::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 316996dbbb..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::math_optimization::test { +namespace cuopt::mathematical_optimization::test { void init_handler(const raft::handle_t* handle_ptr) { @@ -45,8 +45,8 @@ 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::math_optimization::io::mps_data_model_t problem = - cuopt::math_optimization::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); @@ -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::math_optimization::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::math_optimization::test +} // namespace cuopt::mathematical_optimization::test diff --git a/cpp/tests/mip/cuts_test.cu b/cpp/tests/mip/cuts_test.cu index 52a1802a47..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::math_optimization::test { +namespace cuopt::mathematical_optimization::test { namespace { @@ -169,7 +169,8 @@ 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::math_optimization::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"); @@ -1506,4 +1507,4 @@ TEST(cuts, flow_cover_generates_valid_single_node_flow_cut) EXPECT_GT(generated_cuts, 0); } -} // namespace cuopt::math_optimization::test +} // namespace cuopt::mathematical_optimization::test diff --git a/cpp/tests/mip/determinism_test.cu b/cpp/tests/mip/determinism_test.cu index 1dadc9bee1..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::math_optimization::test { +namespace cuopt::mathematical_optimization::test { namespace { @@ -246,4 +246,4 @@ INSTANTIATE_TEST_SUITE_P( return name + "_threads" + std::to_string(threads); }); -} // namespace cuopt::math_optimization::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 d82e48b066..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::math_optimization::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::math_optimization::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::math_optimization::io::mps_data_model_t problem2 = - cuopt::math_optimization::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::math_optimization::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 4dd404fa1d..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::math_optimization::test { +namespace cuopt::mathematical_optimization::test { void init_handler(const raft::handle_t* handle_ptr) { @@ -60,8 +60,8 @@ 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::math_optimization::io::mps_data_model_t mps_problem = - cuopt::math_optimization::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); @@ -128,8 +128,8 @@ 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::math_optimization::io::mps_data_model_t mps_problem = - cuopt::math_optimization::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); @@ -212,4 +212,4 @@ TEST(mip_solve, elim_var_remap_solution_test) } } -} // namespace cuopt::math_optimization::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 3ed12e9b6a..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::math_optimization::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::math_optimization::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 155fb9126b..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::math_optimization::test { +namespace cuopt::mathematical_optimization::test { void init_handler(const raft::handle_t* handle_ptr) { @@ -68,8 +68,8 @@ 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::math_optimization::io::mps_data_model_t mps_problem = - cuopt::math_optimization::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); @@ -259,4 +259,4 @@ TEST(mip_solve, feasibility_jump_obj_runoff_test) } } -} // namespace cuopt::math_optimization::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 5a8149d125..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::math_optimization::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::math_optimization::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 282ac8788d..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::math_optimization::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::math_optimization::io::mps_data_model_t& op_problem, - const cuopt::math_optimization::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::math_optimization::io::mps_data_model_t mps_problem = - cuopt::math_optimization::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::math_optimization::io::mps_data_model_t mps_problem = - cuopt::math_optimization::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::math_optimization::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 bef7702584..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::math_optimization::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::math_optimization::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::math_optimization::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 fd2a9b4338..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::math_optimization::test { +namespace cuopt::mathematical_optimization::test { inline auto make_async() { return rmm::mr::cuda_async_memory_resource(); } @@ -121,8 +121,8 @@ 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::math_optimization::io::mps_data_model_t mps_problem = - cuopt::math_optimization::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); @@ -168,4 +168,4 @@ TEST(presolve, multi_probe) } } -} // namespace cuopt::math_optimization::test +} // namespace cuopt::mathematical_optimization::test diff --git a/cpp/tests/mip/mip_utils.cuh b/cpp/tests/mip/mip_utils.cuh index 1ee9803ae9..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::math_optimization::test { +namespace cuopt::mathematical_optimization::test { static void test_variable_bounds( - const cuopt::math_optimization::io::mps_data_model_t& problem, + const cuopt::mathematical_optimization::io::mps_data_model_t& problem, const rmm::device_uvector& solution, - const cuopt::math_optimization::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::math_optimization::io::mps_data_model_t& problem, + const cuopt::mathematical_optimization::io::mps_data_model_t& problem, const std::vector& solution, - const cuopt::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::io::mps_data_model_t problem = - cuopt::math_optimization::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::math_optimization::test +} // namespace cuopt::mathematical_optimization::test diff --git a/cpp/tests/mip/miplib_test.cu b/cpp/tests/mip/miplib_test.cu index 510076004f..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/math_optimization/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::math_optimization::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::math_optimization::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::math_optimization::io::mps_data_model_t problem = - cuopt::math_optimization::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::math_optimization::io::mps_data_model_t problem = - cuopt::math_optimization::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::math_optimization::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 723bb717a9..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::math_optimization::test { +namespace cuopt::mathematical_optimization::test { inline auto make_async() { return rmm::mr::cuda_async_memory_resource(); } @@ -143,8 +143,8 @@ 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::math_optimization::io::mps_data_model_t mps_problem = - cuopt::math_optimization::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); @@ -200,4 +200,4 @@ TEST(presolve, multi_probe) } } -} // namespace cuopt::math_optimization::test +} // namespace cuopt::mathematical_optimization::test diff --git a/cpp/tests/mip/presolve_test.cu b/cpp/tests/mip/presolve_test.cu index ca357b814e..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,19 +27,19 @@ #include #include -namespace cuopt::math_optimization::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::math_optimization::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 result = presolver->apply(op_problem, - cuopt::math_optimization::problem_category_t::MIP, - cuopt::math_optimization::presolver_t::Papilo, + cuopt::mathematical_optimization::problem_category_t::MIP, + cuopt::mathematical_optimization::presolver_t::Papilo, false, 1e-6, 1e-12, @@ -63,4 +63,4 @@ TEST(problem, find_implied_integers) ((int)mip::problem_t::var_flags_t::VAR_IMPLIED_INTEGER)); } -} // namespace cuopt::math_optimization::test +} // namespace cuopt::mathematical_optimization::test diff --git a/cpp/tests/mip/problem_test.cu b/cpp/tests/mip/problem_test.cu index 477ff24ea3..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::math_optimization::test { +namespace cuopt::mathematical_optimization::test { -namespace lp = cuopt::math_optimization; -namespace dtl = cuopt::math_optimization::mip; +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) @@ -205,7 +205,7 @@ TEST(problem, run_small_tests) } } -namespace ds = cuopt::math_optimization::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::math_optimization::mip::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::math_optimization::mip::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::math_optimization::mip::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::math_optimization::mip::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::math_optimization::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 a7e6650730..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/math_optimization/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::math_optimization::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::math_optimization::test +} // namespace cuopt::mathematical_optimization::test diff --git a/cpp/tests/mip/server_test.cu b/cpp/tests/mip/server_test.cu index 898d42a4fc..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::math_optimization::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::math_optimization::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::math_optimization::solve_lp(&handle, problem, settings); + auto result = cuopt::mathematical_optimization::solve_lp(&handle, problem, settings); EXPECT_EQ(result.get_termination_status(), - cuopt::math_optimization::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::math_optimization::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::math_optimization::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::math_optimization::mip_termination_status_t::FeasibleFound), + cuopt::mathematical_optimization::mip_termination_status_t::FeasibleFound), std::make_tuple(false, CUOPT_MIP_SCALING_ON, false, - cuopt::math_optimization::mip_termination_status_t::Optimal), + cuopt::mathematical_optimization::mip_termination_status_t::Optimal), std::make_tuple(true, CUOPT_MIP_SCALING_OFF, true, - cuopt::math_optimization::mip_termination_status_t::FeasibleFound), + cuopt::mathematical_optimization::mip_termination_status_t::FeasibleFound), std::make_tuple(false, CUOPT_MIP_SCALING_OFF, false, - cuopt::math_optimization::mip_termination_status_t::Optimal))); + cuopt::mathematical_optimization::mip_termination_status_t::Optimal))); -} // namespace cuopt::math_optimization::test +} // namespace cuopt::mathematical_optimization::test diff --git a/cpp/tests/mip/termination_test.cu b/cpp/tests/mip/termination_test.cu index d7d18cae43..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::math_optimization::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::math_optimization::test +} // namespace cuopt::mathematical_optimization::test diff --git a/cpp/tests/mip/unit_test.cu b/cpp/tests/mip/unit_test.cu index 02b2e3404f..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::math_optimization::test { +namespace cuopt::mathematical_optimization::test { io::mps_data_model_t create_std_lp_problem() { @@ -82,17 +82,17 @@ Subject To End )LP"); - cuopt::math_optimization::pdlp_solver_settings_t settings{}; + cuopt::mathematical_optimization::pdlp_solver_settings_t settings{}; settings.set_optimality_tolerance(1e-2); - settings.method = cuopt::math_optimization::method_t::PDLP; + settings.method = cuopt::mathematical_optimization::method_t::PDLP; settings.time_limit = 5; // Solve - auto result = cuopt::math_optimization::solve_lp(&handle, problem, settings); + auto result = cuopt::mathematical_optimization::solve_lp(&handle, problem, settings); // Check results EXPECT_EQ(result.get_termination_status(), - cuopt::math_optimization::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::math_optimization::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::math_optimization::presolver_t::None; + settings.presolver = cuopt::mathematical_optimization::presolver_t::None; - auto result = cuopt::math_optimization::solve_lp(&handle, problem, settings); + auto result = cuopt::mathematical_optimization::solve_lp(&handle, problem, settings); EXPECT_EQ(result.get_termination_status(), - cuopt::math_optimization::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::math_optimization::mip_solver_settings_t settings{}; + cuopt::mathematical_optimization::mip_solver_settings_t settings{}; settings.time_limit = 5; - settings.presolver = cuopt::math_optimization::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::math_optimization::solve_mip(&handle, problem, settings); + auto result = cuopt::mathematical_optimization::solve_mip(&handle, problem, settings); EXPECT_EQ(result.get_termination_status(), - cuopt::math_optimization::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::math_optimization::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::math_optimization::presolver_t::None; + settings.presolver = cuopt::mathematical_optimization::presolver_t::None; - auto result = cuopt::math_optimization::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::math_optimization::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::math_optimization::presolver_t::None; + settings.presolver = cuopt::mathematical_optimization::presolver_t::None; - auto result = cuopt::math_optimization::solve_mip(&handle, problem, settings); + auto result = cuopt::mathematical_optimization::solve_mip(&handle, problem, settings); EXPECT_EQ(result.get_termination_status(), - cuopt::math_optimization::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::math_optimization::mip_termination_status_t::Optimal), - std::make_tuple(false, - CUOPT_MIP_SCALING_ON, - false, - cuopt::math_optimization::mip_termination_status_t::Optimal), - std::make_tuple(true, - CUOPT_MIP_SCALING_OFF, - true, - cuopt::math_optimization::mip_termination_status_t::Optimal), - std::make_tuple(false, - CUOPT_MIP_SCALING_OFF, - false, - cuopt::math_optimization::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 @@ -337,4 +338,4 @@ TEST(ScalingIntegrity, NoObjectiveScalingPreservesIntegerCoefficients) << " integer coefficients lost integrality after scaling (no-obj mode)"; } -} // namespace cuopt::math_optimization::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 b21cb37761..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::math_optimization { +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::math_optimization +} // 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 31618a8394..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::math_optimization::var_t const var_types_host[] = { - cuopt::math_optimization::var_t::CONTINUOUS, cuopt::math_optimization::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::math_optimization::var_t const var_types_host[] = { - cuopt::math_optimization::var_t::CONTINUOUS, - cuopt::math_optimization::var_t::CONTINUOUS, - cuopt::math_optimization::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::math_optimization { +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::math_optimization +} // 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 1dec3aa956..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::math_optimization { +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::math_optimization +} // 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 8d6b4de9da..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::math_optimization { +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::math_optimization +} // namespace cuopt::mathematical_optimization diff --git a/cpp/tests/socp/general_quadratic_test.cu b/cpp/tests/socp/general_quadratic_test.cu index 7639640bf0..0485482c9f 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,7 @@ #include #include -namespace cuopt::math_optimization::barrier::test { +namespace cuopt::mathematical_optimization::barrier::test { using i_t = int; using f_t = double; @@ -46,7 +46,7 @@ TEST(general_quadratic, dense_pd_2x2_solve) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::math_optimization::simplex; + using namespace cuopt::mathematical_optimization::simplex; user_problem_t user_problem(&handle); // Need at least one linear constraint for the barrier solver. @@ -159,7 +159,7 @@ TEST(general_quadratic, rejects_non_convex) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::math_optimization::simplex; + using namespace cuopt::mathematical_optimization::simplex; user_problem_t user_problem(&handle); constexpr int m = 0; @@ -217,7 +217,7 @@ TEST(general_quadratic, rank_deficient_psd_solve) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::math_optimization::simplex; + using namespace cuopt::mathematical_optimization::simplex; user_problem_t user_problem(&handle); constexpr int m = 1; @@ -302,7 +302,7 @@ TEST(general_quadratic, with_inequality_constraint) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::math_optimization::simplex; + using namespace cuopt::mathematical_optimization::simplex; user_problem_t user_problem(&handle); // 2 constraints: one equality, one inequality @@ -400,7 +400,7 @@ TEST(general_quadratic, least_squares_b_in_range) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::math_optimization::simplex; + using namespace cuopt::mathematical_optimization::simplex; user_problem_t user_problem(&handle); // Variables: x0, x1, u (u = t - b^T*b = t - 5). @@ -519,7 +519,7 @@ TEST(general_quadratic, least_squares_b_not_in_range) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::math_optimization::simplex; + using namespace cuopt::mathematical_optimization::simplex; user_problem_t user_problem(&handle); constexpr int m = 1; @@ -592,7 +592,7 @@ TEST(general_quadratic, soc_head_nonneg_accepted) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::math_optimization::simplex; + using namespace cuopt::mathematical_optimization::simplex; user_problem_t user_problem(&handle); // Variables: x0, x1, t. Constraint: x0^2 + x1^2 - t^2 <= 0 @@ -659,7 +659,7 @@ TEST(general_quadratic, soc_head_free_rejected) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::math_optimization::simplex; + using namespace cuopt::mathematical_optimization::simplex; user_problem_t user_problem(&handle); constexpr int m = 1; @@ -715,7 +715,7 @@ TEST(general_quadratic, rotated_soc_heads_nonneg_accepted) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::math_optimization::simplex; + using namespace cuopt::mathematical_optimization::simplex; user_problem_t user_problem(&handle); // Variables: x0, x1, y, z. Constraint: x0^2 + x1^2 - 2*y*z <= 0 @@ -774,7 +774,7 @@ TEST(general_quadratic, rotated_soc_heads_free_rejected) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::math_optimization::simplex; + using namespace cuopt::mathematical_optimization::simplex; user_problem_t user_problem(&handle); constexpr int m = 1; @@ -824,4 +824,4 @@ TEST(general_quadratic, rotated_soc_heads_free_rejected) cuopt::logic_error); } -} // namespace cuopt::math_optimization::barrier::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 0111bbef99..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::math_optimization::barrier::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::math_optimization::barrier::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 716ae4b293..0fc1d93470 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::math_optimization::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,7 @@ TEST(barrier, cone_metadata_reindexed_when_slack_is_inserted_before_cones) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::math_optimization::simplex; + using namespace cuopt::mathematical_optimization::simplex; user_problem_t user_problem(&handle); constexpr int m = 1; @@ -98,7 +98,7 @@ TEST(barrier, presolve_reindexes_cone_start_after_empty_column_removal) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::math_optimization::simplex; + using namespace cuopt::mathematical_optimization::simplex; user_problem_t user_problem(&handle); constexpr int m = 1; @@ -167,7 +167,7 @@ TEST(barrier, presolve_keeps_direct_free_variables_before_cones) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::math_optimization::simplex; + using namespace cuopt::mathematical_optimization::simplex; user_problem_t user_problem(&handle); constexpr int m = 1; @@ -230,7 +230,7 @@ TEST(barrier, rejects_middle_cone_input_before_barrier) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::math_optimization::simplex; + using namespace cuopt::mathematical_optimization::simplex; user_problem_t user_problem(&handle); constexpr int m = 3; @@ -282,7 +282,7 @@ TEST(barrier, socp_min_x0_subject_to_norm_constraint) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::math_optimization::simplex; + using namespace cuopt::mathematical_optimization::simplex; user_problem_t user_problem(&handle); constexpr int m = 1; @@ -343,7 +343,7 @@ TEST(barrier, mixed_linear_and_soc_block) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::math_optimization::simplex; + using namespace cuopt::mathematical_optimization::simplex; user_problem_t user_problem(&handle); constexpr int m = 2; @@ -409,7 +409,7 @@ TEST(barrier, mixed_linear_and_soc_tail_coupling) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::math_optimization::simplex; + using namespace cuopt::mathematical_optimization::simplex; user_problem_t user_problem(&handle); constexpr int m = 2; @@ -476,7 +476,7 @@ TEST(barrier, mixed_linear_and_soc_tail_coupling_with_inequality) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::math_optimization::simplex; + using namespace cuopt::mathematical_optimization::simplex; user_problem_t user_problem(&handle); constexpr int m = 2; @@ -546,7 +546,7 @@ TEST(barrier, mixed_linear_and_two_soc_blocks) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::math_optimization::simplex; + using namespace cuopt::mathematical_optimization::simplex; user_problem_t user_problem(&handle); constexpr int m = 4; @@ -627,7 +627,7 @@ TEST(barrier, mixed_linear_and_two_soc_blocks_with_inequality) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::math_optimization::simplex; + using namespace cuopt::mathematical_optimization::simplex; user_problem_t user_problem(&handle); constexpr int m = 4; @@ -707,7 +707,7 @@ TEST(barrier, free_linear_prefix_is_uncrushed_correctly_with_soc_block) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::math_optimization::simplex; + using namespace cuopt::mathematical_optimization::simplex; user_problem_t user_problem(&handle); constexpr int m = 2; @@ -771,7 +771,7 @@ TEST(barrier, qp_with_soc_block) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::math_optimization::simplex; + using namespace cuopt::mathematical_optimization::simplex; user_problem_t user_problem(&handle); constexpr int m = 1; @@ -824,4 +824,4 @@ TEST(barrier, qp_with_soc_block) EXPECT_NEAR(std::abs(solution.x[3]), 0.0, 1e-4); } -} // namespace cuopt::math_optimization::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 e28d3aec0c..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::math_optimization::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::math_optimization::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 d76d621262..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::math_optimization::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::math_optimization::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 aa5cd203fc..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/math_optimization/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 55bbfefaa1..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 701c824dda..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 529c78278c..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 18ca3a9a6a..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 3e4d5f704d..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 0df0f09813..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 d3c1bc4f82..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 57efa553be..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 522902d7ad..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 9c7a538329..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/math_optimization/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 847882936f..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/math_optimization/io/mps_data_model.hpp" namespace "cuopt::math_optimization::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/math_optimization/io/mps_data_model.hpp" namespace "cuop vector[double] vals -cdef extern from "cuopt/math_optimization/io/data_model_view.hpp" namespace "cuopt::math_optimization::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/math_optimization/io/data_model_view.hpp" namespace "cuo vector[mps_data_model_t[i_t, f_t].quadratic_constraint_t] constraints) except + -cdef extern from "cuopt/math_optimization/io/writer.hpp" namespace "cuopt::math_optimization::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 02f5b614e7..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/math_optimization/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 3d7430e24c..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/math_optimization/io/mps_data_model.hpp" namespace "cuopt::math_optimization::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/math_optimization/io/mps_data_model.hpp" namespace "cuop string problem_name_ const vector[quadratic_constraint_t]& get_quadratic_constraints() const -cdef extern from "cuopt/math_optimization/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 10f38d498c..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/math_optimization/optimization_problem.hpp" namespace "cuopt::math_optimization": # noqa - ctypedef enum problem_category_t "cuopt::math_optimization::problem_category_t": # noqa - LP "cuopt::math_optimization::problem_category_t::LP" - MIP "cuopt::math_optimization::problem_category_t::MIP" - IP "cuopt::math_optimization::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/math_optimization/mip/solver_solution.hpp" namespace "cuopt::math_optimization": # noqa - ctypedef enum mip_termination_status_t "cuopt::math_optimization::mip_termination_status_t": # noqa - NoTermination "cuopt::math_optimization::mip_termination_status_t::NoTermination" # noqa - Optimal "cuopt::math_optimization::mip_termination_status_t::Optimal" - FeasibleFound "cuopt::math_optimization::mip_termination_status_t::FeasibleFound" # noqa - Infeasible "cuopt::math_optimization::mip_termination_status_t::Infeasible" # noqa - Unbounded "cuopt::math_optimization::mip_termination_status_t::Unbounded" # noqa - TimeLimit "cuopt::math_optimization::mip_termination_status_t::TimeLimit" # noqa - WorkLimit "cuopt::math_optimization::mip_termination_status_t::WorkLimit" # noqa - UnboundedOrInfeasible "cuopt::math_optimization::mip_termination_status_t::UnboundedOrInfeasible" # noqa - - -cdef extern from "cuopt/math_optimization/pdlp/solver_solution.hpp" namespace "cuopt::math_optimization": # noqa - ctypedef enum pdlp_termination_status_t "cuopt::math_optimization::pdlp_termination_status_t": # noqa - NoTermination "cuopt::math_optimization::pdlp_termination_status_t::NoTermination" # noqa - NumericalError "cuopt::math_optimization::pdlp_termination_status_t::NumericalError" # noqa - Optimal "cuopt::math_optimization::pdlp_termination_status_t::Optimal" # noqa - PrimalInfeasible "cuopt::math_optimization::pdlp_termination_status_t::PrimalInfeasible" # noqa - DualInfeasible "cuopt::math_optimization::pdlp_termination_status_t::DualInfeasible" # noqa - IterationLimit "cuopt::math_optimization::pdlp_termination_status_t::IterationLimit" # noqa - TimeLimit "cuopt::math_optimization::pdlp_termination_status_t::TimeLimit" # noqa - ConcurrentLimit "cuopt::math_optimization::pdlp_termination_status_t::ConcurrentLimit" # noqa - PrimalFeasible "cuopt::math_optimization::pdlp_termination_status_t::PrimalFeasible" # noqa - UnboundedOrInfeasible "cuopt::math_optimization::pdlp_termination_status_t::UnboundedOrInfeasible" # noqa - - -cdef extern from "cuopt/math_optimization/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/math_optimization/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/math_optimization/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/math_optimization/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 17ad7ca45f..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/math_optimization/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 90780bfb0b..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/math_optimization/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/math_optimization/pdlp/solver_settings.hpp" namespace "cuopt::math_optimization": # noqa - ctypedef enum pdlp_solver_mode_t "cuopt::math_optimization::pdlp_solver_mode_t": # noqa - Stable1 "cuopt::math_optimization::pdlp_solver_mode_t::Stable1" # noqa - Stable2 "cuopt::math_optimization::pdlp_solver_mode_t::Stable2" # noqa - Methodical1 "cuopt::math_optimization::pdlp_solver_mode_t::Methodical1" # noqa - Fast1 "cuopt::math_optimization::pdlp_solver_mode_t::Fast1" # noqa - Stable3 "cuopt::math_optimization::pdlp_solver_mode_t::Stable3" # noqa - - ctypedef enum method_t "cuopt::math_optimization::method_t": # noqa - Concurrent "cuopt::math_optimization::method_t::Concurrent" # noqa - PDLP "cuopt::math_optimization::method_t::PDLP" # noqa - DualSimplex "cuopt::math_optimization::method_t::DualSimplex" # noqa - Barrier "cuopt::math_optimization::method_t::Barrier" # noqa - Unset "cuopt::math_optimization::method_t::Unset" # noqa - -cdef extern from "cuopt/math_optimization/solver_settings.hpp" namespace "cuopt::math_optimization": # 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 df2b700926..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/math_optimization/` | 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/math_optimization/solver_settings.hpp" namespace "cuopt::math_optimization": - ctypedef enum pdlp_solver_mode_t "cuopt::math_optimization::pdlp_solver_mode_t": - Stable1 "cuopt::math_optimization::pdlp_solver_mode_t::Stable1" - Stable2 "cuopt::math_optimization::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 8a2879d3ef..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 c8bc1330c2..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/math_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 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 525ac95fcd..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 d1e30a677a..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 8b4219057a..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 007ce2089d..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 ea4f689cb5..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 729f5cacd0..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/math_optimization/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 0e992aec8e..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/math_optimization/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/math_optimization/constants.h` | -| C API Header | `cpp/include/cuopt/math_optimization/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` | From 342ec390afbf4074280a2d5ed3cabb0cb1bd6859 Mon Sep 17 00:00:00 2001 From: Miles Lubin Date: Wed, 24 Jun 2026 15:26:37 +0000 Subject: [PATCH 13/17] refactor: drop dead simplex::branch_and_bound_t forward-decl local_search.cuh forward-declared branch_and_bound_t in the simplex namespace, but the type lives in ::mip (the file's actual use is mip::branch_and_bound_t, reachable via solver_context.cuh). The stray decl was a leftover: Task moving B&B to ::mip updated the usage but missed this forward declaration, which the dual_simplex->simplex rename then renamed. Dead (nothing referenced simplex::branch_and_bound_t); removed. Co-Authored-By: Claude Opus 4.8 (1M context) Signed-off-by: Miles Lubin --- cpp/src/mip_heuristics/local_search/local_search.cuh | 5 ----- 1 file changed, 5 deletions(-) diff --git a/cpp/src/mip_heuristics/local_search/local_search.cuh b/cpp/src/mip_heuristics/local_search/local_search.cuh index f786dceed1..e22d7e2d0e 100644 --- a/cpp/src/mip_heuristics/local_search/local_search.cuh +++ b/cpp/src/mip_heuristics/local_search/local_search.cuh @@ -15,11 +15,6 @@ #include #include -namespace cuopt::mathematical_optimization::simplex { -template -class branch_and_bound_t; -} - namespace cuopt::mathematical_optimization::mip { // make sure RANDOM is always the last From c57bd231a54a4ac4b48aa7c3ba38174e8f901777 Mon Sep 17 00:00:00 2001 From: Miles Lubin Date: Thu, 25 Jun 2026 14:46:18 +0000 Subject: [PATCH 14/17] refactor: use targeted using-declarations for shared simplex names Replace the inconsistent mix of 'using namespace simplex' directives and scattered full qualification with per-file 'using simplex::NAME;' declarations for names used 2+ times (bare thereafter); single uses stay qualified. Headers remain fully-qualified; the shadowed vector_norm* family stays simplex::-qualified. Co-Authored-By: Claude Opus 4.8 (1M context) Signed-off-by: Miles Lubin --- cpp/src/barrier/barrier.cu | 22 +++- cpp/src/barrier/cusparse_view.cu | 7 +- cpp/src/barrier/pinned_host_allocator.cu | 3 - cpp/src/branch_and_bound/branch_and_bound.cpp | 76 ++++++++---- .../branch_and_bound/diving_heuristics.cpp | 6 +- cpp/src/branch_and_bound/pseudo_costs.cpp | 114 ++++++++++-------- cpp/src/cuts/cuts.cpp | 36 ++++-- cpp/src/cuts/objective_step.cpp | 3 +- .../mip_heuristics/feasibility_jump/fj_cpu.cu | 32 ++--- .../presolve/conflict_graph/clique_table.cu | 21 ++-- cpp/src/mip_heuristics/problem/problem.cu | 20 +-- cpp/src/mip_heuristics/solve.cu | 16 +-- cpp/src/mip_heuristics/solver.cu | 31 ++--- cpp/tests/socp/general_quadratic_test.cu | 39 +++--- cpp/tests/socp/solve_barrier_socp.cu | 12 -- 15 files changed, 245 insertions(+), 193 deletions(-) diff --git a/cpp/src/barrier/barrier.cu b/cpp/src/barrier/barrier.cu index ecc4300a09..f75bd58176 100644 --- a/cpp/src/barrier/barrier.cu +++ b/cpp/src/barrier/barrier.cu @@ -52,8 +52,20 @@ namespace cuopt::mathematical_optimization::barrier { -using namespace cuopt::mathematical_optimization::simplex; // shared simplex types (lp_problem_t, - // inf, etc.) +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; template bool validate_barrier_cone_layout(const lp_problem_t& problem, @@ -1781,7 +1793,7 @@ class iteration_data_t { // u = A^T * y dense_vector_t u(n); - matrix_transpose_vector_multiply(A, 1.0, y, 0.0, 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 @@ -2121,7 +2133,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()) { @@ -3004,7 +3016,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 { diff --git a/cpp/src/barrier/cusparse_view.cu b/cpp/src/barrier/cusparse_view.cu index fb71747034..2585084097 100644 --- a/cpp/src/barrier/cusparse_view.cu +++ b/cpp/src/barrier/cusparse_view.cu @@ -24,9 +24,6 @@ namespace cuopt::mathematical_optimization::barrier { -using namespace cuopt::mathematical_optimization::simplex; // shared simplex types (lp_problem_t, - // inf, etc.) - #define CUDA_VER_12_4_UP (CUDART_VERSION >= 12040) #if CUDA_VER_12_4_UP @@ -129,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()), @@ -149,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; diff --git a/cpp/src/barrier/pinned_host_allocator.cu b/cpp/src/barrier/pinned_host_allocator.cu index a74b5c525d..797d679e2b 100644 --- a/cpp/src/barrier/pinned_host_allocator.cu +++ b/cpp/src/barrier/pinned_host_allocator.cu @@ -12,9 +12,6 @@ namespace cuopt::mathematical_optimization::barrier { -using namespace cuopt::mathematical_optimization::simplex; // shared simplex types (lp_problem_t, - // inf, etc.) - template struct PinnedHostAllocator { using value_type = T; diff --git a/cpp/src/branch_and_bound/branch_and_bound.cpp b/cpp/src/branch_and_bound/branch_and_bound.cpp index 3f3d332186..dd89dc65d4 100644 --- a/cpp/src/branch_and_bound/branch_and_bound.cpp +++ b/cpp/src/branch_and_bound/branch_and_bound.cpp @@ -46,8 +46,31 @@ namespace cuopt::mathematical_optimization::mip { -using namespace cuopt::mathematical_optimization::simplex; // shared simplex types (lp_problem_t, - // etc.) +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::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; + namespace { template @@ -101,8 +124,8 @@ bool check_guess(const lp_problem_t& original_lp, bool feasible = false; std::vector residual(original_lp.num_rows); residual = original_lp.rhs; - matrix_vector_multiply(original_lp.A, 1.0, guess, -1.0, residual); - primal_error = vector_norm_inf(residual); + simplex::matrix_vector_multiply(original_lp.A, 1.0, guess, -1.0, residual); + primal_error = simplex::vector_norm_inf(residual); bound_error = 0.0; constexpr bool verbose = false; for (i_t j = 0; j < original_lp.num_cols; j++) { @@ -247,8 +270,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 @@ -582,7 +606,7 @@ 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; @@ -658,7 +682,7 @@ void branch_and_bound_t::repair_heuristic_solutions() } template -void branch_and_bound_t::set_solution_at_root(simplex::mip_solution_t& solution, +void branch_and_bound_t::set_solution_at_root(mip_solution_t& solution, const cut_info_t& cut_info) { mutex_upper_.lock(); @@ -687,7 +711,7 @@ void branch_and_bound_t::set_solution_at_root(simplex::mip_solution_t< } template -void branch_and_bound_t::set_final_solution(simplex::mip_solution_t& solution, +void branch_and_bound_t::set_final_solution(mip_solution_t& solution, f_t lower_bound) { if (solver_status_ == mip_status_t::NUMERICAL) { @@ -2040,13 +2064,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; @@ -2144,7 +2168,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"); @@ -2156,7 +2180,7 @@ lp_status_t branch_and_bound_t::solve_root_relaxation( template auto branch_and_bound_t::do_cut_pass( [[maybe_unused]] i_t cut_pass, - simplex::mip_solution_t& solution, + mip_solution_t& solution, i_t& num_fractional, std::vector& fractional, cut_generation_t& cut_generation, @@ -2363,7 +2387,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 @@ -2436,7 +2460,7 @@ auto branch_and_bound_t::do_cut_pass( } template -mip_status_t branch_and_bound_t::solve(simplex::mip_solution_t& solution) +mip_status_t branch_and_bound_t::solve(mip_solution_t& solution) { raft::common::nvtx::range scope("BB::solve"); @@ -2588,12 +2612,12 @@ mip_status_t branch_and_bound_t::solve(simplex::mip_solution_t 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_)); } diff --git a/cpp/src/branch_and_bound/diving_heuristics.cpp b/cpp/src/branch_and_bound/diving_heuristics.cpp index cdd1241a13..aebb7998cc 100644 --- a/cpp/src/branch_and_bound/diving_heuristics.cpp +++ b/cpp/src/branch_and_bound/diving_heuristics.cpp @@ -9,8 +9,8 @@ namespace cuopt::mathematical_optimization::mip { -using namespace cuopt::mathematical_optimization::simplex; // shared simplex types (lp_problem_t, - // etc.) +using simplex::logger_t; +using simplex::lp_problem_t; template branch_variable_t line_search_diving(const std::vector& fractional, @@ -24,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) { diff --git a/cpp/src/branch_and_bound/pseudo_costs.cpp b/cpp/src/branch_and_bound/pseudo_costs.cpp index da35a1392c..9e694bd865 100644 --- a/cpp/src/branch_and_bound/pseudo_costs.cpp +++ b/cpp/src/branch_and_bound/pseudo_costs.cpp @@ -27,8 +27,20 @@ namespace cuopt::mathematical_optimization::mip { -using namespace cuopt::mathematical_optimization::simplex; // shared simplex types (lp_problem_t, - // etc.) +using simplex::basis_update_mpf_t; +using simplex::compute_initial_nonbasic_end; +using simplex::compute_objective; +using simplex::csr_matrix_t; +using simplex::dual_status_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; + namespace { static bool is_dual_simplex_done(dual_status_t status) @@ -50,7 +62,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++) { @@ -107,28 +119,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 @@ -138,8 +150,8 @@ 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); - f_t dual_residual_norm = vector_norm_inf(dual_residual); + simplex::matrix_transpose_vector_multiply(lp.A, 1.0, lp_solution.y, 1.0, dual_residual); + f_t dual_residual_norm = simplex::vector_norm_inf(dual_residual); settings.log.printf("Dual residual norm: %e\n", dual_residual_norm); } #endif @@ -361,15 +373,15 @@ 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) { @@ -497,26 +509,26 @@ std::pair trial_branching(const lp_problem_t& orig // 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) { @@ -534,7 +546,7 @@ std::pair trial_branching(const lp_problem_t& orig template static cuopt::mathematical_optimization::io::mps_data_model_t -simplex_problem_to_mps_data_model(const simplex::lp_problem_t& lp, +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) @@ -570,7 +582,7 @@ simplex_problem_to_mps_data_model(const simplex::lp_problem_t& lp, } // Convert CSC to CSR using built-in method - 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]; @@ -729,7 +741,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);*/ @@ -891,7 +903,7 @@ static void batch_pdlp_strong_branching_task( template static void batch_pdlp_reliability_branching_task( - logger_t& log, + simplex::logger_t& log, i_t rb_mode, i_t num_candidates, f_t start_time, diff --git a/cpp/src/cuts/cuts.cpp b/cpp/src/cuts/cuts.cpp index aa0379605a..ec926cec84 100644 --- a/cpp/src/cuts/cuts.cpp +++ b/cpp/src/cuts/cuts.cpp @@ -29,8 +29,20 @@ namespace cuopt::mathematical_optimization::mip { -using namespace cuopt::mathematical_optimization::simplex; // shared simplex types (lp_problem_t, - // etc.) +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_vector_t; +using simplex::tic; +using simplex::toc; +using simplex::variable_status_t; +using simplex::variable_type_t; namespace { @@ -595,12 +607,12 @@ f_t cut_pool_t::cut_orthogonality(i_t i, i_t j) const i_t j_end = cut_storage_.row_start[j + 1]; const i_t j_nz = j_end - j_start; - f_t dot = sparse_dot(cut_storage_.j.data() + i_start, - cut_storage_.x.data() + i_start, - i_nz, - cut_storage_.j.data() + j_start, - cut_storage_.x.data() + j_start, - j_nz); + f_t dot = simplex::sparse_dot(cut_storage_.j.data() + i_start, + cut_storage_.x.data() + i_start, + i_nz, + cut_storage_.j.data() + j_start, + cut_storage_.x.data() + j_start, + j_nz); f_t norm_i = cut_norms_[i]; f_t norm_j = cut_norms_[j]; @@ -3398,7 +3410,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)); @@ -3897,7 +3909,7 @@ void complemented_mixed_integer_rounding_cut_t::compute_initial_scores { const bool verbose = false; const i_t n = lp.num_cols; - const f_t obj_norm = vector_norm2(lp.objective); + const f_t obj_norm = simplex::vector_norm2(lp.objective); const f_t obj_denom = std::max(1.0, obj_norm); // Compute initial scores for all rows @@ -5476,7 +5488,7 @@ void read_saved_solution_for_cut_verification(const lp_problem_t& lp, std::vector residual = lp.rhs; matrix_vector_multiply(lp.A, 1.0, saved_solution, -1.0, residual); settings.log.printf("Saved solution: || A*x - b ||_inf %e\n", - vector_norm_inf(residual)); + simplex::vector_norm_inf(residual)); f_t infeas = 0; for (i_t j = 0; j < lp.num_cols; j++) { if (saved_solution[j] < lp.lower[j] - 1e-6) { @@ -5510,7 +5522,7 @@ void write_solution_for_cut_verification(const lp_problem_t& lp, std::vector residual = lp.rhs; matrix_vector_multiply(lp.A, 1.0, solution, -1.0, residual); - printf("|| A*x - b ||_inf %e\n", vector_norm_inf(residual)); + printf("|| A*x - b ||_inf %e\n", simplex::vector_norm_inf(residual)); auto hash_combine_f = [](size_t seed, f_t x) { seed ^= std::hash{}(x) + 0x9e3779b9 + (seed << 6) + (seed >> 2); return seed; diff --git a/cpp/src/cuts/objective_step.cpp b/cpp/src/cuts/objective_step.cpp index 7b579ea7a7..a3978de228 100644 --- a/cpp/src/cuts/objective_step.cpp +++ b/cpp/src/cuts/objective_step.cpp @@ -16,8 +16,7 @@ namespace cuopt::mathematical_optimization::mip { -using namespace cuopt::mathematical_optimization::simplex; // shared simplex types - // (objective_step_t, etc.) +using simplex::objective_step_t; namespace { diff --git a/cpp/src/mip_heuristics/feasibility_jump/fj_cpu.cu b/cpp/src/mip_heuristics/feasibility_jump/fj_cpu.cu index db4dfc012a..04a312766c 100644 --- a/cpp/src/mip_heuristics/feasibility_jump/fj_cpu.cu +++ b/cpp/src/mip_heuristics/feasibility_jump/fj_cpu.cu @@ -48,6 +48,10 @@ 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( fj_cpu_climber_t& fj_cpu, @@ -1416,10 +1420,10 @@ void finalize_fj_cpu_host_initialization( template static std::unique_ptr> init_fj_cpu_from_host_lp( - const 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 simplex::simplex_solver_settings_t& settings, + const simplex_solver_settings_t& settings, std::atomic& preemption_flag, int64_t seed) { @@ -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 == 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 && @@ -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] != 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 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 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 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 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 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 simplex::simplex_solver_settings_t& settings, + const simplex_solver_settings_t& settings, std::function&, double)> improvement_callback, std::string log_prefix, int64_t seed); 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 a14f8057e2..bcf2d1a9dd 100644 --- a/cpp/src/mip_heuristics/presolve/conflict_graph/clique_table.cu +++ b/cpp/src/mip_heuristics/presolve/conflict_graph/clique_table.cu @@ -32,6 +32,9 @@ namespace cuopt::mathematical_optimization::mip { +using simplex::csr_matrix_t; +using simplex::user_problem_t; + // do constraints with only binary variables. template void find_cliques_from_constraint(const knapsack_constraint_t& kc, @@ -99,7 +102,7 @@ void sort_csr_by_constraint_coefficients( template void make_coeff_positive_knapsack_constraint( - const 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 simplex::user_problem_t& problem, +void fill_knapsack_constraints(const user_problem_t& problem, std::vector>& knapsack_constraints, - simplex::csr_matrix_t& A) + csr_matrix_t& A) { // we might add additional constraints for the equality constraints i_t added_constraints = 0; @@ -593,7 +596,7 @@ void clique_table_t::set_small_clique_adj_for_test( } template -void build_clique_table(const 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 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; - 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(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(simplex::user_problem_t& problem, double t_remove = 0.; #endif std::vector> knapsack_constraints; - 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(simplex::user_problem_t& problem, #define INSTANTIATE(F_TYPE) \ template void find_initial_cliques( \ - 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 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, \ diff --git a/cpp/src/mip_heuristics/problem/problem.cu b/cpp/src/mip_heuristics/problem/problem.cu index b789c05cbc..770c8c4623 100644 --- a/cpp/src/mip_heuristics/problem/problem.cu +++ b/cpp/src/mip_heuristics/problem/problem.cu @@ -50,6 +50,10 @@ 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_) { @@ -2153,7 +2157,7 @@ void problem_t::preprocess_problem() template void problem_t::set_constraints_from_host_user_problem( - const cuopt::mathematical_optimization::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"); - 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); @@ -2273,8 +2277,7 @@ void problem_t::papilo_uncrush_assignment(rmm::device_uvector& as } template -void problem_t::get_host_user_problem( - cuopt::mathematical_optimization::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); - 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::mathematical_optimization::simplex::variable_type_t::CONTINUOUS - : cuopt::mathematical_optimization::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; } } diff --git a/cpp/src/mip_heuristics/solve.cu b/cpp/src/mip_heuristics/solve.cu index 0e6609f5b2..891c7c3a8b 100644 --- a/cpp/src/mip_heuristics/solve.cu +++ b/cpp/src/mip_heuristics/solve.cu @@ -67,6 +67,9 @@ 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) { @@ -209,12 +212,11 @@ mip_solution_t run_mip_solver( scaled_problem.n_variables); symmetry.reset(); if (settings.symmetry != 0) { - 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; - 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 = mip::detect_symmetry(reduced_user_problem, simplex_settings, has_symmetry_reduced); @@ -431,10 +433,10 @@ mip_solution_t solve_mip_helper(optimization_problem_t& op_p bool has_symmetry = false; if (settings.symmetry != 0) { mip::problem_t problem(op_problem); - 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; - simplex::user_problem_t user_problem = + user_problem_t user_problem = cuopt_problem_to_user_problem(op_problem.get_handle_ptr(), problem); symmetry = mip::detect_symmetry(user_problem, simplex_settings, has_symmetry); if (has_symmetry) { settings.presolver = presolver_t::None; } diff --git a/cpp/src/mip_heuristics/solver.cu b/cpp/src/mip_heuristics/solver.cu index e2b5ab9dfb..0ede00964a 100644 --- a/cpp/src/mip_heuristics/solver.cu +++ b/cpp/src/mip_heuristics/solver.cu @@ -35,6 +35,9 @@ 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, - 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,16 +86,15 @@ struct branch_and_bound_solution_helper_t { void preempt_heuristic_solver() { dm->population.preempt_heuristic_solver(); } diversity_manager_t* dm; - 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 simplex::user_problem_t& branch_and_bound_problem, - const probing_cache_t& probing_cache, - mip::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; @@ -296,12 +298,11 @@ 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::mathematical_optimization::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::mathematical_optimization::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::mathematical_optimization::mip::detect_symmetry( post_presolve_problem, simplex_settings, has_symmetry_post); @@ -310,7 +311,7 @@ solution_t mip_solver_t::run_solver() namespace simplex = cuopt::mathematical_optimization::simplex; mip::mip_status_t branch_and_bound_status = mip::mip_status_t::UNSET; - simplex::user_problem_t branch_and_bound_problem(context.problem_ptr->handle_ptr); + 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,7 +329,7 @@ solution_t mip_solver_t::run_solver() if (context.settings.objective_step) { branch_and_bound_problem.objective_step = context.problem_ptr->get_objective_step(); } - simplex::simplex_solver_settings_t branch_and_bound_settings; + 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); simplex::mip_solution_t branch_and_bound_solution(1); @@ -338,7 +339,7 @@ solution_t mip_solver_t::run_solver() i_t num_threads = omp_get_num_threads(); if (!context.settings.heuristics_only) { - // Convert the presolved problem to 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); diff --git a/cpp/tests/socp/general_quadratic_test.cu b/cpp/tests/socp/general_quadratic_test.cu index 0485482c9f..870c1b62ae 100644 --- a/cpp/tests/socp/general_quadratic_test.cu +++ b/cpp/tests/socp/general_quadratic_test.cu @@ -21,6 +21,15 @@ 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; using qc_t = optimization_problem_interface_t::quadratic_constraint_t; @@ -46,7 +55,6 @@ TEST(general_quadratic, dense_pd_2x2_solve) raft::handle_t handle{}; init_handler(&handle); - using namespace cuopt::mathematical_optimization::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) - 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::mathematical_optimization::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}; - 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::mathematical_optimization::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}; - 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::mathematical_optimization::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 - 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::mathematical_optimization::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 - 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::mathematical_optimization::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 - 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::mathematical_optimization::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}; - 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::mathematical_optimization::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}; - 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::mathematical_optimization::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}; - 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::mathematical_optimization::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}; - 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}; diff --git a/cpp/tests/socp/solve_barrier_socp.cu b/cpp/tests/socp/solve_barrier_socp.cu index 0fc1d93470..8a5792185c 100644 --- a/cpp/tests/socp/solve_barrier_socp.cu +++ b/cpp/tests/socp/solve_barrier_socp.cu @@ -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::mathematical_optimization::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::mathematical_optimization::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::mathematical_optimization::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::mathematical_optimization::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::mathematical_optimization::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::mathematical_optimization::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::mathematical_optimization::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::mathematical_optimization::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::mathematical_optimization::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::mathematical_optimization::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::mathematical_optimization::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::mathematical_optimization::simplex; user_problem_t user_problem(&handle); constexpr int m = 1; From 5db73a91efe974f92878149f7409a9d34cbff79a Mon Sep 17 00:00:00 2001 From: Miles Lubin Date: Thu, 25 Jun 2026 15:19:05 +0000 Subject: [PATCH 15/17] refactor: replace remaining file-scope using-namespace with targeted using-declarations grpc server glue and the C API impl kept file-scope 'using namespace cuopt::mathematical_optimization[::io]'; replace with targeted using-declarations (>=2 uses) / full qualification (single use), per the repo style rule. cpp/src is now free of file-scope using-namespace directives. Co-Authored-By: Claude Opus 4.8 (1M context) Signed-off-by: Miles Lubin --- cpp/src/grpc/server/grpc_service_impl.cpp | 6 +- cpp/src/grpc/server/grpc_worker.cpp | 87 ++++++++++++----------- cpp/src/pdlp/cuopt_c.cpp | 39 ++++++---- 3 files changed, 73 insertions(+), 59 deletions(-) diff --git a/cpp/src/grpc/server/grpc_service_impl.cpp b/cpp/src/grpc/server/grpc_service_impl.cpp index 5f35640241..83dbec3d19 100644 --- a/cpp/src/grpc/server/grpc_service_impl.cpp +++ b/cpp/src/grpc/server/grpc_service_impl.cpp @@ -9,8 +9,6 @@ #include "grpc_pipe_serialization.hpp" #include "grpc_server_types.hpp" -using namespace cuopt::mathematical_optimization; - class CuOptRemoteServiceImpl final : public cuopt::remote::CuOptRemoteService::Service { public: // Unary submit: the entire problem fits in a single gRPC message. @@ -361,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 e686d12974..3c33021d00 100644 --- a/cpp/src/grpc/server/grpc_worker.cpp +++ b/cpp/src/grpc/server/grpc_worker.cpp @@ -9,16 +9,18 @@ #include "grpc_pipe_serialization.hpp" #include "grpc_server_types.hpp" -using namespace cuopt::mathematical_optimization; +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; // --------------------------------------------------------------------------- // Data-transfer structs used to pass results between decomposed functions. // --------------------------------------------------------------------------- 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; }; @@ -251,7 +253,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. @@ -318,7 +321,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 @@ -337,21 +340,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) { @@ -378,7 +382,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 @@ -405,25 +409,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/pdlp/cuopt_c.cpp b/cpp/src/pdlp/cuopt_c.cpp index 66a21ca3a3..0288014f40 100644 --- a/cpp/src/pdlp/cuopt_c.cpp +++ b/cpp/src/pdlp/cuopt_c.cpp @@ -27,8 +27,15 @@ #include #include -using namespace cuopt::mathematical_optimization::io; -using namespace cuopt::mathematical_optimization; +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; @@ -824,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] = 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; } @@ -1075,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); @@ -1103,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); From e5fe2a015a5e3183fc61158381c7a8cc1c9bdd03 Mon Sep 17 00:00:00 2001 From: Miles Lubin Date: Thu, 25 Jun 2026 16:20:48 +0000 Subject: [PATCH 16/17] refactor: restore the phase2 namespace in phase2.cpp Per PR review: the phase2 namespace was intentional, scoping the generically named dual-simplex phase-2 helpers (compute_reduced_costs, steepest_edge_pricing, flip_bounds, ...) away from same-named routines in primal/crossover (which use anonymous namespaces). An earlier phase had folded it into the parent namespace. Restore the exact original set (48 helpers + phase2_timers_t) under namespace phase2; the dual_phase2 entry points stay in the parent and call the helpers via phase2::. File-internal; no header or other-file changes. Co-Authored-By: Claude Opus 4.8 (1M context) Signed-off-by: Miles Lubin --- cpp/src/dual_simplex/phase2.cpp | 614 ++++++++++++++++---------------- 1 file changed, 312 insertions(+), 302 deletions(-) diff --git a/cpp/src/dual_simplex/phase2.cpp b/cpp/src/dual_simplex/phase2.cpp index 75083ddb19..36daed4c8d 100644 --- a/cpp/src/dual_simplex/phase2.cpp +++ b/cpp/src/dual_simplex/phase2.cpp @@ -271,6 +271,9 @@ void update_Arow(i_t leaving, // 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, @@ -2489,6 +2492,8 @@ class phase2_timers_t { bool record_time; }; +} // namespace phase2 + template dual_status_t dual_phase2(i_t phase, i_t slack_basis, @@ -2575,7 +2580,7 @@ dual_status_t dual_phase2_with_advanced_basis(i_t phase, std::vector z_old = z; phase2_work_estimate += 4 * n; - bound_info(lp, settings); + phase2::bound_info(lp, settings); phase2_work_estimate += 2 * n; f_t refactor_work = 0.0; @@ -2620,12 +2625,13 @@ dual_status_t dual_phase2_with_advanced_basis(i_t phase, "|| y || %e || cB || %e\n", vector_norm_inf(y), vector_norm_inf(c_basic)); } - compute_reduced_costs(objective, lp.A, y, basic_list, nonbasic_list, z, phase2_work_estimate); + phase2::compute_reduced_costs( + objective, lp.A, y, basic_list, nonbasic_list, z, phase2_work_estimate); if constexpr (print_norms) { settings.log.printf("|| z || %e\n", vector_norm_inf(z)); } #ifdef COMPUTE_DUAL_RESIDUAL std::vector dual_res1; - compute_dual_residual(lp.A, objective, y, z, dual_res1); + phase2::compute_dual_residual(lp.A, objective, y, z, dual_res1); f_t dual_res_norm = vector_norm_inf(dual_res1); if (dual_res_norm > settings.tight_tol) { settings.log.printf("|| A'*y + z - c || %e\n", dual_res_norm); @@ -2633,19 +2639,19 @@ dual_status_t dual_phase2_with_advanced_basis(i_t phase, assert(dual_res_norm < 1e-3); #endif - set_primal_variables_on_bounds(lp, settings, z, vstatus, x); + phase2::set_primal_variables_on_bounds(lp, settings, z, vstatus, x); phase2_work_estimate += 5 * (n - m); #ifdef PRINT_VSTATUS_CHANGES i_t num_vstatus_changes; i_t num_z_changes; - vstatus_changes(vstatus, vstatus_old, z, z_old, num_vstatus_changes, num_z_changes); + phase2::vstatus_changes(vstatus, vstatus_old, z, z_old, num_vstatus_changes, num_z_changes); settings.log.printf("Number of vstatus changes %d\n", num_vstatus_changes); settings.log.printf("Number of z changes %d\n", num_z_changes); #endif const f_t init_dual_inf = - dual_infeasibility(lp, settings, vstatus, z, settings.tight_tol, settings.dual_tol); + phase2::dual_infeasibility(lp, settings, vstatus, z, settings.tight_tol, settings.dual_tol); phase2_work_estimate += 3 * n; if (init_dual_inf > settings.dual_tol) { settings.log.printf("Initial dual infeasibility %e\n", init_dual_inf); @@ -2658,15 +2664,15 @@ dual_status_t dual_phase2_with_advanced_basis(i_t phase, } phase2_work_estimate += 3 * n; - compute_primal_variables(ft, - lp.rhs, - lp.A, - basic_list, - nonbasic_list, - settings.tight_tol, - x, - xB_workspace, - phase2_work_estimate); + phase2::compute_primal_variables(ft, + lp.rhs, + lp.A, + basic_list, + nonbasic_list, + settings.tight_tol, + x, + xB_workspace, + phase2_work_estimate); 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)); } @@ -2685,14 +2691,14 @@ dual_status_t dual_phase2_with_advanced_basis(i_t phase, delta_y_steepest_edge.resize(n); phase2_work_estimate += n; if (slack_basis) { - initialize_steepest_edge_norms_from_slack_basis( + phase2::initialize_steepest_edge_norms_from_slack_basis( basic_list, nonbasic_list, delta_y_steepest_edge); phase2_work_estimate += 2 * n; } else { std::fill(delta_y_steepest_edge.begin(), delta_y_steepest_edge.end(), -1); phase2_work_estimate += n; f_t steepest_edge_start = tic(); - i_t status = initialize_steepest_edge_norms( + 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; } @@ -2738,24 +2744,26 @@ dual_status_t dual_phase2_with_advanced_basis(i_t phase, delta_z_indices.reserve(n); phase2_work_estimate += n; - reset_basis_mark(basic_list, nonbasic_list, basic_mark, nonbasic_mark, phase2_work_estimate); + phase2::reset_basis_mark( + basic_list, nonbasic_list, basic_mark, nonbasic_mark, phase2_work_estimate); std::vector bounded_variables(n, 0); - compute_bounded_info(lp.lower, lp.upper, bounded_variables); + phase2::compute_bounded_info(lp.lower, lp.upper, bounded_variables); phase2_work_estimate += 4 * n; f_t primal_infeasibility; - f_t primal_infeasibility_squared = compute_initial_primal_infeasibilities(lp, - settings, - basic_list, - x, - squared_infeasibilities, - infeasibility_indices, - primal_infeasibility); + f_t primal_infeasibility_squared = + phase2::compute_initial_primal_infeasibilities(lp, + settings, + basic_list, + x, + squared_infeasibilities, + infeasibility_indices, + primal_infeasibility); phase2_work_estimate += 4 * m + 2 * n; #ifdef CHECK_BASIC_INFEASIBILITIES - check_basic_infeasibilities(basic_list, basic_mark, infeasibility_indices, 0); + phase2::check_basic_infeasibilities(basic_list, basic_mark, infeasibility_indices, 0); #endif csr_matrix_t Arow(1, 1, 0); @@ -2785,7 +2793,7 @@ dual_status_t dual_phase2_with_advanced_basis(i_t phase, i_t num_refactors = 0; i_t total_bound_flips = 0; f_t delta_y_nz_percentage = 0.0; - phase2_timers_t timers(false); + phase2::phase2_timers_t timers(false); // Sparse vectors for main loop (declared outside loop for instrumentation) sparse_vector_t delta_y_sparse(m, 0); @@ -2831,20 +2839,20 @@ dual_status_t dual_phase2_with_advanced_basis(i_t phase, { PHASE2_NVTX_RANGE("DualSimplex::pricing"); if (settings.use_steepest_edge_pricing) { - leaving_index = steepest_edge_pricing_with_infeasibilities(lp, - settings, - x, - delta_y_steepest_edge, - basic_mark, - squared_infeasibilities, - infeasibility_indices, - direction, - basic_leaving_index, - max_val, - phase2_work_estimate); + leaving_index = phase2::steepest_edge_pricing_with_infeasibilities(lp, + settings, + x, + delta_y_steepest_edge, + basic_mark, + squared_infeasibilities, + infeasibility_indices, + direction, + basic_leaving_index, + max_val, + phase2_work_estimate); } else { // Max infeasibility pricing - leaving_index = phase2_pricing( + leaving_index = phase2::phase2_pricing( lp, settings, x, basic_list, direction, basic_leaving_index, primal_infeasibility); } } @@ -2881,13 +2889,14 @@ dual_status_t dual_phase2_with_advanced_basis(i_t phase, #endif #ifdef CHECK_PRIMAL_INFEASIBILITIES - primal_infeasibility_squared = compute_initial_primal_infeasibilities(lp, - settings, - basic_list, - x, - squared_infeasibilities, - infeasibility_indices, - primal_infeasibility); + primal_infeasibility_squared = + phase2::compute_initial_primal_infeasibilities(lp, + settings, + basic_list, + x, + squared_infeasibilities, + infeasibility_indices, + primal_infeasibility); if (primal_infeasibility > settings.primal_tol) { const i_t nz = infeasibility_indices.size(); for (i_t k = 0; k < nz; ++k) { @@ -2931,21 +2940,21 @@ dual_status_t dual_phase2_with_advanced_basis(i_t phase, if (refactor_status > 0) { return dual_status_t::NUMERICAL; } refactor_work = ft.work_estimate() - refactor_start_work; - reset_basis_mark( + phase2::reset_basis_mark( basic_list, nonbasic_list, basic_mark, nonbasic_mark, phase2_work_estimate); compute_initial_nonbasic_end(basic_mark, Arow, nonbasic_end); - compute_primal_solution_from_basis( + phase2::compute_primal_solution_from_basis( lp, ft, basic_list, nonbasic_list, vstatus, x, xB_workspace, phase2_work_estimate); primal_infeasibility_squared = - compute_initial_primal_infeasibilities(lp, - settings, - basic_list, - x, - squared_infeasibilities, - infeasibility_indices, - primal_infeasibility); + phase2::compute_initial_primal_infeasibilities(lp, + settings, + basic_list, + x, + squared_infeasibilities, + infeasibility_indices, + primal_infeasibility); phase2_work_estimate += 4 * m + 2 * n; iterations_since_refactor = 0; solve_work = 0.0; @@ -2960,23 +2969,23 @@ dual_status_t dual_phase2_with_advanced_basis(i_t phase, } } - prepare_optimality(0, - primal_infeasibility, - lp, - settings, - ft, - objective, - basic_list, - nonbasic_list, - vstatus, - phase, - start_time, - max_val, - iter, - x, - y, - z, - sol); + phase2::prepare_optimality(0, + primal_infeasibility, + lp, + settings, + ft, + objective, + basic_list, + nonbasic_list, + vstatus, + phase, + start_time, + max_val, + iter, + x, + y, + z, + sol); status = dual_status_t::OPTIMAL; break; } @@ -2995,7 +3004,7 @@ dual_status_t dual_phase2_with_advanced_basis(i_t phase, f_t btran_start_work = ft.work_estimate(); { PHASE2_NVTX_RANGE("DualSimplex::btran"); - compute_delta_y(ft, basic_leaving_index, direction, delta_y_sparse, UTsol_sparse); + phase2::compute_delta_y(ft, basic_leaving_index, direction, delta_y_sparse, UTsol_sparse); } timers.btran_time += timers.stop_timer(); solve_work += (ft.work_estimate() - btran_start_work); @@ -3070,7 +3079,7 @@ dual_status_t dual_phase2_with_advanced_basis(i_t phase, std::vector zeros(n, 0.0); std::vector delta_y_dense(m); delta_y_sparse.to_dense(delta_y_dense); - compute_dual_residual(lp.A, zeros, delta_y_dense, delta_z, dual_residual); + phase2::compute_dual_residual(lp.A, zeros, delta_y_dense, delta_z, dual_residual); // || A'*delta_y + delta_z ||_inf f_t dual_residual_norm = vector_norm_inf(dual_residual); settings.log.printf( @@ -3086,15 +3095,15 @@ dual_status_t dual_phase2_with_advanced_basis(i_t phase, { PHASE2_NVTX_RANGE("DualSimplex::ratio_test"); if (harris_ratio) { - f_t max_step_length = first_stage_harris(lp, vstatus, nonbasic_list, z, delta_z); - entering_index = second_stage_harris(lp, - vstatus, - nonbasic_list, - z, - delta_z, - max_step_length, - step_length, - nonbasic_entering_index); + f_t max_step_length = phase2::first_stage_harris(lp, vstatus, nonbasic_list, z, delta_z); + entering_index = phase2::second_stage_harris(lp, + vstatus, + nonbasic_list, + z, + delta_z, + max_step_length, + step_length, + nonbasic_entering_index); } else if (bound_flip_ratio) { timers.start_timer(); f_t slope = direction == 1 ? (lp.lower[leaving_index] - x[leaving_index]) @@ -3121,7 +3130,7 @@ dual_status_t dual_phase2_with_advanced_basis(i_t phase, } timers.bfrt_time += timers.stop_timer(); } else { - entering_index = phase2_ratio_test( + entering_index = phase2::phase2_ratio_test( lp, settings, vstatus, nonbasic_list, z, delta_z, step_length, nonbasic_entering_index); } } @@ -3130,7 +3139,7 @@ dual_status_t dual_phase2_with_advanced_basis(i_t phase, 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); - f_t perturbation = amount_of_perturbation(lp, objective); + f_t perturbation = phase2::amount_of_perturbation(lp, objective); phase2_work_estimate += 2 * n; if (perturbation > 0.0 && phase == 2) { @@ -3138,10 +3147,10 @@ dual_status_t dual_phase2_with_advanced_basis(i_t phase, std::vector unperturbed_y(m); std::vector unperturbed_z(n); phase2_work_estimate += m + n; - compute_dual_solution_from_basis( + phase2::compute_dual_solution_from_basis( lp, ft, basic_list, nonbasic_list, unperturbed_y, unperturbed_z, phase2_work_estimate); { - const f_t dual_infeas = dual_infeasibility( + const f_t dual_infeas = phase2::dual_infeasibility( lp, settings, vstatus, unperturbed_z, settings.tight_tol, settings.dual_tol); phase2_work_estimate += 3 * n; settings.log.printf("Dual infeasibility after removing perturbation %e\n", dual_infeas); @@ -3154,49 +3163,49 @@ dual_status_t dual_phase2_with_advanced_basis(i_t phase, std::vector unperturbed_x(n); phase2_work_estimate += n; - compute_primal_solution_from_basis(lp, - ft, - basic_list, - nonbasic_list, - vstatus, - unperturbed_x, - xB_workspace, - phase2_work_estimate); + phase2::compute_primal_solution_from_basis(lp, + ft, + basic_list, + nonbasic_list, + vstatus, + unperturbed_x, + xB_workspace, + phase2_work_estimate); x = unperturbed_x; primal_infeasibility_squared = - compute_initial_primal_infeasibilities(lp, - settings, - basic_list, - x, - squared_infeasibilities, - infeasibility_indices, - primal_infeasibility); + phase2::compute_initial_primal_infeasibilities(lp, + settings, + basic_list, + x, + squared_infeasibilities, + infeasibility_indices, + primal_infeasibility); phase2_work_estimate += 4 * m + 2 * n; settings.log.printf("Updated primal infeasibility: %e\n", primal_infeasibility); objective = lp.objective; phase2_work_estimate += 2 * n; // Need to reset the objective value, since we have recomputed x - obj = compute_perturbed_objective(objective, x); + obj = phase2::compute_perturbed_objective(objective, x); phase2_work_estimate += 2 * n; if (dual_infeas <= settings.dual_tol && primal_infeasibility <= settings.primal_tol) { - prepare_optimality(1, - primal_infeasibility, - lp, - settings, - ft, - objective, - basic_list, - nonbasic_list, - vstatus, - phase, - start_time, - max_val, - iter, - x, - y, - z, - sol); + phase2::prepare_optimality(1, + primal_infeasibility, + lp, + settings, + ft, + objective, + basic_list, + nonbasic_list, + vstatus, + phase, + start_time, + max_val, + iter, + x, + y, + z, + sol); status = dual_status_t::OPTIMAL; break; } @@ -3204,54 +3213,55 @@ dual_status_t dual_phase2_with_advanced_basis(i_t phase, "Continuing with perturbation removed and steepest edge norms reset\n"); // Clear delta_z before restarting the iteration phase2_work_estimate += 3 * delta_z_indices.size(); - clear_delta_z(entering_index, leaving_index, delta_z_mark, delta_z_indices, delta_z); + phase2::clear_delta_z( + entering_index, leaving_index, delta_z_mark, delta_z_indices, delta_z); continue; } else { std::vector unperturbed_x(n); phase2_work_estimate += n; - compute_primal_solution_from_basis(lp, - ft, - basic_list, - nonbasic_list, - vstatus, - unperturbed_x, - xB_workspace, - phase2_work_estimate); + phase2::compute_primal_solution_from_basis(lp, + ft, + basic_list, + nonbasic_list, + vstatus, + unperturbed_x, + xB_workspace, + phase2_work_estimate); x = unperturbed_x; phase2_work_estimate += 2 * n; primal_infeasibility_squared = - compute_initial_primal_infeasibilities(lp, - settings, - basic_list, - x, - squared_infeasibilities, - infeasibility_indices, - primal_infeasibility); + phase2::compute_initial_primal_infeasibilities(lp, + settings, + basic_list, + x, + squared_infeasibilities, + infeasibility_indices, + primal_infeasibility); phase2_work_estimate += 4 * m + 2 * n; - const f_t orig_dual_infeas = - dual_infeasibility(lp, settings, vstatus, z, settings.tight_tol, settings.dual_tol); + const f_t orig_dual_infeas = phase2::dual_infeasibility( + lp, settings, vstatus, z, settings.tight_tol, settings.dual_tol); phase2_work_estimate += 3 * n; if (primal_infeasibility <= settings.primal_tol && orig_dual_infeas <= settings.dual_tol) { - prepare_optimality(2, - primal_infeasibility, - lp, - settings, - ft, - objective, - basic_list, - nonbasic_list, - vstatus, - phase, - start_time, - max_val, - iter, - x, - y, - z, - sol); + phase2::prepare_optimality(2, + primal_infeasibility, + lp, + settings, + ft, + objective, + basic_list, + nonbasic_list, + vstatus, + phase, + start_time, + max_val, + iter, + x, + y, + z, + sol); status = dual_status_t::OPTIMAL; break; } @@ -3271,30 +3281,30 @@ dual_status_t dual_phase2_with_advanced_basis(i_t phase, delta_y_sparse.to_dense(my_delta_y); // TODO(CMM): Do I use the perturbed or unperturbed objective? - const f_t obj_val = compute_perturbed_objective(objective, x); - compute_farkas_certificate(lp, - settings, - vstatus, - x, - y, - z, - my_delta_y, - delta_z, - direction, - leaving_index, - obj_val, - farkas_y, - farkas_zl, - farkas_zu, - farkas_constant); + const f_t obj_val = phase2::compute_perturbed_objective(objective, x); + phase2::compute_farkas_certificate(lp, + settings, + vstatus, + x, + y, + z, + my_delta_y, + delta_z, + direction, + leaving_index, + obj_val, + farkas_y, + farkas_zl, + farkas_zu, + farkas_constant); } } const f_t dual_infeas = - dual_infeasibility(lp, settings, vstatus, z, settings.tight_tol, settings.dual_tol); + 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 = simplex::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()); @@ -3311,14 +3321,14 @@ dual_status_t dual_phase2_with_advanced_basis(i_t phase, // Update dual variables // y <- y + steplength * delta_y // z <- z + steplength * delta_z - i_t update_dual_variables_status = update_dual_variables(delta_y_sparse, - delta_z_indices, - delta_z, - step_length, - leaving_index, - y, - z, - phase2_work_estimate); + i_t update_dual_variables_status = phase2::update_dual_variables(delta_y_sparse, + delta_z_indices, + delta_z, + step_length, + leaving_index, + y, + z, + 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; @@ -3327,7 +3337,7 @@ dual_status_t dual_phase2_with_advanced_basis(i_t phase, #ifdef COMPUTE_DUAL_RESIDUAL std::vector dual_res1; - compute_dual_residual(lp.A, objective, y, z, dual_res1); + phase2::compute_dual_residual(lp.A, objective, y, z, dual_res1); f_t dual_res_norm = vector_norm_inf(dual_res1); if (dual_res_norm > settings.dual_tol) { settings.log.printf("|| A'*y + z - c || %e steplength %e\n", dual_res_norm, step_length); @@ -3336,20 +3346,20 @@ dual_status_t dual_phase2_with_advanced_basis(i_t phase, timers.start_timer(); // Update primal variable - const i_t num_flipped = flip_bounds(lp, - settings, - bounded_variables, - objective, - z, - delta_z_indices, - nonbasic_list, - entering_index, - vstatus, - delta_x_flip, - atilde_mark, - atilde, - atilde_index, - phase2_work_estimate); + const i_t num_flipped = phase2::flip_bounds(lp, + settings, + bounded_variables, + objective, + z, + delta_z_indices, + nonbasic_list, + entering_index, + vstatus, + delta_x_flip, + atilde_mark, + atilde, + atilde_index, + phase2_work_estimate); timers.flip_time += timers.stop_timer(); total_bound_flips += num_flipped; @@ -3357,17 +3367,17 @@ dual_status_t dual_phase2_with_advanced_basis(i_t phase, delta_xB_0_sparse.clear(); if (num_flipped > 0) { timers.start_timer(); - adjust_for_flips(ft, - basic_list, - delta_z_indices, - atilde_index, - atilde, - atilde_mark, - atilde_sparse, - delta_xB_0_sparse, - delta_x_flip, - x, - phase2_work_estimate); + phase2::adjust_for_flips(ft, + basic_list, + delta_z_indices, + atilde_index, + atilde, + atilde_mark, + atilde_sparse, + delta_xB_0_sparse, + delta_x_flip, + x, + phase2_work_estimate); timers.ftran_time += timers.stop_timer(); } @@ -3378,21 +3388,21 @@ dual_status_t dual_phase2_with_advanced_basis(i_t phase, f_t ftran_start_work = ft.work_estimate(); { PHASE2_NVTX_RANGE("DualSimplex::ftran"); - if (compute_delta_x(lp, - ft, - entering_index, - leaving_index, - basic_leaving_index, - direction, - basic_list, - delta_x_flip, - rhs_sparse, - delta_z, - x, - utilde_sparse, - scaled_delta_xB_sparse, - delta_x, - phase2_work_estimate) == -1) { + if (phase2::compute_delta_x(lp, + ft, + entering_index, + leaving_index, + basic_leaving_index, + direction, + basic_list, + delta_x_flip, + rhs_sparse, + delta_z, + x, + utilde_sparse, + scaled_delta_xB_sparse, + delta_x, + phase2_work_estimate) == -1) { settings.log.printf("Failed to compute delta_x. Iter %d\n", iter); return dual_status_t::NUMERICAL; } @@ -3412,19 +3422,19 @@ dual_status_t dual_phase2_with_advanced_basis(i_t phase, timers.start_timer(); f_t se_norms_start_work = ft.work_estimate(); - const i_t steepest_edge_status = update_steepest_edge_norms(settings, - basic_list, - ft, - direction, - delta_y_sparse, - steepest_edge_norm_check, - scaled_delta_xB_sparse, - basic_leaving_index, - entering_index, - v, - v_sparse, - delta_y_steepest_edge, - phase2_work_estimate); + const i_t steepest_edge_status = phase2::update_steepest_edge_norms(settings, + basic_list, + ft, + direction, + delta_y_sparse, + steepest_edge_norm_check, + scaled_delta_xB_sparse, + basic_leaving_index, + entering_index, + v, + v_sparse, + delta_y_steepest_edge, + phase2_work_estimate); #ifdef STEEPEST_EDGE_DEBUG if (steepest_edge_status == -1) { settings.log.printf("Num updates %d\n", ft.num_updates()); @@ -3441,7 +3451,7 @@ dual_status_t dual_phase2_with_advanced_basis(i_t phase, timers.start_timer(); // x <- x + delta_x - update_primal_variables( + phase2::update_primal_variables( scaled_delta_xB_sparse, basic_list, delta_x, entering_index, x, phase2_work_estimate); timers.vector_time += timers.stop_timer(); @@ -3457,77 +3467,77 @@ dual_status_t dual_phase2_with_advanced_basis(i_t phase, timers.start_timer(); // TODO(CMM): Do I also need to update the objective due to the bound flips? // TODO(CMM): I'm using the unperturbed objective here, should this be the perturbed objective? - update_objective(basic_list, - scaled_delta_xB_sparse.i, - lp.objective, - delta_x, - entering_index, - obj, - phase2_work_estimate); + phase2::update_objective(basic_list, + scaled_delta_xB_sparse.i, + lp.objective, + delta_x, + entering_index, + obj, + phase2_work_estimate); timers.objective_time += timers.stop_timer(); timers.start_timer(); // Update primal infeasibilities due to changes in basic variables // from flipping bounds #ifdef CHECK_BASIC_INFEASIBILITIES - check_basic_infeasibilities(basic_list, basic_mark, infeasibility_indices, 2); + phase2::check_basic_infeasibilities(basic_list, basic_mark, infeasibility_indices, 2); #endif - bool needs_cleanup = update_primal_infeasibilities(lp, - settings, - basic_list, - x, - entering_index, - leaving_index, - delta_xB_0_sparse.i, - squared_infeasibilities, - infeasibility_indices, - primal_infeasibility_squared, - phase2_work_estimate); + bool needs_cleanup = phase2::update_primal_infeasibilities(lp, + settings, + basic_list, + x, + entering_index, + leaving_index, + delta_xB_0_sparse.i, + squared_infeasibilities, + infeasibility_indices, + primal_infeasibility_squared, + phase2_work_estimate); // Update primal infeasibilities due to changes in basic variables // from the leaving and entering variables - needs_cleanup |= update_primal_infeasibilities(lp, - settings, - basic_list, - x, - entering_index, - leaving_index, - scaled_delta_xB_sparse.i, - squared_infeasibilities, - infeasibility_indices, - primal_infeasibility_squared, - phase2_work_estimate); + needs_cleanup |= phase2::update_primal_infeasibilities(lp, + settings, + basic_list, + x, + entering_index, + leaving_index, + scaled_delta_xB_sparse.i, + squared_infeasibilities, + infeasibility_indices, + primal_infeasibility_squared, + phase2_work_estimate); // Update the entering variable { const f_t old_val = squared_infeasibilities[entering_index]; - update_single_primal_infeasibility(lp.lower, - lp.upper, - x, - settings.primal_tol, - squared_infeasibilities, - infeasibility_indices, - entering_index, - primal_infeasibility_squared); + phase2::update_single_primal_infeasibility(lp.lower, + lp.upper, + x, + settings.primal_tol, + squared_infeasibilities, + infeasibility_indices, + entering_index, + primal_infeasibility_squared); needs_cleanup |= (old_val != 0.0 && squared_infeasibilities[entering_index] == 0.0); } if (needs_cleanup) { - clean_up_infeasibilities( + phase2::clean_up_infeasibilities( squared_infeasibilities, infeasibility_indices, phase2_work_estimate); } #if CHECK_PRIMAL_INFEASIBILITIES - check_primal_infeasibilities( + phase2::check_primal_infeasibilities( lp, settings, basic_list, x, squared_infeasibilities, infeasibility_indices); #endif timers.update_infeasibility_time += timers.stop_timer(); // Clear delta_x - clear_delta_x( + phase2::clear_delta_x( basic_list, entering_index, scaled_delta_xB_sparse, delta_x, phase2_work_estimate); timers.start_timer(); f_t sum_perturb = 0.0; - compute_perturbation( + phase2::compute_perturbation( lp, settings, delta_z_indices, z, objective, sum_perturb, phase2_work_estimate); timers.perturb_time += timers.stop_timer(); @@ -3549,7 +3559,7 @@ dual_status_t dual_phase2_with_advanced_basis(i_t phase, leaving_index, entering_index, lp.A, row_mark, nonbasic_end, Arow, phase2_work_estimate); #ifdef CHECK_BASIC_INFEASIBILITIES - check_basic_infeasibilities(basic_list, basic_mark, infeasibility_indices, 5); + phase2::check_basic_infeasibilities(basic_list, basic_mark, infeasibility_indices, 5); #endif timers.start_timer(); @@ -3565,7 +3575,7 @@ dual_status_t dual_phase2_with_advanced_basis(i_t phase, if (!should_refactor) { i_t recommend_refactor = ft.update(utilde_sparse, UTsol_sparse, basic_leaving_index); #ifdef CHECK_UPDATE - check_update(lp, settings, ft, basic_list, basic_leaving_index); + phase2::check_update(lp, settings, ft, basic_list, basic_leaving_index); #endif should_refactor = recommend_refactor == 1; timers.lu_update_time += timers.stop_timer(); @@ -3573,7 +3583,7 @@ dual_status_t dual_phase2_with_advanced_basis(i_t phase, } #ifdef CHECK_BASIC_INFEASIBILITIES - check_basic_infeasibilities(basic_list, basic_mark, infeasibility_indices, 6); + phase2::check_basic_infeasibilities(basic_list, basic_mark, infeasibility_indices, 6); #endif if (should_refactor) { PHASE2_NVTX_RANGE("DualSimplex::refactorization"); @@ -3614,37 +3624,37 @@ dual_status_t dual_phase2_with_advanced_basis(i_t phase, } refactor_work = ft.work_estimate() - refactor_start_work; - reset_basis_mark( + phase2::reset_basis_mark( basic_list, nonbasic_list, basic_mark, nonbasic_mark, phase2_work_estimate); compute_initial_nonbasic_end(basic_mark, Arow, nonbasic_end); if (should_recompute_x) { std::vector unperturbed_x(n); phase2_work_estimate += n; - compute_primal_solution_from_basis(lp, - ft, - basic_list, - nonbasic_list, - vstatus, - unperturbed_x, - xB_workspace, - phase2_work_estimate); + phase2::compute_primal_solution_from_basis(lp, + ft, + basic_list, + nonbasic_list, + vstatus, + unperturbed_x, + xB_workspace, + phase2_work_estimate); x = unperturbed_x; phase2_work_estimate += 2 * n; } primal_infeasibility_squared = - compute_initial_primal_infeasibilities(lp, - settings, - basic_list, - x, - squared_infeasibilities, - infeasibility_indices, - primal_infeasibility); + phase2::compute_initial_primal_infeasibilities(lp, + settings, + basic_list, + x, + squared_infeasibilities, + infeasibility_indices, + primal_infeasibility); phase2_work_estimate += 4 * m + 2 * n; iterations_since_refactor = 0; solve_work = 0.0; } #ifdef CHECK_BASIC_INFEASIBILITIES - check_basic_infeasibilities(basic_list, basic_mark, infeasibility_indices, 7); + phase2::check_basic_infeasibilities(basic_list, basic_mark, infeasibility_indices, 7); #endif } timers.lu_factorization_time += timers.stop_timer(); @@ -3652,19 +3662,19 @@ dual_status_t dual_phase2_with_advanced_basis(i_t phase, #ifdef STEEPEST_EDGE_DEBUG if (iter < 100 || iter % 100 == 0)) { - check_steepest_edge_norms(settings, basic_list, ft, delta_y_steepest_edge); + phase2::check_steepest_edge_norms(settings, basic_list, ft, delta_y_steepest_edge); } #endif #ifdef CHECK_BASIS_MARK - check_basis_mark(settings, basic_list, nonbasic_list, basic_mark, nonbasic_mark); + phase2::check_basis_mark(settings, basic_list, nonbasic_list, basic_mark, nonbasic_mark); #endif iter++; // Clear delta_z phase2_work_estimate += 3 * delta_z_indices.size(); - clear_delta_z(entering_index, leaving_index, delta_z_mark, delta_z_indices, delta_z); + phase2::clear_delta_z(entering_index, leaving_index, delta_z_mark, delta_z_indices, delta_z); f_t now = toc(start_time); From ab50cfea27f05ce48a22407b063f04bc4fbc83b3 Mon Sep 17 00:00:00 2001 From: Miles Lubin Date: Thu, 25 Jun 2026 19:33:53 +0000 Subject: [PATCH 17/17] refactor: add targeted using-declarations per PR review Address reviewer suggestions: import frequently-/singly-used shared simplex names via 'using simplex::NAME;' instead of repeated qualification, in barrier.cu (vector_norm1 only -- vector_norm2/vector_norm_inf stay qualified since barrier defines shadowing device overloads), branch_and_bound.cpp, pseudo_costs.cpp, and cuts.cpp. Single-use imports included (bar lowered to 1). Header sparse_cholesky.cuh intentionally left fully-qualified. Co-Authored-By: Claude Opus 4.8 (1M context) Signed-off-by: Miles Lubin --- cpp/src/barrier/barrier.cu | 3 ++- cpp/src/branch_and_bound/branch_and_bound.cpp | 6 ++++-- cpp/src/branch_and_bound/pseudo_costs.cpp | 9 +++++--- cpp/src/cuts/cuts.cpp | 21 +++++++++++-------- 4 files changed, 24 insertions(+), 15 deletions(-) diff --git a/cpp/src/barrier/barrier.cu b/cpp/src/barrier/barrier.cu index f75bd58176..a1f493823d 100644 --- a/cpp/src/barrier/barrier.cu +++ b/cpp/src/barrier/barrier.cu @@ -66,6 +66,7 @@ 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, @@ -2352,7 +2353,7 @@ int barrier_solver_t::initial_point(iteration_data_t& data) // y = 0 data.y.set_scalar(0.0); - f_t epsilon = 1.0 + simplex::vector_norm1(lp.objective); + f_t epsilon = 1.0 + vector_norm1(lp.objective); // A^T y + z - E^T v - Q x = c // when y = 0, z - E^T v = c + Q x diff --git a/cpp/src/branch_and_bound/branch_and_bound.cpp b/cpp/src/branch_and_bound/branch_and_bound.cpp index dd89dc65d4..806f2850ce 100644 --- a/cpp/src/branch_and_bound/branch_and_bound.cpp +++ b/cpp/src/branch_and_bound/branch_and_bound.cpp @@ -61,6 +61,7 @@ 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; @@ -70,6 +71,7 @@ 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 { @@ -124,8 +126,8 @@ bool check_guess(const lp_problem_t& original_lp, bool feasible = false; std::vector residual(original_lp.num_rows); residual = original_lp.rhs; - simplex::matrix_vector_multiply(original_lp.A, 1.0, guess, -1.0, residual); - primal_error = simplex::vector_norm_inf(residual); + matrix_vector_multiply(original_lp.A, 1.0, guess, -1.0, residual); + primal_error = vector_norm_inf(residual); bound_error = 0.0; constexpr bool verbose = false; for (i_t j = 0; j < original_lp.num_cols; j++) { diff --git a/cpp/src/branch_and_bound/pseudo_costs.cpp b/cpp/src/branch_and_bound/pseudo_costs.cpp index 9e694bd865..baea370fa4 100644 --- a/cpp/src/branch_and_bound/pseudo_costs.cpp +++ b/cpp/src/branch_and_bound/pseudo_costs.cpp @@ -30,8 +30,10 @@ 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; @@ -40,6 +42,7 @@ using simplex::tic; using simplex::toc; using simplex::variable_status_t; using simplex::variable_type_t; +using simplex::vector_norm_inf; namespace { @@ -151,7 +154,7 @@ objective_change_estimate_t single_pivot_objective_change_estimate( dual_residual[j] -= lp.objective[j]; } simplex::matrix_transpose_vector_multiply(lp.A, 1.0, lp_solution.y, 1.0, dual_residual); - f_t dual_residual_norm = simplex::vector_norm_inf(dual_residual); + f_t dual_residual_norm = vector_norm_inf(dual_residual); settings.log.printf("Dual residual norm: %e\n", dual_residual_norm); } #endif @@ -570,7 +573,7 @@ simplex_problem_to_mps_data_model(const lp_problem_t& lp, original_root_soln_x.resize(n); // Remove slacks from A - 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; @@ -903,7 +906,7 @@ static void batch_pdlp_strong_branching_task( template static void batch_pdlp_reliability_branching_task( - simplex::logger_t& log, + logger_t& log, i_t rb_mode, i_t num_candidates, f_t start_time, diff --git a/cpp/src/cuts/cuts.cpp b/cpp/src/cuts/cuts.cpp index ec926cec84..2cc041d81a 100644 --- a/cpp/src/cuts/cuts.cpp +++ b/cpp/src/cuts/cuts.cpp @@ -38,11 +38,14 @@ 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 { @@ -607,12 +610,12 @@ f_t cut_pool_t::cut_orthogonality(i_t i, i_t j) const i_t j_end = cut_storage_.row_start[j + 1]; const i_t j_nz = j_end - j_start; - f_t dot = simplex::sparse_dot(cut_storage_.j.data() + i_start, - cut_storage_.x.data() + i_start, - i_nz, - cut_storage_.j.data() + j_start, - cut_storage_.x.data() + j_start, - j_nz); + f_t dot = sparse_dot(cut_storage_.j.data() + i_start, + cut_storage_.x.data() + i_start, + i_nz, + cut_storage_.j.data() + j_start, + cut_storage_.x.data() + j_start, + j_nz); f_t norm_i = cut_norms_[i]; f_t norm_j = cut_norms_[j]; @@ -3909,7 +3912,7 @@ void complemented_mixed_integer_rounding_cut_t::compute_initial_scores { const bool verbose = false; const i_t n = lp.num_cols; - const f_t obj_norm = simplex::vector_norm2(lp.objective); + const f_t obj_norm = vector_norm2(lp.objective); const f_t obj_denom = std::max(1.0, obj_norm); // Compute initial scores for all rows @@ -5488,7 +5491,7 @@ void read_saved_solution_for_cut_verification(const lp_problem_t& lp, std::vector residual = lp.rhs; matrix_vector_multiply(lp.A, 1.0, saved_solution, -1.0, residual); settings.log.printf("Saved solution: || A*x - b ||_inf %e\n", - simplex::vector_norm_inf(residual)); + vector_norm_inf(residual)); f_t infeas = 0; for (i_t j = 0; j < lp.num_cols; j++) { if (saved_solution[j] < lp.lower[j] - 1e-6) { @@ -5522,7 +5525,7 @@ void write_solution_for_cut_verification(const lp_problem_t& lp, std::vector residual = lp.rhs; matrix_vector_multiply(lp.A, 1.0, solution, -1.0, residual); - printf("|| A*x - b ||_inf %e\n", simplex::vector_norm_inf(residual)); + printf("|| A*x - b ||_inf %e\n", vector_norm_inf(residual)); auto hash_combine_f = [](size_t seed, f_t x) { seed ^= std::hash{}(x) + 0x9e3779b9 + (seed << 6) + (seed >> 2); return seed;