Renamed and methods names to debug_pdlp_log_file_ to stress its nature; also renamed pdlpIterLog etc to debugPdlpIterLog

Author: jajhall

highs/pdlp/cupdlp/cupdlp_defs.h

@@ -424,7 +424,7 @@ struct CUPDLP_WORK {
   // cusparseDnVecDescr_t vecbuffer;
   cublasHandle_t cublashandle;
 #endif
-  FILE* pdlp_log_file;
+  FILE* debug_pdlp_log_file;
 };
 
 #ifdef __cplusplus

highs/pdlp/cupdlp/cupdlp_solver.c

@@ -897,8 +897,8 @@ cupdlp_retcode PDHG_Solve(const cupdlp_int* has_variables, CUPDLPwork *pdhg) {
   timers->nIter = 0;
   timers->dSolvingBeg = getTimeStamp();
 
-  pdhg->pdlp_log_file = fopen("cuPDLP.log", "w");
-  assert(pdhg->pdlp_log_file);
+  pdhg->debug_pdlp_log_file = fopen("cuPDLP.log", "w");
+  assert(pdhg->debug_pdlp_log_file);
 
   // PDHG_Init_Data does nothing!
   PDHG_Init_Data(pdhg);
@@ -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, pdhg->stepsize->dBeta);
+    debugPdlpIterLog(pdhg->debug_pdlp_log_file, timers->nIter, pdhg->stepsize->dBeta);
     PDHG_Compute_SolvingTime(pdhg);
 #if CUPDLP_DUMP_ITERATES_STATS && CUPDLP_DEBUG
     PDHG_Dump_Stats(pdhg);
@@ -1154,7 +1154,7 @@ cupdlp_retcode PDHG_Solve(const cupdlp_int* has_variables, CUPDLPwork *pdhg) {
 #endif
 
 exit_cleanup:
-  fclose(pdhg->pdlp_log_file);
+  fclose(pdhg->debug_pdlp_log_file);
   return retcode;
 }
 

highs/pdlp/cupdlp/cupdlp_step.c

