Make barrier_dual_initial_point itself ENUM

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

Author: yuwenchen95

cpp/include/cuopt/mathematical_optimization/pdlp/solver_settings.hpp

@@ -294,7 +294,7 @@ class pdlp_solver_settings_t {
   i_t augmented{-1};
   i_t dualize{-1};
   i_t ordering{-1};
-  i_t barrier_dual_initial_point{-1};
+  barrier_dual_initial_point_t barrier_dual_initial_point{barrier_dual_initial_point_t::Automatic};
   i_t postsolve_info{-1};
   i_t barrier_presolve_bound_free_variables{-1};  // -1 automatic, 0 disabled, 1 enabled
   // Ruiz equilibration for QCQP (barrier) scaling: -1 automatic (row/column

cpp/include/cuopt/mathematical_optimization/utilities/internals.hpp

@@ -142,5 +142,20 @@ enum presolver_t : int {
   PSLP    = CUOPT_PRESOLVE_PSLP
 };
 
+/**
+ * @brief Barrier primal-dual initial-point strategy.
+ *
+ * Automatic: use Lustig-Marsten-Shanno for LP/QP; Sturm/SeDuMi mu-based point for conic problems.
+ * LustigMarstenShanno: Mehrotra-style dual start (Lustig, Marsten, Shanno, SIAM J. Optim. 1992).
+ * DualLeastSquares: solve augmented or ADAT dual least-squares system.
+ * SedumiMu: Sturm/SeDuMi mu-based primal+dual point (no factorization).
+ */
+enum barrier_dual_initial_point_t : int {
+  Automatic           = CUOPT_BARRIER_DUAL_INITIAL_POINT_AUTOMATIC,
+  LustigMarstenShanno = CUOPT_BARRIER_DUAL_INITIAL_POINT_LUSTIG_MARSTEN_SHANNO,
+  DualLeastSquares    = CUOPT_BARRIER_DUAL_INITIAL_POINT_DUAL_LEAST_SQUARES,
+  SedumiMu            = CUOPT_BARRIER_DUAL_INITIAL_POINT_SEDUMI_MU
+};
+
 }  // namespace mathematical_optimization
 }  // namespace cuopt

cpp/src/barrier/barrier.cu

@@ -2204,8 +2204,7 @@ int barrier_solver_t<i_t, f_t>::initial_point(iteration_data_t<i_t, f_t>& data)
   const bool use_augmented          = data.use_augmented;
   const bool has_direct_free_linear = data.n_direct_free_linear > 0;
 
-  const barrier_dual_initial_point_t input_strategy =
-    static_cast<barrier_dual_initial_point_t>(settings.barrier_dual_initial_point);
+  const barrier_dual_initial_point_t input_strategy = settings.barrier_dual_initial_point;
 
   const barrier_dual_initial_point_t init_strategy =
     (data.has_cones() && input_strategy == barrier_dual_initial_point_t::Automatic)

cpp/src/barrier/barrier.hpp

@@ -9,6 +9,7 @@
 #include <linear_algebra/dense_vector.hpp>
 
 #include <cuopt/mathematical_optimization/constants.h>
+#include <cuopt/mathematical_optimization/utilities/internals.hpp>
 #include <dual_simplex/presolve.hpp>
 #include <dual_simplex/simplex_solver_settings.hpp>
 #include <dual_simplex/solution.hpp>
