Implement python and C api for semi-continuous variables

cpp/include/cuopt/linear_programming/constants.h

@@ -137,8 +137,9 @@
 #define CUOPT_EQUAL        'E'
 
 /* @brief The variable type constants */
-#define CUOPT_CONTINUOUS 'C'
-#define CUOPT_INTEGER    'I'
+#define CUOPT_CONTINUOUS      'C'
+#define CUOPT_INTEGER         'I'
+#define CUOPT_SEMI_CONTINUOUS 'S'
 
 /* @brief The infinity constant */
 #ifdef __cplusplus

cpp/include/cuopt/linear_programming/cuopt_c.h

@@ -164,7 +164,8 @@ cuopt_int_t cuOptWriteProblem(cuOptOptimizationProblem problem,
  * @param[in] upper_bounds A pointer to an array of type cuopt_float_t of size num_variables
  *            containing the upper bounds of the variables
  * @param[in] variable_types A pointer to an array of type char of size num_variables
- *            containing the types of the variables (CUOPT_CONTINUOUS or CUOPT_INTEGER)
+ *            containing the types of the variables (CUOPT_CONTINUOUS, CUOPT_INTEGER, or
+ *            CUOPT_SEMI_CONTINUOUS)
  * @param[out] problem_ptr Pointer to store the created optimization problem
  * @return CUOPT_SUCCESS if successful, CUOPT_ERROR otherwise
  */
@@ -229,8 +230,8 @@ cuopt_int_t cuOptCreateProblem(cuopt_int_t num_constraints,
  *  cuopt_float_t of size num_variables containing the upper bounds of the variables.
  *
  * @param[in] variable_types - A pointer to an array of type char of size
- *  num_variables containing the types of the variables (CUOPT_CONTINUOUS or
- *  CUOPT_INTEGER).
+ *  num_variables containing the types of the variables (CUOPT_CONTINUOUS,
+ *  CUOPT_INTEGER, or CUOPT_SEMI_CONTINUOUS).
  *
  * @param[out] problem_ptr - A pointer to a cuOptOptimizationProblem.
  * On output the problem will be created and initialized with the provided data.
@@ -585,7 +586,7 @@ cuopt_int_t cuOptGetVariableUpperBounds(cuOptOptimizationProblem problem,
  *
  * @param[out] variable_types_ptr - A pointer to an array of type char of size
  *  num_variables that on output will contain the types of the variables
- *  (CUOPT_CONTINUOUS or CUOPT_INTEGER).
+ *  (CUOPT_CONTINUOUS, CUOPT_INTEGER, or CUOPT_SEMI_CONTINUOUS).
  *
  * @return A status code indicating success or failure.
  */

cpp/include/cuopt/linear_programming/optimization_problem_utils.hpp

@@ -18,13 +18,25 @@ namespace cuopt::linear_programming {
 
 namespace detail {
 
+inline constexpr bool is_valid_public_var_type_code(char variable_type)
+{
+  return variable_type == 'C' || variable_type == 'I' || variable_type == 'S';
+}
+
 inline constexpr var_t char_to_var_type(char variable_type)
 {
   if (variable_type == 'I' || variable_type == 'B') { return var_t::INTEGER; }
   if (variable_type == 'S') { return var_t::SEMI_CONTINUOUS; }
   return var_t::CONTINUOUS;
 }
 
+inline constexpr char var_type_to_char(var_t variable_type)
+{
+  if (variable_type == var_t::INTEGER) { return 'I'; }
+  if (variable_type == var_t::SEMI_CONTINUOUS) { return 'S'; }
+  return 'C';
+}
+
 }  // namespace detail
 
 /**

cpp/src/io/mps_parser.cpp

@@ -250,7 +250,7 @@ BoundType convert(std::string_view str)
     return LowerBoundIntegerVariable;
   } else if (str == "UI") {
     return UpperBoundIntegerVariable;
-  } else if (str == "SC" || str == "LC") {
+  } else if (str == "SC") {
     return SemiContinuousVariable;
   } else {
     mps_parser_expects(false,

cpp/src/mip_heuristics/presolve/semi_continuous.cu

@@ -14,6 +14,7 @@
 #include <dual_simplex/simplex_solver_settings.hpp>
 #include <mip_heuristics/mip_constants.hpp>
 #include <mip_heuristics/problem/problem.cuh>
+#include <mip_heuristics/problem/problem_helpers.cuh>
 #include <mip_heuristics/solver_context.cuh>
 #include <pdlp/translate.hpp>
 #include <utilities/copy_helpers.hpp>
@@ -38,6 +39,32 @@ bool is_effectively_infinite_sc_upper_bound(f_t ub)
   return !std::isfinite(ub) || ub >= static_cast<f_t>(sc_infinity_threshold);
 }
 
+template <typename i_t, typename f_t>
+void ensure_constraint_bounds_populated(optimization_problem_t<i_t, f_t>& op_problem)
+{
+  if (!op_problem.get_constraint_lower_bounds().is_empty() ||
+      !op_problem.get_constraint_upper_bounds().is_empty()) {
+    return;
+  }
+  if (op_problem.get_row_types().is_empty() || op_problem.get_constraint_bounds().is_empty()) {
+    return;
+  }
+  const auto* handle_ptr = op_problem.get_handle_ptr();
+  const auto stream      = handle_ptr->get_stream();
+  const i_t n            = static_cast<i_t>(op_problem.get_row_types().size());
+  rmm::device_uvector<f_t> clb(n, stream);
+  rmm::device_uvector<f_t> cub(n, stream);
+  auto in_first  = thrust::make_zip_iterator(thrust::make_tuple(
+    op_problem.get_row_types().cbegin(), op_problem.get_constraint_bounds().cbegin()));
+  auto in_last   = thrust::make_zip_iterator(thrust::make_tuple(
+    op_problem.get_row_types().cend(), op_problem.get_constraint_bounds().cend()));
+  auto out_first = thrust::make_zip_iterator(thrust::make_tuple(clb.begin(), cub.begin()));
+  thrust::transform(
+    handle_ptr->get_thrust_policy(), in_first, in_last, out_first, transform_bounds_functor<f_t>{});
+  op_problem.set_constraint_lower_bounds(clb.data(), n);
+  op_problem.set_constraint_upper_bounds(cub.data(), n);
+}
+
 template <typename i_t, typename f_t>
 std::vector<f_t> call_host_bounds_strengthening(const optimization_problem_t<i_t, f_t>& op_problem,
                                                 const mip_solver_settings_t<i_t, f_t>& settings,
@@ -147,6 +174,8 @@ bool reformulate_semi_continuous(optimization_problem_t<i_t, f_t>& op_problem,
     op_relaxed.set_variable_types(relaxed_types.data(), n_orig);
     op_relaxed.set_variable_lower_bounds(relaxed_lb.data(), n_orig);
     op_relaxed.set_variable_upper_bounds(relaxed_ub.data(), n_orig);
+
+    ensure_constraint_bounds_populated(op_relaxed);
   }
 
   // 3. Run deterministic CPU bounds strengthening on the relaxed problem to tighten UBs.
@@ -159,6 +188,8 @@ bool reformulate_semi_continuous(optimization_problem_t<i_t, f_t>& op_problem,
 
   // 4. Fetch all host arrays we need to extend with the new binary variables
   //    and linking constraints.
+  ensure_constraint_bounds_populated(op_problem);
+
   auto obj_c  = op_problem.get_objective_coefficients_host();
   auto A_vals = op_problem.get_constraint_matrix_values_host();
   auto A_idx  = op_problem.get_constraint_matrix_indices_host();

cpp/src/pdlp/cpu_optimization_problem.cpp

@@ -9,6 +9,7 @@
 #include <cuopt/linear_programming/cpu_optimization_problem.hpp>
 #include <cuopt/linear_programming/csr_matrix_utils.hpp>
 #include <cuopt/linear_programming/optimization_problem.hpp>
+#include <cuopt/linear_programming/optimization_problem_utils.hpp>
 #include <cuopt/linear_programming/solve_remote.hpp>
 
 #include <cuopt/linear_programming/io/writer.hpp>
@@ -176,13 +177,16 @@ void cpu_optimization_problem_t<i_t, f_t>::set_variable_types(const var_t* varia
   std::copy(variable_types, variable_types + size, variable_types_.begin());
 
   // Auto-detect problem category based on variable types (matching original optimization_problem_t)
-  i_t n_integer = std::count_if(
-    variable_types_.begin(), variable_types_.end(), [](auto val) { return val == var_t::INTEGER; });
+  i_t n_discrete = std::count_if(variable_types_.begin(), variable_types_.end(), [](auto val) {
+    return val == var_t::INTEGER || val == var_t::SEMI_CONTINUOUS;
+  });
   // By default it is LP
-  if (n_integer == size) {
+  if (n_discrete == size) {
     problem_category_ = problem_category_t::IP;
-  } else if (n_integer > 0) {
+  } else if (n_discrete > 0) {
     problem_category_ = problem_category_t::MIP;
+  } else {
+    problem_category_ = problem_category_t::LP;
   }
 }
 
@@ -749,7 +753,7 @@ void cpu_optimization_problem_t<i_t, f_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] = (variable_types_[i] == var_t::INTEGER) ? 'I' : 'C';
+      var_types_char[i] = detail::var_type_to_char(variable_types_[i]);
     }
 
     data_model_view.set_variable_types(var_types_char.data(), var_types_char.size());

cpp/src/pdlp/cuopt_c.cpp

@@ -172,6 +172,11 @@ cuopt_int_t cuOptCreateProblem(cuopt_int_t num_constraints,
       variable_types == nullptr) {
     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;
+    }
+  }
 
   problem_and_stream_view_t* problem_and_stream =
     new problem_and_stream_view_t(get_memory_backend_type());
@@ -195,8 +200,7 @@ cuopt_int_t cuOptCreateProblem(cuopt_int_t num_constraints,
     // Set variable types (problem category is auto-detected)
     std::vector<var_t> variable_types_host(num_variables);
     for (int j = 0; j < num_variables; j++) {
-      variable_types_host[j] =
-        variable_types[j] == CUOPT_CONTINUOUS ? var_t::CONTINUOUS : var_t::INTEGER;
+      variable_types_host[j] = detail::char_to_var_type(variable_types[j]);
     }
     problem->set_variable_types(variable_types_host.data(), num_variables);
 
@@ -232,6 +236,13 @@ cuopt_int_t cuOptCreateRangedProblem(cuopt_int_t num_constraints,
       variable_upper_bounds == nullptr) {
     return CUOPT_INVALID_ARGUMENT;
   }
+  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;
+      }
+    }
+  }
 
   problem_and_stream_view_t* problem_and_stream =
     new problem_and_stream_view_t(get_memory_backend_type());
@@ -257,8 +268,7 @@ cuopt_int_t cuOptCreateRangedProblem(cuopt_int_t num_constraints,
     std::vector<var_t> variable_types_host(num_variables);
     if (variable_types != nullptr) {
       for (int j = 0; j < num_variables; j++) {
-        variable_types_host[j] =
-          variable_types[j] == CUOPT_CONTINUOUS ? var_t::CONTINUOUS : var_t::INTEGER;
+        variable_types_host[j] = detail::char_to_var_type(variable_types[j]);
       }
     } else {
       // Default to all continuous
@@ -614,8 +624,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] =
-      variable_types_host[j] == var_t::INTEGER ? CUOPT_INTEGER : CUOPT_CONTINUOUS;
+    variable_types_ptr[j] = detail::var_type_to_char(variable_types_host[j]);
   }
   return CUOPT_SUCCESS;
 }

cpp/src/pdlp/optimization_problem.cu

@@ -7,6 +7,7 @@
 
 #include <cuopt/linear_programming/cpu_optimization_problem.hpp>
 #include <cuopt/linear_programming/optimization_problem.hpp>
+#include <cuopt/linear_programming/optimization_problem_utils.hpp>
 #include <cuopt/linear_programming/solve_remote.hpp>
 
 #include <cuopt/error.hpp>
@@ -847,7 +848,7 @@ void optimization_problem_t<i_t, f_t>::write_to_mps(const std::string& mps_file_
 
     // Convert enum types to char types
     for (size_t i = 0; i < variable_types.size(); ++i) {
-      variable_types[i] = (enum_variable_types[i] == var_t::INTEGER) ? 'I' : 'C';
+      variable_types[i] = detail::var_type_to_char(enum_variable_types[i]);
     }
 
     data_model_view.set_variable_types(variable_types.data(), variable_types.size());

cpp/tests/linear_programming/c_api_tests/c_api_test.c

@@ -1041,6 +1041,117 @@ cuopt_int_t test_ranged_problem(cuopt_int_t* termination_status_ptr, cuopt_float
   return status;
 }
 
+cuopt_int_t test_semi_continuous_problem(cuopt_int_t* termination_status_ptr,
+                                         cuopt_float_t* objective_ptr,
+                                         cuopt_float_t* solution_values)
+{
+  cuOptOptimizationProblem problem = NULL;
+  cuOptSolverSettings settings     = NULL;
+  cuOptSolution solution           = NULL;
+
+  /* Minimize x with x semi-continuous and x + y = 1.
+     Since x is either 0 or in [5, 10], the optimum is x = 0, y = 1.
+     If CUOPT_SEMI_CONTINUOUS is treated as integer, this model is infeasible. */
+  cuopt_int_t num_variables              = 2;
+  cuopt_int_t num_constraints            = 1;
+  cuopt_int_t row_offsets[]              = {0, 2};
+  cuopt_int_t column_indices[]           = {0, 1};
+  cuopt_float_t values[]                 = {1.0, 1.0};
+  char constraint_sense[]                = {CUOPT_EQUAL};
+  cuopt_float_t rhs[]                    = {1.0};
+  cuopt_float_t lower_bounds[]           = {5.0, 0.0};
+  cuopt_float_t upper_bounds[]           = {10.0, 1.0};
+  char variable_types[]                  = {CUOPT_SEMI_CONTINUOUS, CUOPT_CONTINUOUS};
+  cuopt_float_t objective_coefficients[] = {1.0, 0.0};
+  char check_variable_types[2];
+  cuopt_int_t is_mip;
+  cuopt_int_t status;
+
+  status = cuOptCreateProblem(num_constraints,
+                              num_variables,
+                              CUOPT_MINIMIZE,
+                              0.0,
+                              objective_coefficients,
+                              row_offsets,
+                              column_indices,
+                              values,
+                              constraint_sense,
+                              rhs,
+                              lower_bounds,
+                              upper_bounds,
+                              variable_types,
+                              &problem);
+  if (status != CUOPT_SUCCESS) {
+    printf("Error creating semi-continuous problem\n");
+    goto DONE;
+  }
+
+  status = cuOptGetVariableTypes(problem, check_variable_types);
+  if (status != CUOPT_SUCCESS) {
+    printf("Error getting variable types for semi-continuous problem\n");
+    goto DONE;
+  }
+  if (check_variable_types[0] != CUOPT_SEMI_CONTINUOUS ||
+      check_variable_types[1] != CUOPT_CONTINUOUS) {
+    printf("Error: semi-continuous variable types were not preserved\n");
+    status = -1;
+    goto DONE;
+  }
+
+  status = cuOptIsMIP(problem, &is_mip);
+  if (status != CUOPT_SUCCESS) {
+    printf("Error getting MIP flag for semi-continuous problem\n");
+    goto DONE;
+  }
+  if (!is_mip) {
+    printf("Error: semi-continuous problem was not detected as a MIP\n");
+    status = -1;
+    goto DONE;
+  }
+
+  status = cuOptCreateSolverSettings(&settings);
+  if (status != CUOPT_SUCCESS) {
+    printf("Error creating solver settings\n");
+    goto DONE;
+  }
+  status = cuOptSetFloatParameter(settings, CUOPT_TIME_LIMIT, 10.0);
+  if (status != CUOPT_SUCCESS) {
+    printf("Error setting time limit\n");
+    goto DONE;
+  }
+
+  status = cuOptSolve(problem, settings, &solution);
+  if (status != CUOPT_SUCCESS) {
+    printf("Error solving semi-continuous problem\n");
+    goto DONE;
+  }
+
+  status = cuOptGetTerminationStatus(solution, termination_status_ptr);
+  if (status != CUOPT_SUCCESS) {
+    printf("Error getting termination status\n");
+    goto DONE;
+  }
+
+  status = cuOptGetObjectiveValue(solution, objective_ptr);
+  if (status != CUOPT_SUCCESS) {
+    printf("Error getting objective value\n");
+    goto DONE;
+  }
+
+  status = cuOptGetPrimalSolution(solution, solution_values);
+  if (status != CUOPT_SUCCESS) {
+    printf("Error getting primal solution\n");
+    goto DONE;
+  }
+
+DONE:
+  cuOptDestroyProblem(&problem);
+  cuOptDestroySolverSettings(&settings);
+  cuOptDestroySolution(&solution);
+
+  return status;
+}
+
 // Test invalid bounds scenario (what MOI wrapper was producing)
 cuopt_int_t test_invalid_bounds(cuopt_int_t test_mip)
 {

cpp/tests/linear_programming/c_api_tests/c_api_tests.cpp

@@ -125,6 +125,19 @@ TEST(c_api, test_ranged_problem)
   EXPECT_NEAR(objective, 32.0, 1e-3);
 }
 
+TEST(c_api, test_semi_continuous_problem)
+{
+  cuopt_int_t termination_status   = CUOPT_TERMINATION_STATUS_NO_TERMINATION;
+  cuopt_float_t objective          = 0.0;
+  cuopt_float_t solution_values[2] = {0.0, 0.0};
+  ASSERT_EQ(test_semi_continuous_problem(&termination_status, &objective, solution_values),
+            CUOPT_SUCCESS);
+  EXPECT_EQ(termination_status, CUOPT_TERMINATION_STATUS_OPTIMAL);
+  EXPECT_NEAR(objective, 0.0, 1e-6);
+  EXPECT_NEAR(solution_values[0], 0.0, 1e-6);
+  EXPECT_NEAR(solution_values[1], 1.0, 1e-6);
+}
+
 TEST(c_api, test_invalid_bounds)
 {
   // Test LP codepath

cpp/tests/linear_programming/c_api_tests/c_api_tests.h

@@ -31,6 +31,9 @@ cuopt_int_t test_bad_parameter_name();
 cuopt_int_t test_mip_get_callbacks_only();
 cuopt_int_t test_mip_get_set_callbacks();
 cuopt_int_t test_ranged_problem(cuopt_int_t* termination_status_ptr, cuopt_float_t* objective_ptr);
+cuopt_int_t test_semi_continuous_problem(cuopt_int_t* termination_status_ptr,
+                                         cuopt_float_t* objective_ptr,
+                                         cuopt_float_t* solution_values);
 cuopt_int_t test_invalid_bounds(cuopt_int_t test_mip);
 cuopt_int_t test_quadratic_problem(cuopt_int_t* termination_status_ptr,
                                    cuopt_float_t* objective_ptr);