Wrapper now no longer uses Scaling, rather PDLPSolver::scaleProblem and PDLPSolver::unscaleSolution

Author: jajhall

check/TestPdlp.cpp

@@ -344,11 +344,12 @@ TEST_CASE("hi-pdlp", "[pdlp]") {
   h.setOptionValue("pdlp_restart_strategy", 0);
   h.setOptionValue("pdlp_step_size_strategy", 0);
 
-  h.setOptionValue("pdlp_iteration_limit", 15);
+  //  h.setOptionValue("pdlp_iteration_limit", 15);
   //  h.setOptionValue("log_dev_level", kHighsLogDevLevelVerbose);
   HighsStatus run_status = h.run();
   //  REQUIRE(run_status == HighsStatus::kOk);
   //  REQUIRE(h.getModelStatus() == HighsModelStatus::kOptimal);
+  REQUIRE(h.getInfo().pdlp_iteration_count == 11880);
   const bool cupdlp_test = true;
   if (cupdlp_test) {
     h.clearSolver();

highs/pdlp/HiPdlpWrapper.cpp

@@ -63,34 +63,34 @@ HighsStatus solveLpHiPdlp(const HighsOptions& options, HighsTimer& timer,
   HighsLp preprocessed_lp;
   pdlp.passLp(&lp);
   // logger_.info("Preprocessing LP to handle ranged constraints...");
-  pdlp.PreprocessLp();
+  pdlp.preprocessLp();
 
   // 3. Scale with HiPdlp
-  pdlp.scaling_.ScaleProblem();
+  pdlp.scaleProblem();
 
   // 4. Solve with HiPdlp
   std::vector<double> x, y;
-  pdlp.Solve(x, y);
+  pdlp.solve(x, y);
 
   // 5. Unscale with HiPdlp
-  pdlp.scaling_.UnscaleSolution(x, y);
+  pdlp.unscaleSolution(x, y);
 
   // 6. Postprocess with HiPDLP
   HighsSolution pdlp_solution;
-  // pdlp.Postsolve(presolved_lp, preprocessed_lp, x, y, pdlp_solution); //
+  // pdlp.postprocess(presolved_lp, preprocessed_lp, x, y, pdlp_solution); //
   // return x, y
 
   // --- Print Summary ---
-  logger.print_summary(pdlp.GetResults(), pdlp.GetIterationCount(),
+  logger.print_summary(pdlp.getResults(), pdlp.getIterationCount(),
                        total_timer.read());
 
-  highs_info.pdlp_iteration_count = pdlp.GetIterationCount();
+  highs_info.pdlp_iteration_count = pdlp.getIterationCount();
 
   model_status = HighsModelStatus::kUnknown;
   highs_solution.clear();
   highs_basis.valid = false;
 
-  const TerminationStatus termination_status = pdlp.GetResults().term_code;
+  const TerminationStatus termination_status = pdlp.getResults().term_code;
   switch (termination_status) {
     case TerminationStatus::OPTIMAL: {
       model_status = HighsModelStatus::kOptimal;

highs/pdlp/hipdlp/pdhg.cc

@@ -24,9 +24,9 @@
 
 using namespace std;
 
-int PDLPSolver::GetIterationCount() const { return final_iter_count_; }
+int PDLPSolver::getIterationCount() const { return final_iter_count_; }
 
-void PDLPSolver::PreprocessLp() {
+void PDLPSolver::preprocessLp() {
   logger_.info(
       "Preprocessing LP using cupdlp formulation (slack variables for "
       "bounds)...");
@@ -175,7 +175,7 @@ void PDLPSolver::PreprocessLp() {
                std::to_string(processed_lp.num_col_) + " cols.");
 }
 
-void PDLPSolver::Postsolve(HighsSolution& solution) {
+void PDLPSolver::postprocess(HighsSolution& solution) {
   logger_.info("Post-solving the solution...");
 
   std::vector<double> x_unscaled = x_current_;
@@ -185,7 +185,7 @@ void PDLPSolver::Postsolve(HighsSolution& solution) {
   std::vector<double> dSlackNeg_unscaled = dSlackNeg_;
 
   // 1. Unscale the solution vectors first
-  scaling_.UnscaleSolution(x_unscaled, y_unscaled);
+  unscaleSolution(x_unscaled, y_unscaled);
   const auto& row_scale = scaling_.GetRowScaling();  // Assumes getter exists
   const auto& col_scale = scaling_.GetColScaling();  // Assumes getter exists
   if (col_scale.size() == dSlackPos_unscaled.size()) {
@@ -272,7 +272,7 @@ void PDLPSolver::Postsolve(HighsSolution& solution) {
 
 PDLPSolver::PDLPSolver(Logger& logger) : logger_(logger) {}
 
-void PDLPSolver::Solve(std::vector<double>& x, std::vector<double>& y) {
+void PDLPSolver::solve(std::vector<double>& x, std::vector<double>& y) {
   Timer solver_timer;
 
   const HighsLp& lp = lp_;
@@ -379,7 +379,7 @@ void PDLPSolver::Solve(std::vector<double>& x, std::vector<double>& y) {
           // Reset to average and terminate
           x = x_avg_;
           y = y_avg_;
-          // scaling_.UnscaleSolution(x, y);
+          // unscalesolution(x, y);
           return solveReturn();
         }
     }
@@ -951,3 +951,14 @@ void PDLPSolver::setParams(const HighsOptions& options, HighsTimer& timer) {
   scaling_.passParams(&params_);
   restart_scheme_.passParams(&params_);
 }
+
+void PDLPSolver::scaleProblem() {
+  scaling_.passLp(&lp_);
+  scaling_.passParams(&params_);
+  scaling_.scaleProblem();
+}
+
+void PDLPSolver::unscaleSolution(std::vector<double>& x,
+                                 std::vector<double>& y) const {
+  scaling_.unscaleSolution(x, y);
+}

highs/pdlp/hipdlp/pdhg.hpp

@@ -37,22 +37,19 @@ class PDLPSolver {
  public:
   PDLPSolver(Logger& logger);
   void setParams(const HighsOptions& options, HighsTimer& timer);
-  void PreprocessLp();
-  void ScaleProblem(HighsLp& lp, const PrimalDualParams& params);
-  void Solve(std::vector<double>& x, std::vector<double>& y);
-  void Postsolve(HighsSolution& solution);
+  void preprocessLp();
+  void scaleProblem();
+  void solve(std::vector<double>& x, std::vector<double>& y);
+  void unscaleSolution(std::vector<double>& x, std::vector<double>& y) const;
+  void postprocess(HighsSolution& solution);
   void setSolution(const std::vector<double>& col_value,
                    const std::vector<double>& row_dual);
   void getSolution(std::vector<double>& col_value,
                    std::vector<double>& row_dual);
 
-  const SolverResults& GetResults() const { return results_; }
+  const SolverResults& getResults() const { return results_; }
   void passLp(const HighsLp* lp) { original_lp_ = lp; }
-  // Scaling
-  // ScalingParams scaling_params_;
-  Scaling scaling_;
-
-  int GetIterationCount() const;
+  int getIterationCount() const;
 
  private:
   // Problem data
@@ -78,6 +75,8 @@ class PDLPSolver {
   std::vector<double>* y_ = nullptr;
   std::vector<double> x_current_;
   std::vector<double> y_current_;
+  // Scaling
+  Scaling scaling_;
   // Restart State
   std::vector<double> x_avg_, y_avg_;
   std::vector<double> x_sum_, y_sum_;

highs/pdlp/hipdlp/scaling.cc

@@ -65,7 +65,7 @@ void LogMatrixNorms(const HighsLp& lp, const std::string& stage) {
   std::cout << "-------------------------\n" << std::endl;
 }
 
-void Scaling::ScaleProblem() {
+void Scaling::scaleProblem() {
   if (params_->scaling_method == ScalingMethod::NONE) {
     std::cout << "No scaling applied." << std::endl;
     return;
@@ -298,7 +298,7 @@ void Scaling::ApplyScaling(const std::vector<double>& col_scaling,
   }
 }
 
-void Scaling::UnscaleSolution(std::vector<double>& x,
+void Scaling::unscaleSolution(std::vector<double>& x,
                               std::vector<double>& y) const {
   if (!is_scaled_) return;
 

highs/pdlp/hipdlp/scaling.hpp

@@ -23,8 +23,8 @@ class Scaling {
   Scaling() = default;
 
   void Initialize(const HighsLp& lp);
-  void ScaleProblem();
-  void UnscaleSolution(std::vector<double>& x, std::vector<double>& y) const;
+  void scaleProblem();
+  void unscaleSolution(std::vector<double>& x, std::vector<double>& y) const;
   void passLp(HighsLp* lp) { lp_ = lp; };
   void passParams(const PrimalDualParams* params) { params_ = params; };