Added initialiseIterationInfo to HekkPrimal and HekkDual so iteration info is not unassigned

Julian Hall · Julian Hall · commit 3b82c5da6e2c · 2026-02-22T16:54:52.000Z
diff --git a/check/TestLpSolvers.cpp b/check/TestLpSolvers.cpp
@@ -553,32 +553,32 @@ TEST_CASE("choose-lp-solver", "[highs_lp_solver]") {
 
   h.resetGlobalScheduler(true);
 }
-/*
+
 TEST_CASE("chuzc4", "[highs_lp_solver]") {
   std::string model_file =
-        "/srv/mps_da/fit2d.mps.gz";
+      std::string(HIGHS_DIR) + "/check/instances/fit2d.mps";
   //    "/srv/miplib2017/irp.mps.gz";
   //    "/srv/miplib2017/nw04.mps.gz";
   Highs h;
   //  h.setOptionValue("output_flag", dev_run);
   h.readModel(model_file);
-  h.setOptionValue("highs_analysis_level", 2+8);
+  h.setOptionValue("highs_analysis_level", 2 + 8);
   h.setOptionValue("presolve", kHighsOffString);
   h.setOptionValue("solve_relaxation", true);
   for (HighsInt k = 0; k < 3; k++) {
     if (k == 0) {
-      h.setOptionValue("dual_simplex_chuzc_strategy", kDualSimplexChuzcStrategyChoose);
+      h.setOptionValue("dual_simplex_chuzc_strategy",
+                       kDualSimplexChuzcStrategyChoose);
     } else if (k == 1) {
-      h.setOptionValue("dual_simplex_chuzc_strategy", kDualSimplexChuzcStrategyQuad);
+      h.setOptionValue("dual_simplex_chuzc_strategy",
+                       kDualSimplexChuzcStrategyQuad);
     } else {
-      h.setOptionValue("dual_simplex_chuzc_strategy", kDualSimplexChuzcStrategyHeap);
+      h.setOptionValue("dual_simplex_chuzc_strategy",
+                       kDualSimplexChuzcStrategyHeap);
     }
     h.clearSolver();
     h.zeroAllClocks();
     h.run();
   }
   h.resetGlobalScheduler(true);
-
 }
-
-*/
diff --git a/check/instances/fit2d.mps b/check/instances/fit2d.mps
diff --git a/highs/lp_data/HConst.h b/highs/lp_data/HConst.h
@@ -332,6 +332,11 @@ const double kHessianRegularizationValue = 1e-7;
 const HighsInt kDefaultAllowedMatrixPow2Scale = 20;
 const HighsInt kMaxAllowedMatrixPow2Scale = 30;
 
+// Illegal values of simplex iteration information to check whether
+// they have been set
+const double kHighsIllegalSimplexInterationDoubleValue = -kHighsInf;
+const HighsInt kHighsIllegalSimplexInterationIntValue = -kHighsIInf;
+
 // Illegal values of num/max/sum infeasibility - used to indicate that true
 // values aren't known
 const double kHighsIllegalInfeasibilityMeasure = kHighsInf;
