Main merge release/26.04 2

cpp/CMakeLists.txt

@@ -138,7 +138,8 @@ endif(BUILD_MSAN)
 # infrastructure files. Those files include abseil headers, and abseil's shared library
 # on conda-forge doesn't export Mutex::Dtor() in NDEBUG builds (abseil-cpp#1624).
 # Keeping NDEBUG defined for gRPC files makes the header inline an empty Dtor(),
-# avoiding the missing symbol at runtime.
+# avoiding the missing symbol at runtime.  Additionally, gRPC files are always
+# compiled with -DNDEBUG (see below) so Debug builds also avoid the missing symbol.
 if(DEFINE_ASSERT)
   add_definitions(-DASSERT_MODE)
   list(APPEND CUOPT_CUDA_FLAGS -UNDEBUG)
@@ -390,7 +391,7 @@ if(DEFINE_ASSERT)
 endif()
 
 # Add gRPC mapper files and generated protobuf sources
-list(APPEND CUOPT_SRC_FILES
+set(GRPC_INFRA_FILES
   ${PROTO_SRCS}
   ${GRPC_PROTO_SRCS}
   ${GRPC_SERVICE_SRCS}
@@ -401,6 +402,15 @@ list(APPEND CUOPT_SRC_FILES
   src/grpc/client/grpc_client.cpp
   src/grpc/client/solve_remote.cpp
 )
+list(APPEND CUOPT_SRC_FILES ${GRPC_INFRA_FILES})
+
+# Always keep NDEBUG defined for gRPC infrastructure files so that abseil
+# headers inline Mutex::Dtor() instead of emitting an external call.
+# The conda-forge abseil shared library is built with NDEBUG and does not
+# export that symbol (abseil-cpp#1624).  Without this, Debug builds fail
+# at runtime with "undefined symbol: absl::…::Mutex::Dtor".
+set_property(SOURCE ${GRPC_INFRA_FILES} DIRECTORY ${CMAKE_SOURCE_DIR}
+  APPEND PROPERTY COMPILE_OPTIONS "-DNDEBUG")
 
 add_library(cuopt SHARED
   ${CUOPT_SRC_FILES}

cpp/cuopt_cli.cpp

@@ -13,6 +13,7 @@
 #include <cuopt/linear_programming/solve.hpp>
 #include <mps_parser/parser.hpp>
 #include <utilities/logger.hpp>
+#include <utilities/timer.hpp>
 
 #include <raft/core/device_setter.hpp>
 #include <raft/core/handle.hpp>
@@ -85,30 +86,22 @@ inline cuopt::init_logger_t dummy_logger(
  * @brief Run a single file
  * @param file_path Path to the MPS format input file containing the optimization problem
  * @param initial_solution_file Path to initial solution file in SOL format
- * @param settings_strings Map of solver parameters
+ * @param settings Merged solver settings (config file loaded in main, then CLI overrides applied)
  */
 int run_single_file(const std::string& file_path,
                     const std::string& initial_solution_file,
                     bool solve_relaxation,
-                    const std::map<std::string, std::string>& settings_strings)
+                    cuopt::linear_programming::solver_settings_t<int, double>& settings)
 {
-  cuopt::linear_programming::solver_settings_t<int, double> settings;
-
-  try {
-    for (auto& [key, val] : settings_strings) {
-      settings.set_parameter_from_string(key, val);
-    }
-  } catch (const std::exception& e) {
-    auto log = dummy_logger(settings);
-    CUOPT_LOG_ERROR("Error: %s", e.what());
-    return -1;
-  }
+  cuopt::init_logger_t log(settings.get_parameter<std::string>(CUOPT_LOG_FILE),
+                           settings.get_parameter<bool>(CUOPT_LOG_TO_CONSOLE));
 
   std::string base_filename = file_path.substr(file_path.find_last_of("/\\") + 1);
 
   constexpr bool input_mps_strict = false;
   cuopt::mps_parser::mps_data_model_t<int, double> mps_data_model;
   bool parsing_failed = false;
+  auto timer          = cuopt::timer_t(settings.get_parameter<double>(CUOPT_TIME_LIMIT));
   {
     CUOPT_LOG_INFO("Reading file %s", base_filename.c_str());
     try {
@@ -123,6 +116,7 @@ int run_single_file(const std::string& file_path,
     CUOPT_LOG_ERROR("Parsing MPS failed. Exiting!");
     return -1;
   }
+  CUOPT_LOG_INFO("Read file %s in %.2f seconds", base_filename.c_str(), timer.elapsed_time());
 
   // Determine memory backend and create problem using interface
   // Create handle only for GPU memory backend (avoid CUDA init on CPU-only hosts)
@@ -259,6 +253,21 @@ int set_cuda_module_loading(int argc, char* argv[])
  */
 int main(int argc, char* argv[])
 {
+  // Handle dump flags before argparse so no other args are required
+  for (int i = 1; i < argc; ++i) {
+    std::string arg = argv[i];
+    if (arg == "--dump-hyper-params") {
+      cuopt::linear_programming::solver_settings_t<int, double> settings;
+      settings.dump_parameters_to_file("/dev/stdout", true);
+      return 0;
+    }
+    if (arg == "--dump-params") {
+      cuopt::linear_programming::solver_settings_t<int, double> settings;
+      settings.dump_parameters_to_file("/dev/stdout", false);
+      return 0;
+    }
+  }
+
   if (set_cuda_module_loading(argc, argv) != 0) { return 1; }
 
   // Get the version string from the version_config.hpp file
@@ -287,6 +296,20 @@ int main(int argc, char* argv[])
     .default_value(true)
     .implicit_value(true);
 
+  program.add_argument("--params-file")
+    .help("path to parameter config file (key = value format, supports all parameters)")
+    .default_value(std::string(""));
+
+  program.add_argument("--dump-hyper-params")
+    .help("print hyper-parameters only in config file format and exit")
+    .default_value(false)
+    .implicit_value(true);
+
+  program.add_argument("--dump-params")
+    .help("print all parameters in config file format and exit")
+    .default_value(false)
+    .implicit_value(true);
+
   std::map<std::string, std::string> arg_name_to_param_name;
 
   // Register --pdlp-precision with string-to-int mapping so that it flows
@@ -312,37 +335,39 @@ int main(int argc, char* argv[])
       std::string arg_name = param_name_to_arg_name(param.param_name);
       // handle duplicate parameters appearing in MIP and LP settings
       if (arg_name_to_param_name.count(arg_name) == 0) {
-        program.add_argument(arg_name.c_str()).default_value(param.default_value);
+        auto& arg = program.add_argument(arg_name.c_str()).default_value(param.default_value);
+        if (param.param_name.find("hyper_") != std::string::npos) { arg.hidden(); }
         arg_name_to_param_name[arg_name] = param.param_name;
       }
     }
 
     for (auto& param : double_params) {
       std::string arg_name = param_name_to_arg_name(param.param_name);
-      // handle duplicate parameters appearing in MIP and LP settings
       if (arg_name_to_param_name.count(arg_name) == 0) {
-        program.add_argument(arg_name.c_str()).default_value(param.default_value);
+        auto& arg = program.add_argument(arg_name.c_str()).default_value(param.default_value);
+        if (param.param_name.find("hyper_") != std::string::npos) { arg.hidden(); }
         arg_name_to_param_name[arg_name] = param.param_name;
       }
     }
 
     for (auto& param : bool_params) {
       std::string arg_name = param_name_to_arg_name(param.param_name);
       if (arg_name_to_param_name.count(arg_name) == 0) {
-        program.add_argument(arg_name.c_str()).default_value(param.default_value);
+        auto& arg = program.add_argument(arg_name.c_str()).default_value(param.default_value);
+        if (param.param_name.find("hyper_") != std::string::npos) { arg.hidden(); }
         arg_name_to_param_name[arg_name] = param.param_name;
       }
     }
 
     for (auto& param : string_params) {
       std::string arg_name = param_name_to_arg_name(param.param_name);
-      // handle duplicate parameters appearing in MIP and LP settings
       if (arg_name_to_param_name.count(arg_name) == 0) {
-        program.add_argument(arg_name.c_str()).default_value(param.default_value);
+        auto& arg = program.add_argument(arg_name.c_str()).default_value(param.default_value);
+        if (param.param_name.find("hyper_") != std::string::npos) { arg.hidden(); }
         arg_name_to_param_name[arg_name] = param.param_name;
       }
-    }  // done with solver settings
-  }
+    }
+  }  // done with solver settings
 
   // Parse arguments
   try {
@@ -374,16 +399,26 @@ int main(int argc, char* argv[])
 
   const auto initial_solution_file = program.get<std::string>("--initial-solution");
   const auto solve_relaxation      = program.get<bool>("--relaxation");
+  const auto params_file           = program.get<std::string>("--params-file");
+
+  cuopt::linear_programming::solver_settings_t<int, double> settings;
+  try {
+    if (!params_file.empty()) { settings.load_parameters_from_file(params_file); }
+    for (auto& [key, val] : settings_strings) {
+      settings.set_parameter_from_string(key, val);
+    }
+  } catch (const std::exception& e) {
+    auto log = dummy_logger(settings);
+    CUOPT_LOG_ERROR("Error: %s", e.what());
+    return -1;
+  }
 
   // Only initialize CUDA resources if using GPU memory backend (not remote execution)
   auto memory_backend = cuopt::linear_programming::get_memory_backend_type();
   std::vector<std::shared_ptr<rmm::mr::device_memory_resource>> memory_resources;
 
   if (memory_backend == cuopt::linear_programming::memory_backend_t::GPU) {
-    // All arguments are parsed as string, default values are parsed as int if unused.
-    const auto num_gpus = program.is_used("--num-gpus")
-                            ? std::stoi(program.get<std::string>("--num-gpus"))
-                            : program.get<int>("--num-gpus");
+    const int num_gpus = settings.get_parameter<int>(CUOPT_NUM_GPUS);
 
     for (int i = 0; i < std::min(raft::device_setter::get_device_count(), num_gpus); ++i) {
       RAFT_CUDA_TRY(cudaSetDevice(i));
@@ -393,5 +428,5 @@ int main(int argc, char* argv[])
     RAFT_CUDA_TRY(cudaSetDevice(0));
   }
 
-  return run_single_file(file_name, initial_solution_file, solve_relaxation, settings_strings);
+  return run_single_file(file_name, initial_solution_file, solve_relaxation, settings);
 }

cpp/include/cuopt/linear_programming/constants.h

@@ -20,64 +20,90 @@
 #define CUOPT_INSTANTIATE_INT64  0
 
 /* @brief LP/MIP parameter string constants */
-#define CUOPT_ABSOLUTE_DUAL_TOLERANCE         "absolute_dual_tolerance"
-#define CUOPT_RELATIVE_DUAL_TOLERANCE         "relative_dual_tolerance"
-#define CUOPT_ABSOLUTE_PRIMAL_TOLERANCE       "absolute_primal_tolerance"
-#define CUOPT_RELATIVE_PRIMAL_TOLERANCE       "relative_primal_tolerance"
-#define CUOPT_ABSOLUTE_GAP_TOLERANCE          "absolute_gap_tolerance"
-#define CUOPT_RELATIVE_GAP_TOLERANCE          "relative_gap_tolerance"
-#define CUOPT_INFEASIBILITY_DETECTION         "infeasibility_detection"
-#define CUOPT_STRICT_INFEASIBILITY            "strict_infeasibility"
-#define CUOPT_PRIMAL_INFEASIBLE_TOLERANCE     "primal_infeasible_tolerance"
-#define CUOPT_DUAL_INFEASIBLE_TOLERANCE       "dual_infeasible_tolerance"
-#define CUOPT_ITERATION_LIMIT                 "iteration_limit"
-#define CUOPT_TIME_LIMIT                      "time_limit"
-#define CUOPT_WORK_LIMIT                      "work_limit"
-#define CUOPT_PDLP_SOLVER_MODE                "pdlp_solver_mode"
-#define CUOPT_METHOD                          "method"
-#define CUOPT_PER_CONSTRAINT_RESIDUAL         "per_constraint_residual"
-#define CUOPT_SAVE_BEST_PRIMAL_SO_FAR         "save_best_primal_so_far"
-#define CUOPT_FIRST_PRIMAL_FEASIBLE           "first_primal_feasible"
-#define CUOPT_LOG_FILE                        "log_file"
-#define CUOPT_LOG_TO_CONSOLE                  "log_to_console"
-#define CUOPT_CROSSOVER                       "crossover"
-#define CUOPT_FOLDING                         "folding"
-#define CUOPT_AUGMENTED                       "augmented"
-#define CUOPT_DUALIZE                         "dualize"
-#define CUOPT_ORDERING                        "ordering"
-#define CUOPT_BARRIER_DUAL_INITIAL_POINT      "barrier_dual_initial_point"
-#define CUOPT_ELIMINATE_DENSE_COLUMNS         "eliminate_dense_columns"
-#define CUOPT_CUDSS_DETERMINISTIC             "cudss_deterministic"
-#define CUOPT_PRESOLVE                        "presolve"
-#define CUOPT_DUAL_POSTSOLVE                  "dual_postsolve"
-#define CUOPT_MIP_DETERMINISM_MODE            "mip_determinism_mode"
-#define CUOPT_MIP_ABSOLUTE_TOLERANCE          "mip_absolute_tolerance"
-#define CUOPT_MIP_RELATIVE_TOLERANCE          "mip_relative_tolerance"
-#define CUOPT_MIP_INTEGRALITY_TOLERANCE       "mip_integrality_tolerance"
-#define CUOPT_MIP_ABSOLUTE_GAP                "mip_absolute_gap"
-#define CUOPT_MIP_RELATIVE_GAP                "mip_relative_gap"
-#define CUOPT_MIP_HEURISTICS_ONLY             "mip_heuristics_only"
-#define CUOPT_MIP_SCALING                     "mip_scaling"
-#define CUOPT_MIP_PRESOLVE                    "mip_presolve"
-#define CUOPT_MIP_RELIABILITY_BRANCHING       "mip_reliability_branching"
-#define CUOPT_MIP_CUT_PASSES                  "mip_cut_passes"
-#define CUOPT_MIP_MIXED_INTEGER_ROUNDING_CUTS "mip_mixed_integer_rounding_cuts"
-#define CUOPT_MIP_MIXED_INTEGER_GOMORY_CUTS   "mip_mixed_integer_gomory_cuts"
-#define CUOPT_MIP_KNAPSACK_CUTS               "mip_knapsack_cuts"
-#define CUOPT_MIP_IMPLIED_BOUND_CUTS          "mip_implied_bound_cuts"
-#define CUOPT_MIP_CLIQUE_CUTS                 "mip_clique_cuts"
-#define CUOPT_MIP_STRONG_CHVATAL_GOMORY_CUTS  "mip_strong_chvatal_gomory_cuts"
-#define CUOPT_MIP_REDUCED_COST_STRENGTHENING  "mip_reduced_cost_strengthening"
-#define CUOPT_MIP_CUT_CHANGE_THRESHOLD        "mip_cut_change_threshold"
-#define CUOPT_MIP_CUT_MIN_ORTHOGONALITY       "mip_cut_min_orthogonality"
-#define CUOPT_MIP_BATCH_PDLP_STRONG_BRANCHING "mip_batch_pdlp_strong_branching"
-#define CUOPT_SOLUTION_FILE                   "solution_file"
-#define CUOPT_NUM_CPU_THREADS                 "num_cpu_threads"
-#define CUOPT_NUM_GPUS                        "num_gpus"
-#define CUOPT_USER_PROBLEM_FILE               "user_problem_file"
-#define CUOPT_PRESOLVE_FILE                   "presolve_file"
-#define CUOPT_RANDOM_SEED                     "random_seed"
-#define CUOPT_PDLP_PRECISION                  "pdlp_precision"
+#define CUOPT_ABSOLUTE_DUAL_TOLERANCE              "absolute_dual_tolerance"
+#define CUOPT_RELATIVE_DUAL_TOLERANCE              "relative_dual_tolerance"
+#define CUOPT_ABSOLUTE_PRIMAL_TOLERANCE            "absolute_primal_tolerance"
+#define CUOPT_RELATIVE_PRIMAL_TOLERANCE            "relative_primal_tolerance"
+#define CUOPT_ABSOLUTE_GAP_TOLERANCE               "absolute_gap_tolerance"
+#define CUOPT_RELATIVE_GAP_TOLERANCE               "relative_gap_tolerance"
+#define CUOPT_INFEASIBILITY_DETECTION              "infeasibility_detection"
+#define CUOPT_STRICT_INFEASIBILITY                 "strict_infeasibility"
+#define CUOPT_PRIMAL_INFEASIBLE_TOLERANCE          "primal_infeasible_tolerance"
+#define CUOPT_DUAL_INFEASIBLE_TOLERANCE            "dual_infeasible_tolerance"
+#define CUOPT_ITERATION_LIMIT                      "iteration_limit"
+#define CUOPT_TIME_LIMIT                           "time_limit"
+#define CUOPT_WORK_LIMIT                           "work_limit"
+#define CUOPT_PDLP_SOLVER_MODE                     "pdlp_solver_mode"
+#define CUOPT_METHOD                               "method"
+#define CUOPT_PER_CONSTRAINT_RESIDUAL              "per_constraint_residual"
+#define CUOPT_SAVE_BEST_PRIMAL_SO_FAR              "save_best_primal_so_far"
+#define CUOPT_FIRST_PRIMAL_FEASIBLE                "first_primal_feasible"
+#define CUOPT_LOG_FILE                             "log_file"
+#define CUOPT_LOG_TO_CONSOLE                       "log_to_console"
+#define CUOPT_CROSSOVER                            "crossover"
+#define CUOPT_FOLDING                              "folding"
+#define CUOPT_AUGMENTED                            "augmented"
+#define CUOPT_DUALIZE                              "dualize"
+#define CUOPT_ORDERING                             "ordering"
+#define CUOPT_BARRIER_DUAL_INITIAL_POINT           "barrier_dual_initial_point"
+#define CUOPT_ELIMINATE_DENSE_COLUMNS              "eliminate_dense_columns"
+#define CUOPT_CUDSS_DETERMINISTIC                  "cudss_deterministic"
+#define CUOPT_PRESOLVE                             "presolve"
+#define CUOPT_DUAL_POSTSOLVE                       "dual_postsolve"
+#define CUOPT_MIP_DETERMINISM_MODE                 "mip_determinism_mode"
+#define CUOPT_MIP_ABSOLUTE_TOLERANCE               "mip_absolute_tolerance"
+#define CUOPT_MIP_RELATIVE_TOLERANCE               "mip_relative_tolerance"
+#define CUOPT_MIP_INTEGRALITY_TOLERANCE            "mip_integrality_tolerance"
+#define CUOPT_MIP_ABSOLUTE_GAP                     "mip_absolute_gap"
+#define CUOPT_MIP_RELATIVE_GAP                     "mip_relative_gap"
+#define CUOPT_MIP_HEURISTICS_ONLY                  "mip_heuristics_only"
+#define CUOPT_MIP_SCALING                          "mip_scaling"
+#define CUOPT_MIP_PRESOLVE                         "mip_presolve"
+#define CUOPT_MIP_RELIABILITY_BRANCHING            "mip_reliability_branching"
+#define CUOPT_MIP_CUT_PASSES                       "mip_cut_passes"
+#define CUOPT_MIP_MIXED_INTEGER_ROUNDING_CUTS      "mip_mixed_integer_rounding_cuts"
+#define CUOPT_MIP_MIXED_INTEGER_GOMORY_CUTS        "mip_mixed_integer_gomory_cuts"
+#define CUOPT_MIP_KNAPSACK_CUTS                    "mip_knapsack_cuts"
+#define CUOPT_MIP_IMPLIED_BOUND_CUTS               "mip_implied_bound_cuts"
+#define CUOPT_MIP_CLIQUE_CUTS                      "mip_clique_cuts"
+#define CUOPT_MIP_STRONG_CHVATAL_GOMORY_CUTS       "mip_strong_chvatal_gomory_cuts"
+#define CUOPT_MIP_REDUCED_COST_STRENGTHENING       "mip_reduced_cost_strengthening"
+#define CUOPT_MIP_CUT_CHANGE_THRESHOLD             "mip_cut_change_threshold"
+#define CUOPT_MIP_CUT_MIN_ORTHOGONALITY            "mip_cut_min_orthogonality"
+#define CUOPT_MIP_BATCH_PDLP_STRONG_BRANCHING      "mip_batch_pdlp_strong_branching"
+#define CUOPT_MIP_BATCH_PDLP_RELIABILITY_BRANCHING "mip_batch_pdlp_reliability_branching"
+#define CUOPT_MIP_STRONG_BRANCHING_SIMPLEX_ITERATION_LIMIT \
+  "mip_strong_branching_simplex_iteration_limit"
+#define CUOPT_SOLUTION_FILE     "solution_file"
+#define CUOPT_NUM_CPU_THREADS   "num_cpu_threads"
+#define CUOPT_NUM_GPUS          "num_gpus"
+#define CUOPT_USER_PROBLEM_FILE "user_problem_file"
+#define CUOPT_PRESOLVE_FILE     "presolve_file"
+#define CUOPT_RANDOM_SEED       "random_seed"
+#define CUOPT_PDLP_PRECISION    "pdlp_precision"
+
+#define CUOPT_MIP_HYPER_HEURISTIC_POPULATION_SIZE     "mip_hyper_heuristic_population_size"
+#define CUOPT_MIP_HYPER_HEURISTIC_NUM_CPUFJ_THREADS   "mip_hyper_heuristic_num_cpufj_threads"
+#define CUOPT_MIP_HYPER_HEURISTIC_PRESOLVE_TIME_RATIO "mip_hyper_heuristic_presolve_time_ratio"
+#define CUOPT_MIP_HYPER_HEURISTIC_PRESOLVE_MAX_TIME   "mip_hyper_heuristic_presolve_max_time"
+#define CUOPT_MIP_HYPER_HEURISTIC_ROOT_LP_TIME_RATIO  "mip_hyper_heuristic_root_lp_time_ratio"
+#define CUOPT_MIP_HYPER_HEURISTIC_ROOT_LP_MAX_TIME    "mip_hyper_heuristic_root_lp_max_time"
+#define CUOPT_MIP_HYPER_HEURISTIC_RINS_TIME_LIMIT     "mip_hyper_heuristic_rins_time_limit"
+#define CUOPT_MIP_HYPER_HEURISTIC_RINS_MAX_TIME_LIMIT "mip_hyper_heuristic_rins_max_time_limit"
+#define CUOPT_MIP_HYPER_HEURISTIC_RINS_FIX_RATE       "mip_hyper_heuristic_rins_fix_rate"
+#define CUOPT_MIP_HYPER_HEURISTIC_STAGNATION_TRIGGER  "mip_hyper_heuristic_stagnation_trigger"
+#define CUOPT_MIP_HYPER_HEURISTIC_MAX_ITERS_WITHOUT_IMPROVEMENT \
+  "mip_hyper_heuristic_max_iterations_without_improvement"
+#define CUOPT_MIP_HYPER_HEURISTIC_INITIAL_INFEASIBILITY_WEIGHT \
+  "mip_hyper_heuristic_initial_infeasibility_weight"
+#define CUOPT_MIP_HYPER_HEURISTIC_N_OF_MINIMUMS_FOR_EXIT \
+  "mip_hyper_heuristic_n_of_minimums_for_exit"
+#define CUOPT_MIP_HYPER_HEURISTIC_ENABLED_RECOMBINERS "mip_hyper_heuristic_enabled_recombiners"
+#define CUOPT_MIP_HYPER_HEURISTIC_CYCLE_DETECTION_LENGTH \
+  "mip_hyper_heuristic_cycle_detection_length"
+#define CUOPT_MIP_HYPER_HEURISTIC_RELAXED_LP_TIME_LIMIT "mip_hyper_heuristic_relaxed_lp_time_limit"
+#define CUOPT_MIP_HYPER_HEURISTIC_RELATED_VARS_TIME_LIMIT \
+  "mip_hyper_heuristic_related_vars_time_limit"
 
 /* @brief MIP determinism mode constants */
 #define CUOPT_MODE_OPPORTUNISTIC 0
@@ -129,6 +155,7 @@
 #define CUOPT_METHOD_PDLP         1
 #define CUOPT_METHOD_DUAL_SIMPLEX 2
 #define CUOPT_METHOD_BARRIER      3
+#define CUOPT_METHOD_UNSET        4
 
 /* @brief PDLP precision mode constants */
 #define CUOPT_PDLP_DEFAULT_PRECISION -1
@@ -153,4 +180,9 @@
 #define CUOPT_PRESOLVE_PAPILO  1
 #define CUOPT_PRESOLVE_PSLP    2
 
+/* @brief MIP scaling mode constants */
+#define CUOPT_MIP_SCALING_OFF          0
+#define CUOPT_MIP_SCALING_ON           1
+#define CUOPT_MIP_SCALING_NO_OBJECTIVE 2
+
 #endif  // CUOPT_CONSTANTS_H