Rename to

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

Author: yuwenchen95

cpp/include/cuopt/mathematical_optimization/constants.h

@@ -46,7 +46,7 @@
 #define CUOPT_AUGMENTED                             "augmented"
 #define CUOPT_DUALIZE                               "dualize"
 #define CUOPT_ORDERING                              "ordering"
-#define CUOPT_BARRIER_DUAL_INITIAL_POINT            "barrier_dual_initial_point"
+#define CUOPT_BARRIER_INITIAL_POINT                 "barrier_initial_point"
 #define CUOPT_POSTSOLVE_INFO                        "postsolve_info"
 #define CUOPT_BARRIER_PRESOLVE_BOUND_FREE_VARIABLES "barrier_presolve_bound_free_variables"
 #define CUOPT_BARRIER_ITERATIVE_REFINEMENT          "barrier_iterative_refinement"
@@ -205,10 +205,10 @@
 #define CUOPT_METHOD_BARRIER      3
 #define CUOPT_METHOD_UNSET        4
 
-#define CUOPT_BARRIER_DUAL_INITIAL_POINT_AUTOMATIC             -1
-#define CUOPT_BARRIER_DUAL_INITIAL_POINT_LUSTIG_MARSTEN_SHANNO 0
-#define CUOPT_BARRIER_DUAL_INITIAL_POINT_DUAL_LEAST_SQUARES    1
-#define CUOPT_BARRIER_DUAL_INITIAL_POINT_SEDUMI_MU             2
+#define CUOPT_BARRIER_INITIAL_POINT_AUTOMATIC             -1
+#define CUOPT_BARRIER_INITIAL_POINT_LUSTIG_MARSTEN_SHANNO 0
+#define CUOPT_BARRIER_INITIAL_POINT_DUAL_LEAST_SQUARES    1
+#define CUOPT_BARRIER_INITIAL_POINT_SEDUMI_MU             2
 
 /* @brief PDLP precision mode constants */
 #define CUOPT_PDLP_DEFAULT_PRECISION -1

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};
-  barrier_dual_initial_point_t barrier_dual_initial_point{barrier_dual_initial_point_t::Automatic};
+  barrier_initial_point_t barrier_initial_point{barrier_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

@@ -150,11 +150,11 @@ enum presolver_t : int {
  * 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
+enum barrier_initial_point_t : int {
+  Automatic           = CUOPT_BARRIER_INITIAL_POINT_AUTOMATIC,
+  LustigMarstenShanno = CUOPT_BARRIER_INITIAL_POINT_LUSTIG_MARSTEN_SHANNO,
+  DualLeastSquares    = CUOPT_BARRIER_INITIAL_POINT_DUAL_LEAST_SQUARES,
+  SedumiMu            = CUOPT_BARRIER_INITIAL_POINT_SEDUMI_MU
 };
 
 }  // namespace mathematical_optimization

cpp/src/barrier/barrier.cu

@@ -2204,19 +2204,19 @@ 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 = settings.barrier_dual_initial_point;
+  const barrier_initial_point_t input_strategy = settings.barrier_initial_point;
 
-  const barrier_dual_initial_point_t init_strategy =
-    (data.has_cones() && input_strategy == barrier_dual_initial_point_t::Automatic)
-      ? barrier_dual_initial_point_t::SedumiMu
+  const barrier_initial_point_t init_strategy =
+    (data.has_cones() && input_strategy == barrier_initial_point_t::Automatic)
+      ? barrier_initial_point_t::SedumiMu
       : input_strategy;
 
   // SedumiMu: Sturm/SeDuMi-style mu-based primal+dual initial point.
   //   mu = sqrt((1 + ||b||_inf) * (1 + ||c||_inf)); x = z = mu * e_K.
   // where e_K is the identity of the symmetric cone:
   //   LP block: e = 1,  SOC block: e = (sqrt(2), 0, ..., 0)
   // Full primal+dual point; no factorization/solve (main loop factorizes later).
-  if (init_strategy == barrier_dual_initial_point_t::SedumiMu) {
+  if (init_strategy == barrier_initial_point_t::SedumiMu) {
     const f_t norm_b     = vector_norm_inf<i_t, f_t>(lp.rhs);
     const f_t norm_c     = vector_norm_inf<i_t, f_t>(lp.objective);
     const f_t mu         = std::sqrt((1.0 + norm_b) * (1.0 + norm_c));
@@ -2404,8 +2404,8 @@ int barrier_solver_t<i_t, f_t>::initial_point(iteration_data_t<i_t, f_t>& data)
       values, epsilon_adjust, linear_mask, linear_end, lp.second_order_cone_dims);
   };
 
-  if (init_strategy == barrier_dual_initial_point_t::Automatic ||
-      init_strategy == barrier_dual_initial_point_t::LustigMarstenShanno) {
+  if (init_strategy == barrier_initial_point_t::Automatic ||
+      init_strategy == barrier_initial_point_t::LustigMarstenShanno) {
     // Use the dual starting point suggested by the paper
     // On Implementing Mehrotra’s Predictor–Corrector Interior-Point Method for Linear Programming
     // Irvin J. Lustig, Roy E. Marsten, and David F. Shanno

cpp/src/dual_simplex/simplex_solver_settings.hpp

@@ -78,7 +78,7 @@ struct simplex_solver_settings_t {
       augmented(0),
       dualize(-1),
       ordering(-1),
-      barrier_dual_initial_point(barrier_dual_initial_point_t::Automatic),
+      barrier_initial_point(barrier_initial_point_t::Automatic),
       postsolve_info(-1),
       barrier_presolve_bound_free_variables(-1),
       qcqp_ruiz_equilibration(-1),
@@ -174,11 +174,10 @@ 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
-  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
+  barrier_initial_point_t barrier_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
   i_t qcqp_ruiz_equilibration;          // -1 automatic (imbalance heuristic), 0 disabled, 1 enabled
   f_t barrier_initial_point_safeguard;  // margin pushing the barrier initial iterate into
   // the interior of the nonnegative orthant / SOC

cpp/src/grpc/codegen/field_registry.yaml

@@ -531,10 +531,10 @@ pdlp_settings:
       field_num: 25
       type: int32
       optional: true
-  - barrier_dual_initial_point:
+  - barrier_initial_point:
       field_num: 26
       type: int32
-      from_proto_cast: "barrier_dual_initial_point_t"
+      from_proto_cast: "barrier_initial_point_t"
       optional: true
   - eliminate_dense_columns:
       field_num: 27

cpp/src/grpc/codegen/generated/cuopt_remote_data.proto

@@ -186,7 +186,7 @@ message PDLPSolverSettings {
   optional int32 augmented = 23;
   optional int32 dualize = 24;
   optional int32 ordering = 25;
-  optional int32 barrier_dual_initial_point = 26;
+  optional int32 barrier_initial_point = 26;
   optional bool eliminate_dense_columns = 27;
   bool save_best_primal_so_far = 28;
   bool first_primal_feasible = 29;

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(static_cast<int32_t>(settings.barrier_dual_initial_point));
+  pb_settings->set_barrier_initial_point(static_cast<int32_t>(settings.barrier_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

@@ -67,8 +67,8 @@
   if (pb_settings.has_ordering()) {
     settings.ordering = pb_settings.ordering();
   }
-  if (pb_settings.has_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_barrier_initial_point()) {
+    settings.barrier_initial_point = static_cast<barrier_initial_point_t>(pb_settings.barrier_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, reinterpret_cast<int*>(&pdlp_settings.barrier_dual_initial_point), -1, 2, -1},
+    {CUOPT_BARRIER_INITIAL_POINT, reinterpret_cast<int*>(&pdlp_settings.barrier_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},