Merge branch 'hi-pdlp-jh' into hi-pdlp

Author: jajhall

highs/pdlp/hipdlp/restart.cc

@@ -11,6 +11,8 @@
 // restart.cc
 #include "restart.hpp"
 
+#include "io/HighsIO.h"  // For pdlpLogging
+
 #include <algorithm>
 #include <cmath>
 
@@ -90,16 +92,13 @@ RestartInfo RestartScheme::Check(int current_iter,
           (candidate_score > last_candidate_score_);
 
       if (artificial_restart) {
-        std::cout << "Artificial restart triggered at iteration "
-                  << current_iter << std::endl;
+        highsLogUser(*log_options_, HighsLogType::kInfo, "Artificial restart triggered at iteration %d\n", current_iter);
         info.should_restart = true;
       } else if (sufficient_decay) {
-        std::cout << "Sufficient decay triggered at iteration " << current_iter
-                  << std::endl;
+        highsLogUser(*log_options_, HighsLogType::kInfo, "Sufficient decay triggered at iteration %d\n", current_iter);
         info.should_restart = true;
       } else if (necessary_decay) {
-        std::cout << "Necessary decay triggered at iteration " << current_iter
-                  << std::endl;
+        highsLogUser(*log_options_, HighsLogType::kInfo, "Necessary decay triggered at iteration %d\n", current_iter);
         info.should_restart = true;
       } else {
         info.should_restart = false;

highs/pdlp/hipdlp/restart.hpp

@@ -39,9 +39,11 @@ class RestartScheme {
 
   int GetLastRestartIter() const { return last_restart_iter_; }
   void passParams(const PrimalDualParams* params) { params_ = params; };
+  void passLogOptions(const HighsLogOptions* log_options) { log_options_ = log_options; };
 
  private:
   const PrimalDualParams* params_;
+  const HighsLogOptions* log_options_;
   // Computes a merit score for a given set of residuals
   double ComputeRestartScore(const SolverResults& results);
 

highs/pdlp/hipdlp/scaling.cc

@@ -17,6 +17,8 @@
 
 #include "linalg.hpp"
 
+#include "io/HighsIO.h"  // For pdlpLogging
+
 void Scaling::Initialize(const HighsLp& lp) {
   col_scale_.assign(lp.num_col_, 1.0);
   row_scale_.assign(lp.num_row_, 1.0);
@@ -27,11 +29,12 @@ void Scaling::Initialize(const HighsLp& lp) {
   norm_rhs_ = linalg::compute_rhs_norm(lp, 2.0);
 }
 
-void LogMatrixNorms(const HighsLp& lp, const std::string& stage) {
-  std::cout << "\n--- Matrix Norms " << stage << " ---" << std::endl;
+void Scaling::LogMatrixNorms(const std::string& stage) {
+  const HighsLp& lp = *lp_;
+  highsLogUser(params_->log_options_, HighsLogType::kInfo, "\n--- Matrix Norms %d ---\n", stage.c_str());
 
   if (lp.num_col_ == 0 || lp.num_row_ == 0) {
-    std::cout << "Matrix is empty." << std::endl;
+    highsLogUser(params_->log_options_, HighsLogType::kInfo, "Matrix is empty\n");
     return;
   }
 
@@ -43,7 +46,7 @@ void LogMatrixNorms(const HighsLp& lp, const std::string& stage) {
          iEl < lp.a_matrix_.start_[iCol + 1]; ++iEl) {
       max_abs_val = std::max(max_abs_val, std::abs(lp.a_matrix_.value_[iEl]));
     }
-    std::cout << "  Col " << iCol << ": " << max_abs_val << std::endl;
+    highsLogUser(params_->log_options_, HighsLogType::kInfo, "  Col %d: %g\n", iCol, max_abs_val);
   }
 
   // --- Calculate and Log Row Norms (Infinity Norm) ---
@@ -59,10 +62,9 @@ void LogMatrixNorms(const HighsLp& lp, const std::string& stage) {
   }
 
   for (HighsInt iRow = 0; iRow < lp.num_row_; ++iRow) {
-    std::cout << "  Row " << iRow << ": " << row_max_abs_vals[iRow]
-              << std::endl;
+    highsLogUser(params_->log_options_, HighsLogType::kInfo, "  Row %d: %g\n", iRow, row_max_abs_vals[iRow]);
   }
-  std::cout << "-------------------------\n" << std::endl;
+  highsLogUser(params_->log_options_, HighsLogType::kInfo, "-------------------------\n");
 }
 
 void Scaling::scaleProblem() {

highs/pdlp/hipdlp/scaling.hpp

@@ -27,7 +27,7 @@ class Scaling {
   void unscaleSolution(std::vector<double>& x, std::vector<double>& y) const;
   void passLp(HighsLp* lp) { lp_ = lp; };
   void passParams(const PrimalDualParams* params) { params_ = params; };
-
+  void LogMatrixNorms(const std::string& stage) ;
   // Get scaling vectors (for unscaling solution later)
   bool IsScaled() const { return is_scaled_; }
   const std::vector<double>& GetColScaling() const { return col_scale_; }