Now trying to log beta

Author: jajhall

highs/pdlp/cupdlp/cupdlp_solver.c

@@ -918,7 +918,7 @@ cupdlp_retcode PDHG_Solve(const cupdlp_int* has_variables, CUPDLPwork *pdhg) {
   const int iter_log_between_header = 50;
   int iter_log_since_header = iter_log_between_header;
   for (timers->nIter = 0; timers->nIter < settings->nIterLim; ++timers->nIter) {
-    pdlpIterLog(pdhg->pdlp_log_file, timers->nIter);
+    pdlpIterLog(pdhg->pdlp_log_file, timers->nIter, pdhg->stepsize->dBeta);
     PDHG_Compute_SolvingTime(pdhg);
 #if CUPDLP_DUMP_ITERATES_STATS && CUPDLP_DEBUG
     PDHG_Dump_Stats(pdhg);

highs/pdlp/cupdlp/cupdlp_utils.c

@@ -1782,8 +1782,8 @@ void writeSol(const char *fout, cupdlp_int nCols, cupdlp_int nRows,
   fclose(fptr);
 }
 
-void pdlpIterLog(FILE* file, const int iter_num) {
-  fprintf(file, "Iter %6d\n", iter_num);
+void pdlpIterLog(FILE* file, const int iter_num, const double beta) {
+  fprintf(file, "Iter %6d; beta = %g\n", iter_num, beta);
 }
 
 void pdlpAxNormLog(FILE* file, const double ax_norm) {

highs/pdlp/cupdlp/cupdlp_utils.h

@@ -193,7 +193,7 @@ void writeSol(const char *fout, cupdlp_int nCols, cupdlp_int nRows,
               cupdlp_float *col_value, cupdlp_float *col_dual,
               cupdlp_float *row_value, cupdlp_float *row_dual);
 
-  void pdlpIterLog(FILE* file, const int iter_num);
+  void pdlpIterLog(FILE* file, const int iter_num, const double beta);
   void pdlpAxNormLog(FILE* file, const double ax_norm);
   void pdlpAtyNormLog(FILE* file, const double aty_norm);
 

highs/pdlp/hipdlp/pdhg.cc

@@ -356,17 +356,18 @@ void PDLPSolver::Solve(HighsLp& original_lp, const PrimalDualParams& params,
 
   logger_.print_iteration_header();
 
-  pdlp_log_file = fopen("HiPDLP.log", "w");
-  assert(pdlp_log_file);
+  pdlp_log_file_ = fopen("HiPDLP.log", "w");
+  assert(pdlp_log_file_);
 
   // --- 2. Main PDHG Loop ---
   // A single loop handles max iterations, convergence, and restarts.
   for (int iter = 0; iter < params.max_iterations; ++iter) {
-    pdlpIterLog(pdlp_log_file, iter);
+    const double dummy_beta = 0.0;
+    pdlpIterLog(pdlp_log_file_, iter, dummy_beta);
     linalg::Ax(lp, x_current_, Ax_current);
     //print norm of Ax
     double ax_norm = linalg::vector_norm(Ax_current);
-    pdlpAxNormLog(pdlp_log_file, ax_norm);
+    pdlpAxNormLog(pdlp_log_file_, ax_norm);
 
     linalg::ATy(lp, y_current_, ATy_current);
     if (solver_timer.read() > params.time_limit) {
@@ -399,22 +400,22 @@ void PDLPSolver::Solve(HighsLp& original_lp, const PrimalDualParams& params,
       case StepSizeStrategy::FIXED:
         step::UpdateIteratesFixed(lp, working_params, fixed_eta, x, y, Ax_new,
                                   x_current_, y_current_, Ax_current,
-				  pdlp_log_file);
+				  pdlp_log_file_);
         break;
 
       case StepSizeStrategy::ADAPTIVE:
         step::UpdateIteratesAdaptive(lp, working_params, x, y, Ax_new,
                                      x_current_, y_current_, Ax_current,
                                      ATy_current, current_eta_, iter,
-				  pdlp_log_file);
+				  pdlp_log_file_);
         break;
 
       case StepSizeStrategy::MALITSKY_POCK:
         step_success = step::UpdateIteratesMalitskyPock(
             lp, working_params, x, y, Ax_new, x_current_, y_current_,
             Ax_current, ATy_current, current_eta_, ratio_last_two_step_sizes_,
             num_rejected_steps_, first_malitsky_iteration,
-				  pdlp_log_file);
+				  pdlp_log_file_);
 
         if (!step_success) {
           std::cerr << "Malitsky-Pock step failed at iteration " << iter
@@ -566,7 +567,7 @@ void PDLPSolver::Solve(HighsLp& original_lp, const PrimalDualParams& params,
 }
 
 void PDLPSolver::solveReturn() {
-  if (pdlp_log_file) fclose(pdlp_log_file);
+  if (pdlp_log_file_) fclose(pdlp_log_file_);
 }
 
 void PDLPSolver::Initialize(const HighsLp& lp, std::vector<double>& x,

highs/pdlp/hipdlp/pdhg.hpp

@@ -84,7 +84,7 @@ class PDLPSolver {
   ScalingParams scaling_params_;
   Scaling scaling_;
 
-  FILE* pdlp_log_file = nullptr;
+  FILE* pdlp_log_file_ = nullptr;
 
   // HighsStatus TransformGxLeqToGeq(HighsLp& lp);
   void PreprocessLp(const HighsLp& original_lp, HighsLp& processed_lp);

highs/pdlp/hipdlp/step.cc

@@ -88,12 +88,12 @@ double ComputeNonlinearity(const std::vector<double>& delta_primal,
 void UpdateX(std::vector<double>& x_new, const std::vector<double>& x_current,
              const HighsLp& lp, const std::vector<double>& y_current,
              double eta, double omega,
-	     FILE* pdlp_log_file) {
+	     FILE* pdlp_log_file_) {
   std::vector<double> ATy_cache(lp.num_col_);
   linalg::ATy(lp, y_current, ATy_cache);
   //print the norm of ATy_cache
   double aty_norm = linalg::vector_norm(ATy_cache);
-  pdlpAtyNormLog(pdlp_log_file, aty_norm);
+  pdlpAtyNormLog(pdlp_log_file_, aty_norm);
   for (HighsInt i = 0; i < lp.num_col_; i++) {
     double gradient = lp.col_cost_[i] - ATy_cache[i];
     x_new[i] = linalg::project_box(x_current[i] - (eta / omega) * gradient,
@@ -142,8 +142,8 @@ void UpdateIteratesFixed(const HighsLp& lp, const PrimalDualParams& params,
                          const std::vector<double>& x_current,
                          const std::vector<double>& y_current,
                          const std::vector<double>& ax_current,
-			 FILE* pdlp_log_file) {
-  UpdateX(x_new, x_current, lp, y_current, params.eta, params.omega, pdlp_log_file);
+			 FILE* pdlp_log_file_) {
+  UpdateX(x_new, x_current, lp, y_current, params.eta, params.omega, pdlp_log_file_);
   linalg::Ax(lp, x_new, ax_new);
   UpdateY(y_new, y_current, lp, ax_new, ax_current, params.eta, params.omega);
 }
@@ -157,7 +157,7 @@ void UpdateIteratesAdaptive(const HighsLp& lp, const PrimalDualParams& params,
                             const std::vector<double>& ax_current,
                             const std::vector<double>& aty_current,
                             double& current_eta, int& step_size_iter_count,
-			    FILE* pdlp_log_file) {
+			    FILE* pdlp_log_file_) {
   const double MIN_ETA = 1e-6;
   const double MAX_ETA = 1.0;
 
@@ -182,7 +182,7 @@ void UpdateIteratesAdaptive(const HighsLp& lp, const PrimalDualParams& params,
     std::vector<double> aty_candidate(lp.num_col_);
 
     // Primal update
-    UpdateX(x_candidate, x_current, lp, y_current, current_eta, params.omega, pdlp_log_file);
+    UpdateX(x_candidate, x_current, lp, y_current, current_eta, params.omega, pdlp_log_file_);
     linalg::Ax(lp, x_candidate, ax_candidate);
 
     // Dual update
@@ -268,14 +268,14 @@ bool UpdateIteratesMalitskyPock(
     const std::vector<double>& aty_current, double& current_eta,
     double& ratio_last_two_step_sizes, int& num_rejected_steps,
     bool first_iteration,
-    FILE* pdlp_log_file)  // Add this parameter to track first iteration
+    FILE* pdlp_log_file_)  // Add this parameter to track first iteration
 {
   // Step 1: Compute primal update first (without extrapolation)
   const double primal_step_size = current_eta / params.omega;
 
   std::vector<double> x_candidate(lp.num_col_);
   UpdateX(x_candidate, x_current, lp, y_current, primal_step_size,
-          params.omega, pdlp_log_file);
+          params.omega, pdlp_log_file_);
 
   // Compute Ax for the primal candidate
   std::vector<double> ax_candidate(lp.num_row_);