diff --git a/highs/lp_data/HighsOptions.h b/highs/lp_data/HighsOptions.h
@@ -1467,8 +1467,8 @@ class HighsOptions : public HighsOptionsStruct {
     records.push_back(record_int);
 
     record_int = new OptionRecordInt(
-        "dual_simplex_chuzc_strategy", "Strategy for CHUZC in dual simplex", advanced,
-        &dual_simplex_chuzc_strategy, kDualSimplexChuzcStrategyMin,
+        "dual_simplex_chuzc_strategy", "Strategy for CHUZC in dual simplex",
+        advanced, &dual_simplex_chuzc_strategy, kDualSimplexChuzcStrategyMin,
         kDualSimplexChuzcStrategyQuad, kDualSimplexChuzcStrategyMax);
     records.push_back(record_int);
 
diff --git a/highs/simplex/HEkkDual.cpp b/highs/simplex/HEkkDual.cpp
@@ -1013,6 +1013,22 @@ void HEkkDual::solvePhase2() {
   return;
 }
 
+void HEkkDual::initialiseIterationInfo() {
+  // integers
+  this->row_out = kHighsIllegalSimplexInterationIntValue;
+  this->variable_out = kHighsIllegalSimplexInterationIntValue;
+  this->move_out = kHighsIllegalSimplexInterationIntValue;
+  this->variable_in = kHighsIllegalSimplexInterationIntValue;
+  // doubles
+  this->delta_primal = kHighsIllegalSimplexInterationDoubleValue;
+  this->theta_dual = kHighsIllegalSimplexInterationDoubleValue;
+  this->theta_primal = kHighsIllegalSimplexInterationDoubleValue;
+  this->alpha_col = kHighsIllegalSimplexInterationDoubleValue;
+  this->alpha_row = kHighsIllegalSimplexInterationDoubleValue;
+  this->numericalTrouble = kHighsIllegalSimplexInterationDoubleValue;
+  this->computed_edge_weight = kHighsIllegalSimplexInterationDoubleValue;
+}
+
 void HEkkDual::rebuild() {
   HighsSimplexInfo& info = ekk_instance_.info_;
   HighsSimplexStatus& status = ekk_instance_.status_;
@@ -1204,6 +1220,8 @@ void HEkkDual::iterate() {
     }
   }
 
+  this->initialiseIterationInfo();
+
   analysis->simplexTimerStart(IterateChuzrClock);
   chooseRow();
   analysis->simplexTimerStop(IterateChuzrClock);
@@ -1322,9 +1340,9 @@ void HEkkDual::iterationAnalysisData() {
   analysis->leaving_variable = variable_out;
   analysis->entering_variable = variable_in;
   analysis->rebuild_reason = rebuild_reason;
-  analysis->reduced_rhs_value = 0;
-  analysis->reduced_cost_value = 0;
-  analysis->edge_weight = 0;
+  analysis->reduced_rhs_value = kHighsIllegalSimplexInterationDoubleValue;
+  analysis->reduced_cost_value = kHighsIllegalSimplexInterationDoubleValue;
+  analysis->edge_weight = kHighsIllegalSimplexInterationDoubleValue;
   analysis->primal_delta = delta_primal;
   analysis->primal_step = theta_primal;
   analysis->dual_step = theta_dual * cost_scale_factor;
diff --git a/highs/simplex/HEkkDual.h b/highs/simplex/HEkkDual.h
@@ -94,6 +94,11 @@ class HEkkDual {
    */
   void solvePhase2();
 
+  /**
+   * @brief Initialise iteration information
+   */
+  void initialiseIterationInfo();
+
   /**
    * @brief Reinvert if INVERT not fresh, then recompute dual and primal values
    *
diff --git a/highs/simplex/HEkkDualRow.cpp b/highs/simplex/HEkkDualRow.cpp
@@ -164,11 +164,11 @@ HighsInt HEkkDualRow::chooseFinal() {
       kDualSimplexChuzcStrategyQuad) {
     use_quad_sort = true;
   } else if (ekk_instance_.info_.dual_simplex_chuzc_strategy ==
-	     kDualSimplexChuzcStrategyHeap) {
+             kDualSimplexChuzcStrategyHeap) {
     use_heap_sort = true;
   } else {
     assert(ekk_instance_.info_.dual_simplex_chuzc_strategy ==
-	   kDualSimplexChuzcStrategyChoose);
+           kDualSimplexChuzcStrategyChoose);
     use_quad_sort = workCount < 10;
     use_heap_sort = !use_quad_sort;
   }
@@ -279,15 +279,15 @@ HighsInt HEkkDualRow::chooseFinal() {
     for (HighsInt i = workGroup[breakGroup]; i < workGroup[breakGroup + 1]; i++)
       if (report_bfrt) debugReportBfrtVar(i, workData);
   } else {
-    if (report_debug_bfrt) printf("DebugHeapSortCHUZC: Pivot = %4d; alpha = %11.4g; theta = %11.4g\n",
-           (int)workPivot, workAlpha, workTheta);
     if (report_debug_bfrt)
-      debugReportBfrtVar(-1, sorted_workData);
+      printf(
+          "DebugHeapSortCHUZC: Pivot = %4d; alpha = %11.4g; theta = %11.4g\n",
+          (int)workPivot, workAlpha, workTheta);
+    if (report_debug_bfrt) debugReportBfrtVar(-1, sorted_workData);
     for (HighsInt i = 0; i < alt_workGroup[breakGroup]; i++) {
       const HighsInt iCol = sorted_workData[i].first;
       const HighsInt move = workMove[iCol];
-      if (report_debug_bfrt)
-	debugReportBfrtVar(i, sorted_workData);
+      if (report_debug_bfrt) debugReportBfrtVar(i, sorted_workData);
       workData[workCount++] = make_pair(iCol, move * workRange[iCol]);
     }
     // Look at all entries of final group to see what dual
@@ -298,8 +298,7 @@ HighsInt HEkkDualRow::chooseFinal() {
     //    HighsInt num_infeasibility = 0;
     const double Td = ekk_instance_.options_->dual_feasibility_tolerance;
     for (HighsInt i = alt_workGroup[breakGroup]; i < to_i; i++) {
-      if (report_debug_bfrt)
-	debugReportBfrtVar(i, sorted_workData);
+      if (report_debug_bfrt) debugReportBfrtVar(i, sorted_workData);
       const HighsInt iCol = sorted_workData[i].first;
       const double value = sorted_workData[i].second;
       const HighsInt move = workMove[iCol];
diff --git a/highs/simplex/HEkkPrimal.cpp b/highs/simplex/HEkkPrimal.cpp
@@ -646,6 +646,22 @@ void HEkkPrimal::solvePhase2() {
   }
 }
 
+void HEkkPrimal::initialiseIterationInfo() {
+  // integers
+  this->variable_in = kHighsIllegalSimplexInterationIntValue;
+  this->move_in = kHighsIllegalSimplexInterationIntValue;
+  this->row_out = kHighsIllegalSimplexInterationIntValue;
+  this->variable_out = kHighsIllegalSimplexInterationIntValue;
+  this->move_out = kHighsIllegalSimplexInterationIntValue;
+  // doubles
+  this->theta_dual = kHighsIllegalSimplexInterationDoubleValue;
+  this->theta_primal = kHighsIllegalSimplexInterationDoubleValue;
+  this->value_in = kHighsIllegalSimplexInterationDoubleValue;
+  this->alpha_col = kHighsIllegalSimplexInterationDoubleValue;
+  this->alpha_row = kHighsIllegalSimplexInterationDoubleValue;
+  this->numericalTrouble = kHighsIllegalSimplexInterationDoubleValue;
+}
+
 void HEkkPrimal::cleanup() {
   HighsSimplexInfo& info = ekk_instance_.info_;
   if (!info.bounds_shifted && !info.bounds_perturbed) return;
@@ -825,6 +841,9 @@ void HEkkPrimal::iterate() {
     solve_phase = kSolvePhaseError;
     return;
   }
+
+  this->initialiseIterationInfo();
+
   // Initialise row_out so that aborting iteration before CHUZR due to
   // numerical test of chosen reduced cost can be spotted - and
   // eliminates the unassigned read that can occur when the first
@@ -2588,10 +2607,10 @@ void HEkkPrimal::iterationAnalysisData() {
   analysis->leaving_variable = variable_out;
   analysis->entering_variable = variable_in;
   analysis->rebuild_reason = rebuild_reason;
-  analysis->reduced_rhs_value = 0;
-  analysis->reduced_cost_value = 0;
-  analysis->edge_weight = 0;
-  analysis->primal_delta = 0;
+  analysis->reduced_rhs_value = kHighsIllegalSimplexInterationDoubleValue;
+  analysis->reduced_cost_value = kHighsIllegalSimplexInterationDoubleValue;
+  analysis->edge_weight = kHighsIllegalSimplexInterationDoubleValue;
+  analysis->primal_delta = kHighsIllegalSimplexInterationDoubleValue;
   analysis->primal_step = theta_primal;
   analysis->dual_step = theta_dual;
   analysis->pivot_value_from_column = alpha_col;
diff --git a/highs/simplex/HEkkPrimal.h b/highs/simplex/HEkkPrimal.h
@@ -43,6 +43,7 @@ class HEkkPrimal {
   void initialiseSolve();
   void solvePhase1();
   void solvePhase2();
+  void initialiseIterationInfo();
   void cleanup();
   void rebuild();
 
diff --git a/highs/simplex/SimplexTimer.h b/highs/simplex/SimplexTimer.h
@@ -233,10 +233,10 @@ class SimplexTimer {
         timer_pointer->clock_time[clock[SimplexTotalClock]];
     const double tolerance_percent_report =
         tolerance_percent_report_ >= 0 ? tolerance_percent_report_ : 1e-8;
-    return timer_pointer->reportOnTolerance(
-        grepStamp, clockList, ideal_sum_time,
-	1.0); //fix-2710
-	//	tolerance_percent_report);
+    return timer_pointer->reportOnTolerance(grepStamp, clockList,
+                                            ideal_sum_time,
+                                            1.0);  // fix-2710
+    //	tolerance_percent_report);
   };
 
   void reportChuzc4ClockList(const std::vector<HighsInt> simplex_clock_list,
diff --git a/highs/util/HighsUtils.cpp b/highs/util/HighsUtils.cpp
@@ -752,7 +752,8 @@ bool updateValueDistribution(const double value,
   value_distribution.sum_count_++;
   const double abs_value = fabs(value);
   printf("updateValueDistribution abs_value = %g\n", abs_value);
-  printf("updateValueDistribution value_distribution.min_value_ = %g\n", value_distribution.min_value_);
+  printf("updateValueDistribution value_distribution.min_value_ = %g\n",
+         value_distribution.min_value_);
   value_distribution.min_value_ =
       std::min(abs_value, value_distribution.min_value_);
   value_distribution.max_value_ =