@@ -21,21 +22,6 @@
 #include <utility>
 namespace cuopt::mathematical_optimization::barrier {
 
-/**
- * @brief Barrier primal-dual initial-point strategy.
- *
- * Automatic: use Lustig-Marsten-Shanno for LP/QP; Sturm/SeDuMi mu-based point for conic problems.
- * LustigMarstenShanno: Mehrotra-style dual start (Lustig, Marsten, Shanno, SIAM J. Optim. 1992).
- * DualLeastSquares: solve augmented or ADAT dual least-squares system.
- * SedumiMu: Sturm/SeDuMi mu-based primal+dual point (no factorization).
- */
-enum barrier_dual_initial_point_t : int {
-  Automatic           = CUOPT_BARRIER_DUAL_INITIAL_POINT_AUTOMATIC,
-  LustigMarstenShanno = CUOPT_BARRIER_DUAL_INITIAL_POINT_LUSTIG_MARSTEN_SHANNO,
-  DualLeastSquares    = CUOPT_BARRIER_DUAL_INITIAL_POINT_DUAL_LEAST_SQUARES,
-  SedumiMu            = CUOPT_BARRIER_DUAL_INITIAL_POINT_SEDUMI_MU
-};
-
 /** Validates SOC layout on an simplex::lp_problem_t before barrier presolve/solve. */
 template <typename i_t, typename f_t>
 bool validate_barrier_cone_layout(const simplex::lp_problem_t<i_t, f_t>& problem,

cpp/src/dual_simplex/simplex_solver_settings.hpp

@@ -9,6 +9,7 @@
 
 #include <cuopt/mathematical_optimization/mip/diving_hyper_params.hpp>
 #include <cuopt/mathematical_optimization/mip/submip_hyper_params.hpp>
+#include <cuopt/mathematical_optimization/utilities/internals.hpp>
 
 #include <dual_simplex/logger.hpp>
 #include <math_optimization/types.hpp>
@@ -77,7 +78,7 @@ struct simplex_solver_settings_t {
       augmented(0),
       dualize(-1),
       ordering(-1),
-      barrier_dual_initial_point(-1),
+      barrier_dual_initial_point(barrier_dual_initial_point_t::Automatic),
       postsolve_info(-1),
       barrier_presolve_bound_free_variables(-1),
       qcqp_ruiz_equilibration(-1),
@@ -173,7 +174,8 @@ struct simplex_solver_settings_t {
   i_t augmented;  // -1 automatic, 0 to solve with ADAT, 1 to solve with augmented system
   i_t dualize;    // -1 automatic, 0 to not dualize, 1 to dualize
   i_t ordering;   // -1 automatic, 0 to use nested dissection, 1 to use AMD
-  i_t barrier_dual_initial_point;             // -1 automatic, 0 Lustig-Marsten-Shanno,
+  barrier_dual_initial_point_t
+    barrier_dual_initial_point;               // -1 automatic, 0 Lustig-Marsten-Shanno,
                                               // 1 dual least squares, 2 SeDuMi mu-based
   i_t postsolve_info;                         // -1 automatic (disabled), 0 disabled, 1 enabled
   i_t barrier_presolve_bound_free_variables;  // -1 automatic, 0 disabled, 1 enabled

cpp/src/grpc/codegen/field_registry.yaml

@@ -534,6 +534,7 @@ pdlp_settings:
   - barrier_dual_initial_point:
       field_num: 26
       type: int32
+      from_proto_cast: "barrier_dual_initial_point_t"
       optional: true
   - eliminate_dense_columns:
       field_num: 27

cpp/src/grpc/codegen/generated/generated_pdlp_settings_to_proto.inc

@@ -31,7 +31,7 @@
   pb_settings->set_augmented(settings.augmented);
   pb_settings->set_dualize(settings.dualize);
   pb_settings->set_ordering(settings.ordering);
-  pb_settings->set_barrier_dual_initial_point(settings.barrier_dual_initial_point);
+  pb_settings->set_barrier_dual_initial_point(static_cast<int32_t>(settings.barrier_dual_initial_point));
   pb_settings->set_eliminate_dense_columns(settings.eliminate_dense_columns);
   pb_settings->set_barrier_iterative_refinement(settings.barrier_iterative_refinement);
   pb_settings->set_barrier_step_scale(settings.barrier_step_scale);

cpp/src/grpc/codegen/generated/generated_proto_to_pdlp_settings.inc

@@ -68,7 +68,7 @@
     settings.ordering = pb_settings.ordering();
   }
   if (pb_settings.has_barrier_dual_initial_point()) {
-    settings.barrier_dual_initial_point = pb_settings.barrier_dual_initial_point();
+    settings.barrier_dual_initial_point = static_cast<barrier_dual_initial_point_t>(pb_settings.barrier_dual_initial_point());
   }
   if (pb_settings.has_eliminate_dense_columns()) {
     settings.eliminate_dense_columns = pb_settings.eliminate_dense_columns();

cpp/src/math_optimization/solver_settings.cu

@@ -137,7 +137,7 @@ solver_settings_t<i_t, f_t>::solver_settings_t() : pdlp_settings(), mip_settings
     {CUOPT_FOLDING, &pdlp_settings.folding, -1, 1, -1},
     {CUOPT_DUALIZE, &pdlp_settings.dualize, -1, 1, -1},
     {CUOPT_ORDERING, &pdlp_settings.ordering, -1, 1, -1},
-    {CUOPT_BARRIER_DUAL_INITIAL_POINT, &pdlp_settings.barrier_dual_initial_point, -1, 2, -1},
+    {CUOPT_BARRIER_DUAL_INITIAL_POINT, reinterpret_cast<int*>(&pdlp_settings.barrier_dual_initial_point), -1, 2, -1},
     {CUOPT_POSTSOLVE_INFO, &pdlp_settings.postsolve_info, -1, 1, -1},
     {CUOPT_MIP_CUT_PASSES, &mip_settings.max_cut_passes, -1, std::numeric_limits<i_t>::max(), 10},
     {CUOPT_MIP_MIXED_INTEGER_ROUNDING_CUTS, &mip_settings.mir_cuts, -1, 1, -1},

cpp/tests/linear_programming/grpc/grpc_client_test.cpp

@@ -2224,24 +2224,25 @@ TEST(MapperRoundtrip, PDLPSettingsAllFields)
   orig.tolerances.absolute_primal_tolerance   = 5e-7;
   orig.tolerances.relative_primal_tolerance   = 6e-7;
 
-  orig.time_limit                   = 99.5;
-  orig.iteration_limit              = 10000;
-  orig.log_to_console               = false;
-  orig.detect_infeasibility         = true;
-  orig.strict_infeasibility         = true;
-  orig.pdlp_solver_mode             = pdlp_solver_mode_t::Fast1;
-  orig.method                       = method_t::Barrier;
-  orig.presolver                    = presolver_t::Default;
-  orig.dual_postsolve               = true;
-  orig.crossover                    = true;
-  orig.num_gpus                     = 4;
-  orig.per_constraint_residual      = true;
-  orig.cudss_deterministic          = true;
-  orig.folding                      = 1;
-  orig.augmented                    = 1;
-  orig.dualize                      = 1;
-  orig.ordering                     = 2;
-  orig.barrier_dual_initial_point   = 1;
+  orig.time_limit              = 99.5;
+  orig.iteration_limit         = 10000;
+  orig.log_to_console          = false;
+  orig.detect_infeasibility    = true;
+  orig.strict_infeasibility    = true;
+  orig.pdlp_solver_mode        = pdlp_solver_mode_t::Fast1;
+  orig.method                  = method_t::Barrier;
+  orig.presolver               = presolver_t::Default;
+  orig.dual_postsolve          = true;
+  orig.crossover               = true;
+  orig.num_gpus                = 4;
+  orig.per_constraint_residual = true;
+  orig.cudss_deterministic     = true;
+  orig.folding                 = 1;
+  orig.augmented               = 1;
+  orig.dualize                 = 1;
+  orig.ordering                = 2;
+  orig.barrier_dual_initial_point =
+    cuopt::mathematical_optimization::barrier_dual_initial_point_t::LustigMarstenShanno;
   orig.eliminate_dense_columns      = true;
   orig.barrier_iterative_refinement = false;  // not the default true, to detect overwrite-on-decode
   orig.barrier_step_scale           = 0.75;   // not the default 0.9
@@ -2282,7 +2283,8 @@ TEST(MapperRoundtrip, PDLPSettingsAllFields)
   EXPECT_EQ(restored.augmented, 1);
   EXPECT_EQ(restored.dualize, 1);
   EXPECT_EQ(restored.ordering, 2);
-  EXPECT_EQ(restored.barrier_dual_initial_point, 1);
+  EXPECT_EQ(restored.barrier_dual_initial_point,
+            cuopt::mathematical_optimization::barrier_dual_initial_point_t::LustigMarstenShanno);
   EXPECT_EQ(restored.eliminate_dense_columns, true);
   EXPECT_EQ(restored.barrier_iterative_refinement, false);
   EXPECT_DOUBLE_EQ(restored.barrier_step_scale, 0.75);