@@ -21,7 +21,7 @@ void PDHG_primalGradientStep(CUPDLPwork *work, CUPDLPvec *xUpdate,
 // print norm of A'y
 double aty_norm = 0.0;
 cupdlp_twoNorm(work, problem->nCols, ATy->data, &aty_norm);
-  pdlpAtyNormLog(work->pdlp_log_file, aty_norm);
+  debugPdlpAtyNormLog(work->debug_pdlp_log_file, aty_norm);
 
 #if !defined(CUPDLP_CPU) && USE_KERNELS
   cupdlp_pgrad_cuda(xUpdate->data, x->data, problem->cost,
@@ -200,7 +200,7 @@ void PDHG_Update_Iterate_Constant_Step_Size(CUPDLPwork *pdhg) {
   double ax_norm = 0.0;
   cupdlp_twoNorm(pdhg, problem->nRows, ax->data,
                   &ax_norm);
-  pdlpAxNormLog(pdhg->pdlp_log_file, ax_norm);
+  debugPdlpAxNormLog(pdhg->debug_pdlp_log_file, ax_norm);
   ATy(pdhg, aty, y);
 
   // x^{k+1} = proj_{X}(x^k - dPrimalStep * (c - A'y^k))

highs/pdlp/cupdlp/cupdlp_utils.c

@@ -1782,14 +1782,14 @@ void writeSol(const char *fout, cupdlp_int nCols, cupdlp_int nRows,
   fclose(fptr);
 }
 
-void pdlpIterLog(FILE* file, const int iter_num, const double beta) {
+void debugPdlpIterLog(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) {
+void debugPdlpAxNormLog(FILE* file, const double ax_norm) {
   fprintf(file, "||Ax|| = %g\n", ax_norm);
 }
 
-void pdlpAtyNormLog(FILE* file, const double aty_norm) {
+void debugPdlpAtyNormLog(FILE* file, const double aty_norm) {
   fprintf(file, "||A^Ty|| = %g\n", aty_norm);
 }

highs/pdlp/cupdlp/cupdlp_utils.h

@@ -193,9 +193,9 @@ 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, const double beta);
-  void pdlpAxNormLog(FILE* file, const double ax_norm);
-  void pdlpAtyNormLog(FILE* file, const double aty_norm);
+  void debugPdlpIterLog(FILE* file, const int iter_num, const double beta);
+  void debugPdlpAxNormLog(FILE* file, const double ax_norm);
+  void debugPdlpAtyNormLog(FILE* file, const double aty_norm);
 
 #ifdef __cplusplus
 }

highs/pdlp/hipdlp/pdhg.cc

@@ -273,16 +273,16 @@ void PDLPSolver::solve(std::vector<double>& x, std::vector<double>& y) {
 
   const HighsLp& lp = lp_;
 
-  pdlp_log_file_ = fopen("HiPDLP.log", "w");
-  assert(pdlp_log_file_);
+  debug_pdlp_log_file_ = fopen("HiPDLP.log", "w");
+  assert(debug_pdlp_log_file_);
 
   // --- 0.Using PowerMethod to estimate the largest eigenvalue ---
   const double op_norm_sq = PowerMethod();
   // Set step sizes based on the operator norm to ensure convergence
   // A safe choice satisfying eta * omega * ||A||^2 < 1
   step_.passLp(&lp_);
   step_.passLogOptions(&params_.log_options_);
-  step_.passDebugLogFile(pdlp_log_file_);
+  step_.passDebugLogFile(debug_pdlp_log_file_);
   StepSizeConfig step_size =
       step_.InitializeStepSizesPowerMethod(lp, op_norm_sq);
   const double fixed_eta = 0.99 / sqrt(op_norm_sq);
@@ -329,11 +329,11 @@ void PDLPSolver::solve(std::vector<double>& x, std::vector<double>& y) {
   // A single loop handles max iterations, convergence, and restarts.
   for (int iter = 0; iter < params_.max_iterations; ++iter) {
     const double dummy_beta = 0.0;
-    pdlpIterLog(pdlp_log_file_, iter, dummy_beta);
+    debugPdlpIterLog(debug_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);
+    debugPdlpAxNormLog(debug_pdlp_log_file_, ax_norm);
 
     linalg::ATy(lp, y_current_, ATy_current);
     if (solver_timer.read() > params_.time_limit) {
@@ -487,7 +487,7 @@ void PDLPSolver::solve(std::vector<double>& x, std::vector<double>& y) {
 }
 
 void PDLPSolver::solveReturn() {
-  if (pdlp_log_file_) fclose(pdlp_log_file_);
+  if (debug_pdlp_log_file_) fclose(debug_pdlp_log_file_);
 }
 
 void PDLPSolver::Initialize(const HighsLp& lp, std::vector<double>& x,

highs/pdlp/hipdlp/pdhg.hpp

@@ -93,7 +93,7 @@ class PDLPSolver {
   std::vector<double> dSlackPos_;
   std::vector<double> dSlackNeg_;
 
-  FILE* pdlp_log_file_ = nullptr;
+  FILE* debug_pdlp_log_file_ = nullptr;
   Timer total_timer;
 
   // Helper functions

highs/pdlp/hipdlp/step.cc

@@ -101,7 +101,7 @@ void PdlpStep::UpdateX(std::vector<double>& x_new,
   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);
+  debugPdlpAtyNormLog(debug_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,

highs/pdlp/hipdlp/step.hpp

@@ -77,18 +77,18 @@ class PdlpStep {
   void passLogOptions(const HighsLogOptions* log_options) {
     log_options_ = log_options;
   };
-  void passDebugLogFile(FILE* pdlp_log_file) {
-    pdlp_log_file_ = pdlp_log_file;
+  void passDebugLogFile(FILE* debug_pdlp_log_file) {
+    debug_pdlp_log_file_ = debug_pdlp_log_file;
   };
 
  private:
   const HighsLp* lp_;
   // JAJH has only passed log_options_ into PdlpStep, leaving YZ to
   // handle "params" as she sees fit.
   const HighsLogOptions* log_options_;
-  // JAJH has passed pdlp_log_file_ into PdlpStep separately, as it's
+  // JAJH has passed debug_pdlp_log_file_ into PdlpStep separately, as it's
   // only temporary.
-  FILE* pdlp_log_file_;
+  FILE* debug_pdlp_log_file_;
 };
 
 #endif  // PDLP_HIPDLP_STEP_HPP