Added (and rationalised) PDLP options, and using them to set up PrimalDualParams

Author: jajhall

highs/highs_bindings.cpp

@@ -1216,9 +1216,8 @@ PYBIND11_MODULE(_core, m, py::mod_gil_not_used()) {
       .def_readwrite("timeless_log", &HighsOptions::timeless_log)
       .def_readwrite("ipm_optimality_tolerance", &HighsOptions::ipm_optimality_tolerance)
       .def_readwrite("ipm_iteration_limit", &HighsOptions::ipm_iteration_limit)
-      .def_readwrite("pdlp_scaling", &HighsOptions::pdlp_scaling)
       .def_readwrite("pdlp_iteration_limit", &HighsOptions::pdlp_iteration_limit)
-      .def_readwrite("pdlp_e_restart_method", &HighsOptions::pdlp_e_restart_method)
+      .def_readwrite("pdlp_cupdlpc_restart_method", &HighsOptions::pdlp_cupdlpc_restart_method)
       .def_readwrite("pdlp_optimality_tolerance", &HighsOptions::pdlp_optimality_tolerance)
       .def_readwrite("qp_iteration_limit", &HighsOptions::qp_iteration_limit)
       .def_readwrite("qp_nullspace_limit", &HighsOptions::qp_nullspace_limit)

highs/lp_data/HConst.h

@@ -364,4 +364,39 @@ const int8_t kPivotUnit = 1;
 const int8_t kPivotRowSingleton = 2;
 const int8_t kPivotColSingleton = 3;
 const int8_t kPivotMarkowitz = 4;
+
+// Mask for switching off PDLP features
+enum PdlpFeaturesOff {
+  kPdlpAllFeaturesOn = 0,
+  kPdlpScalingOff = 1,
+  kPdlpRestartOff = 2,
+  kPdlpAdaptiveStepSizeOff = 4,
+  kPdlpAllFeaturesOff =
+      kPdlpScalingOff + kPdlpRestartOff + kPdlpAdaptiveStepSizeOff
+};
+
+enum PdlpScalingBit {
+  kPdlpScalingMin = 0,
+  kPdlpScalingRuiz = 1,
+  kPdlpScalingL2 = 2,
+  kPdlpScalingPC = 4,
+  kPdlpScalingMax = kPdlpScalingRuiz + kPdlpScalingL2 + kPdlpScalingPC
+};
+
+enum PdlpStepSizeStrategy {
+  kPdlpStepSizeStrategyFixed = 0,
+  kPdlpStepSizeStrategyMin = kPdlpStepSizeStrategyFixed,
+  kPdlpStepSizeStrategyAdaptive,
+  kPdlpStepSizeStrategyMalitskyPock,
+  kPdlpStepSizeStrategyMax = kPdlpStepSizeStrategyMalitskyPock
+};
+
+enum PdlpRestartStrategy {
+  kPdlpRestartStrategyOff = 0,
+  kPdlpRestartStrategyMin = kPdlpRestartStrategyOff,
+  kPdlpRestartStrategyFixed,
+  kPdlpRestartStrategyAdaptive,
+  kPdlpRestartStrategyMax = kPdlpRestartStrategyAdaptive
+};
+
 #endif /* LP_DATA_HCONST_H_ */

highs/lp_data/HighsOptions.h

@@ -369,9 +369,13 @@ struct HighsOptionsStruct {
   std::string hipo_system;
 
   // Options for PDLP solver
-  bool pdlp_scaling;
+  HighsInt pdlp_features_off;
   HighsInt pdlp_iteration_limit;
-  HighsInt pdlp_e_restart_method;
+  HighsInt pdlp_scaling_mode;
+  HighsInt pdlp_ruiz_iterations;
+  HighsInt pdlp_restart_strategy;
+  HighsInt pdlp_cupdlpc_restart_method;
+  HighsInt pdlp_step_size_strategy;
   double pdlp_optimality_tolerance;
 
   // Options for QP solver
@@ -536,9 +540,13 @@ struct HighsOptionsStruct {
         ipm_optimality_tolerance(0.0),
         ipm_iteration_limit(0),
         hipo_system(""),
-        pdlp_scaling(false),
+	pdlp_features_off(0),
         pdlp_iteration_limit(0),
-        pdlp_e_restart_method(0),
+        pdlp_scaling_mode(0),
+        pdlp_ruiz_iterations(0),
+        pdlp_restart_strategy(0),
+        pdlp_cupdlpc_restart_method(0),
+        pdlp_step_size_strategy(0),
         pdlp_optimality_tolerance(0.0),
         qp_iteration_limit(0),
         qp_nullspace_limit(0),
@@ -1260,20 +1268,48 @@ class HighsOptions : public HighsOptionsStruct {
         advanced, &hipo_system, kHighsChooseString);
     records.push_back(record_string);
 
-    record_bool = new OptionRecordBool(
-        "pdlp_scaling", "Scaling option for PDLP solver: Default = true",
-        advanced, &pdlp_scaling, true);
-    records.push_back(record_bool);
+    record_int = new OptionRecordInt(
+        "pdlp_features_off",
+        "Mask for switching PDLP features off: 1 => Scaling; 2 => Restart; 4 "
+        "=> AdaptiveStepSize",
+        advanced, &pdlp_features_off, kPdlpAllFeaturesOn, kPdlpAllFeaturesOn,
+        kPdlpAllFeaturesOff);
+    records.push_back(record_int);
 
     record_int = new OptionRecordInt(
         "pdlp_iteration_limit", "Iteration limit for PDLP solver", advanced,
         &pdlp_iteration_limit, 0, kHighsIInf, kHighsIInf);
     records.push_back(record_int);
 
-    record_int = new OptionRecordInt("pdlp_e_restart_method",
-                                     "Restart mode for PDLP solver: 0 => none; "
+    record_int = new OptionRecordInt("pdlp_scaling_mode",
+                                     "Scaling mode for PDLP solver (default = "
+                                     "5): 1 => Ruiz; 2 => L2; 4 => PC",
+                                     advanced, &pdlp_scaling_mode, kPdlpScalingMin, kPdlpScalingRuiz+kPdlpScalingPC, kPdlpStepSizeStrategyMax);
+    records.push_back(record_int);
+
+    record_int = new OptionRecordInt("pdlp_ruiz_iterations",
+                                     "Number of Ruiz scaling iteraitons for PDLP solver",
+                                     advanced, &pdlp_ruiz_iterations, 0, 10, kHighsIInf);
+    records.push_back(record_int);
+
+    record_int = new OptionRecordInt("pdlp_restart_strategy",
+                                     "Restart strategy for PDLP solver: 0 => off; "
+                                     "1 => fixed; 2 => adaptive",
+                                     advanced, &pdlp_restart_strategy,
+				     kPdlpRestartStrategyMin, kPdlpRestartStrategyOff, kPdlpRestartStrategyMax);
+    records.push_back(record_int);
+
+    record_int = new OptionRecordInt("pdlp_cupdlpc_restart_method",
+                                     "Restart mode for cuPDLP-C solver: 0 => none; "
                                      "1 => GPU (default); 2 => CPU ",
-                                     advanced, &pdlp_e_restart_method, 0, 1, 2);
+                                     advanced, &pdlp_cupdlpc_restart_method, 0, 1, 2);
+    records.push_back(record_int);
+
+    record_int = new OptionRecordInt("pdlp_step_size_strategy",
+                                     "Step size strategy for PDLP solver: 0 => fixed; "
+                                     "1 => adaptive; 2 => Malitsky-Pock",
+                                     advanced, &pdlp_step_size_strategy,
+				     kPdlpStepSizeStrategyMin, kPdlpStepSizeStrategyFixed, kPdlpRestartStrategyMax);
     records.push_back(record_int);
 
     record_double = new OptionRecordDouble(

highs/pdlp/CupdlpWrapper.cpp

@@ -109,7 +109,7 @@ HighsStatus solveLpCupdlp(const HighsOptions& options, HighsTimer& timer,
   // H_Init_Scaling(local_log_level, scaling, nCols, nRows, cost, rhs);
   Init_Scaling(local_log_level, scaling, nCols, nRows, cost, rhs);
 
-  cupdlp_int ifScaling = 1;
+  cupdlp_int ifScaling = intParam[IF_SCALING];
 
   CUPDLPwork* w = cupdlp_NULL;
   cupdlp_init_work(w, 1);
@@ -647,7 +647,25 @@ void getUserParamsFromOptions(const HighsOptions& options, HighsTimer& timer,
   intParam[N_LOG_LEVEL] = getCupdlpLogLevel(options);
   //
   ifChangeIntParam[IF_SCALING] = true;
-  intParam[IF_SCALING] = options.pdlp_scaling ? 1 : 0;
+  cupdlp_int scaling_on =
+      (options.pdlp_features_off & kPdlpScalingOff) == 0 ? 1 : 0;
+  intParam[IF_SCALING] = scaling_on;
+  if (scaling_on == 0)
+    highsLogUser(options.log_options, HighsLogType::kInfo,
+                 "PDLP: Scaling off\n");
+  //
+  ifChangeIntParam[E_LINE_SEARCH_METHOD] = true;
+  cupdlp_int adaptive_lineasearch =
+      (options.pdlp_features_off & kPdlpAdaptiveStepSizeOff) == 0 ? 1 : 0;
+  intParam[E_LINE_SEARCH_METHOD] = adaptive_lineasearch;
+  if (adaptive_lineasearch == 1) {
+    intParam[E_LINE_SEARCH_METHOD] = PDHG_ADAPTIVE_LINESEARCH;
+  } else {
+    intParam[E_LINE_SEARCH_METHOD] = PDHG_FIXED_LINESEARCH;
+  }
+  if (adaptive_lineasearch == 0)
+    highsLogUser(options.log_options, HighsLogType::kInfo,
+                 "PDLP: Adaptive line search off\n");
   //
   ifChangeFloatParam[D_PRIMAL_TOL] = true;
   floatParam[D_PRIMAL_TOL] = options.primal_feasibility_tolerance;
@@ -676,7 +694,13 @@ void getUserParamsFromOptions(const HighsOptions& options, HighsTimer& timer,
   floatParam[D_TIME_LIM] = options.time_limit;
   //
   ifChangeIntParam[E_RESTART_METHOD] = true;
-  intParam[E_RESTART_METHOD] = int(options.pdlp_e_restart_method);
+  cupdlp_int restart_on =
+      (options.pdlp_features_off & kPdlpRestartOff) == 0 ? 1 : 0;
+  if (options.pdlp_cupdlpc_restart_method == 0) restart_on = 0;
+  intParam[E_RESTART_METHOD] = restart_on;
+  if (restart_on == 0)
+    highsLogUser(options.log_options, HighsLogType::kInfo,
+                 "PDLP: Restart off\n");
 }
 
 void analysePdlpSolution(const HighsOptions& options, const HighsLp& lp,

highs/pdlp/HiPdlpWrapper.cpp

@@ -14,7 +14,7 @@
 #include "pdlp/hipdlp/pdhg.hpp"
 #include "pdlp/hipdlp/restart.hpp"
 
-void getHiPpdlpParamsFromOptions(const HighsOptions& options, PrimalDualParams& params);
+void getHiPpdlpParamsFromOptions(const HighsOptions& options, HighsTimer& timer, PrimalDualParams& params);
 
 HighsStatus solveLpHiPdlp(HighsLpSolverObject& solver_object) {
   return solveLpHiPdlp(solver_object.options_, solver_object.timer_,
@@ -42,7 +42,7 @@ HighsStatus solveLpHiPdlp(const HighsOptions& options, HighsTimer& timer,
   // --- Initialize Parameters with Defaults ---
   PrimalDualParams params{};
 
-  getHiPpdlpParamsFromOptions(options, params);
+  getHiPpdlpParamsFromOptions(options, timer, params);
   std::vector<double> x, y;
   PDLPSolver pdlp(logger);
 
@@ -54,14 +54,72 @@ HighsStatus solveLpHiPdlp(const HighsOptions& options, HighsTimer& timer,
   return HighsStatus::kError;
 }
 
-void getHiPpdlpParamsFromOptions(const HighsOptions& options, PrimalDualParams& params) {
+void getHiPpdlpParamsFromOptions(const HighsOptions& options, HighsTimer& timer, PrimalDualParams& params) {
   params.initialise();
-  params.tolerance = 1e-4;
-  params.max_iterations = 40000;
+  //  params.eta = 0; Not set in parse_options_file
+  //  params.omega = 0; Not set in parse_opions_file
+  //
+  // Is params.tolerance for primal and dual feasibility, and
+  // optimality?
+  params.tolerance = options.pdlp_optimality_tolerance;
+  if (options.kkt_tolerance != kDefaultKktTolerance) {
+    params.tolerance = options.kkt_tolerance;
+  }
+  params.max_iterations = options.pdlp_iteration_limit;
+  params.device_type = Device::CPU;
+  // HiPDLP has its own timer, so set its time limit according to
+  // the time remaining with respect to the HiGHS time limit (if
+  // finite)
+  double time_limit = options.time_limit;
+  if (time_limit < kHighsInf) {
+    time_limit -= timer.read();
+    time_limit = std::max(0.0, time_limit);
+  }
+  params.time_limit = time_limit;
+
+  params.scaling_method = ScalingMethod::NONE;
+  params.use_ruiz_scaling = false;
+  params.use_pc_scaling = false;
+  params.use_l2_scaling = false;
+  if ((options.pdlp_features_off & kPdlpScalingOff) == 0) {
+    // Use scaling: now see which
+    params.use_ruiz_scaling = options.pdlp_scaling_mode & kPdlpScalingRuiz;
+    params.use_pc_scaling = options.pdlp_scaling_mode & kPdlpScalingPC;
+    params.use_l2_scaling = options.pdlp_scaling_mode & kPdlpScalingL2;
+  }
+  params.ruiz_iterations = options.pdlp_ruiz_iterations;
+  //  params.ruiz_norm = INFINITY; Not set in parse_opions_file
+  //  params.pc_alpha = 1.0; Not set in parse_opions_file
+
+  // Restart strategy maps 0/1/2 to RestartStrategy
+  params.restart_strategy = RestartStrategy::NO_RESTART;
+  if ((options.pdlp_features_off & kPdlpRestartOff) == 0) {
+    // Use restart: now see which
+    if (options.pdlp_restart_strategy == kPdlpRestartStrategyFixed) {
+      params.restart_strategy = RestartStrategy::FIXED_RESTART;
+    } else if (options.pdlp_restart_strategy == kPdlpRestartStrategyAdaptive) {
+      params.restart_strategy = RestartStrategy::ADAPTIVE_RESTART;
+    }
+  }
+  //  params.fixed_restart_interval = 0; Not set in parse_opions_file
+  //  params.use_halpern_restart = false; Not set in parse_opions_file
+  
+  params.step_size_strategy = StepSizeStrategy::FIXED;
+  if ((options.pdlp_features_off & kPdlpAdaptiveStepSizeOff) == 0) {
+    // Use adaptive step size: now see which
+    if (options.pdlp_step_size_strategy == kPdlpStepSizeStrategyAdaptive) {
+      params.step_size_strategy = StepSizeStrategy::ADAPTIVE;
+    } else if (options.pdlp_step_size_strategy == kPdlpStepSizeStrategyMalitskyPock) {
+      params.step_size_strategy = StepSizeStrategy::MALITSKY_POCK;
+    }
+  }
+  //  params.malitsky_pock_params.initialise(); Not set in parse_opions_file
+  //  params.adaptive_linesearch_params.initialise(); Not set in parse_opions_file
+
 }
 
 void PrimalDualParams::initialise() {
-  this->eta = 0  ;
+  this->eta = 0;
   this->omega = 0;
   this->tolerance = 0;
   this->max_iterations = 0;