Now referring to non-primal simplex as dual in sub-solver timing; formatted

Author: jajhall

highs/lp_data/HConst.h

@@ -303,10 +303,10 @@ enum IisStatus : int {
 
 enum SubSolverIndex : int {
   kSubSolverMip = 0,
-  kSubSolverSimplexBasis,
-  kSubSolverSimplexNoBasis,
-  kSubSolverPrimalSimplexBasis,
-  kSubSolverPrimalSimplexNoBasis,
+  kSubSolverDuSimplexBasis,
+  kSubSolverDuSimplexNoBasis,
+  kSubSolverPrSimplexBasis,
+  kSubSolverPrSimplexNoBasis,
   kSubSolverHipo,
   kSubSolverIpx,
   kSubSolverHipoAc,

highs/lp_data/HighsInterface.cpp

@@ -4327,10 +4327,10 @@ void HighsSubSolverCallTime::initialise() {
   this->num_call.assign(kSubSolverCount, 0);
   this->run_time.assign(kSubSolverCount, 0);
   this->name.assign(kSubSolverCount, "");
-  this->name[kSubSolverSimplexBasis] = "Simplex (basis)";
-  this->name[kSubSolverSimplexNoBasis] = "Simplex (no basis)";
-  this->name[kSubSolverPrimalSimplexBasis] = "Primal simplex (basis)";
-  this->name[kSubSolverPrimalSimplexNoBasis] = "Primal simplex (no basis)";
+  this->name[kSubSolverDuSimplexBasis] = "Du simplex (basis)";
+  this->name[kSubSolverDuSimplexNoBasis] = "Du simplex (no basis)";
+  this->name[kSubSolverPrSimplexBasis] = "Pr simplex (basis)";
+  this->name[kSubSolverPrSimplexNoBasis] = "Pr simplex (no basis)";
   this->name[kSubSolverHipo] = "HiPO";
   this->name[kSubSolverIpx] = "IPX";
   this->name[kSubSolverHipoAc] = "HiPO (AC)";
@@ -4361,7 +4361,7 @@ void Highs::reportSubSolverCallTime() const {
   std::stringstream ss;
   ss.str(std::string());
   ss << highsFormatToString(
-      "\nSub-solver timing\nSolver                 Calls    Time       "
+      "\nSub-solver timing\nSolver                    Calls    Time       "
       "Time/call");
   if (mip_time > 0) ss << "  MIP%";
   highsLogUser(options_.log_options, HighsLogType::kInfo, "%s\n",
@@ -4372,7 +4372,7 @@ void Highs::reportSubSolverCallTime() const {
     if (this->sub_solver_call_time_.num_call[Ix]) {
       ss.str(std::string());
       ss << highsFormatToString(
-          "%-18s %9d %11.4e %11.4e",
+          "%-21s %9d %11.4e %11.4e",
           this->sub_solver_call_time_.name[Ix].c_str(),
           int(this->sub_solver_call_time_.num_call[Ix]),
           this->sub_solver_call_time_.run_time[Ix],
@@ -4391,7 +4391,7 @@ void Highs::reportSubSolverCallTime() const {
   }
   if (mip_time > 0)
     highsLogUser(options_.log_options, HighsLogType::kInfo,
-                 "TOTAL (excluding AC)         %11.4e             %5.1f\n",
+                 "TOTAL (excluding AC)            %11.4e             %5.1f\n",
                  sum_mip_sub_solve_time,
                  1e2 * sum_mip_sub_solve_time / mip_time);
 }

highs/mip/HighsMipAnalysis.cpp

@@ -124,29 +124,29 @@ void HighsMipAnalysis::mipTimerUpdate(
     // If IPM has not been run first, then check that simplex call
     // counts are consistent with valid_basis and presolve
     if (valid_basis) {
-      assert(sub_solver_call_time.num_call[kSubSolverSimplexNoBasis] == 0);
+      assert(sub_solver_call_time.num_call[kSubSolverDuSimplexNoBasis] == 0);
     } else if (!presolve) {
-      assert(sub_solver_call_time.num_call[kSubSolverSimplexBasis] == 0);
+      assert(sub_solver_call_time.num_call[kSubSolverDuSimplexBasis] == 0);
     }
   } else {
     // IPM has been run first, then at least one of the simplex call
     // counts should be zero
-    assert(sub_solver_call_time.num_call[kSubSolverSimplexBasis] == 0 ||
-	   sub_solver_call_time.num_call[kSubSolverSimplexNoBasis] == 0);
+    assert(sub_solver_call_time.num_call[kSubSolverDuSimplexBasis] == 0 ||
+           sub_solver_call_time.num_call[kSubSolverDuSimplexNoBasis] == 0);
   }
 
-  mipTimerAdd(kMipClockSimplexBasisSolveLp,
-	      sub_solver_call_time.num_call[kSubSolverSimplexBasis],
-	      sub_solver_call_time.run_time[kSubSolverSimplexBasis]);
-  mipTimerAdd(kMipClockSimplexNoBasisSolveLp,
-	      sub_solver_call_time.num_call[kSubSolverSimplexNoBasis],
-	      sub_solver_call_time.run_time[kSubSolverSimplexNoBasis]);
-  mipTimerAdd(kMipClockPrimalSimplexBasisSolveLp,
-	      sub_solver_call_time.num_call[kSubSolverPrimalSimplexBasis],
-	      sub_solver_call_time.run_time[kSubSolverPrimalSimplexBasis]);
-  mipTimerAdd(kMipClockPrimalSimplexNoBasisSolveLp,
-	      sub_solver_call_time.num_call[kSubSolverPrimalSimplexNoBasis],
-	      sub_solver_call_time.run_time[kSubSolverPrimalSimplexNoBasis]);
+  mipTimerAdd(kMipClockDuSimplexBasisSolveLp,
+              sub_solver_call_time.num_call[kSubSolverDuSimplexBasis],
+              sub_solver_call_time.run_time[kSubSolverDuSimplexBasis]);
+  mipTimerAdd(kMipClockDuSimplexNoBasisSolveLp,
+              sub_solver_call_time.num_call[kSubSolverDuSimplexNoBasis],
+              sub_solver_call_time.run_time[kSubSolverDuSimplexNoBasis]);
+  mipTimerAdd(kMipClockPrSimplexBasisSolveLp,
+              sub_solver_call_time.num_call[kSubSolverPrSimplexBasis],
+              sub_solver_call_time.run_time[kSubSolverPrSimplexBasis]);
+  mipTimerAdd(kMipClockPrSimplexNoBasisSolveLp,
+              sub_solver_call_time.num_call[kSubSolverPrSimplexNoBasis],
+              sub_solver_call_time.run_time[kSubSolverPrSimplexNoBasis]);
 
   if (sub_solver_call_time.num_call[kSubSolverHipo]) {
     const HighsInt mip_clock = analytic_centre
@@ -179,9 +179,9 @@ void HighsMipAnalysis::reportMipSolveLpClock(const bool header) {
   double total_time = mip_clocks.timer_pointer_->read(0);
   if (total_time < 0.01) return;
   HighsInt simplex_basis_solve_iclock =
-      mip_clocks.clock_[kMipClockSimplexBasisSolveLp];
+      mip_clocks.clock_[kMipClockDuSimplexBasisSolveLp];
   HighsInt simplex_no_basis_solve_iclock =
-      mip_clocks.clock_[kMipClockSimplexNoBasisSolveLp];
+      mip_clocks.clock_[kMipClockDuSimplexNoBasisSolveLp];
   HighsInt ipm_solve_iclock = mip_clocks.clock_[kMipClockIpxSolveLp];
   //  HighsInt num_no_basis_solve =
   //  mip_clocks.timer_pointer_->clock_num_call[no_basis_solve_iclock]; HighsInt
@@ -299,8 +299,8 @@ void HighsMipAnalysis::checkSubSolverCallTime(
       error = true;
     }
   };
-  check(kSubSolverSimplexBasis, kMipClockSimplexBasisSolveLp);
-  check(kSubSolverSimplexNoBasis, kMipClockSimplexNoBasisSolveLp);
+  check(kSubSolverDuSimplexBasis, kMipClockDuSimplexBasisSolveLp);
+  check(kSubSolverDuSimplexNoBasis, kMipClockDuSimplexNoBasisSolveLp);
   check(kSubSolverHipo, kMipClockHipoSolveLp);
   check(kSubSolverIpx, kMipClockIpxSolveLp);
   check(kSubSolverHipoAc, kMipClockHipoSolveAnalyticCentreLp);

highs/mip/MipTimer.h

@@ -96,14 +96,14 @@ enum iClockMip {
   kMipClockModKSepa,
 
   // LP solves
-  kMipClockSimplexBasisSolveLp,
-  kMipClockSimplexNoBasisSolveLp,
+  kMipClockDuSimplexBasisSolveLp,
+  kMipClockDuSimplexNoBasisSolveLp,
   kMipClockHipoSolveAnalyticCentreLp,
   kMipClockIpxSolveAnalyticCentreLp,
   kMipClockHipoSolveLp,
   kMipClockIpxSolveLp,
-  kMipClockPrimalSimplexBasisSolveLp,
-  kMipClockPrimalSimplexNoBasisSolveLp,
+  kMipClockPrSimplexBasisSolveLp,
+  kMipClockPrSimplexNoBasisSolveLp,
 
   // Sub-MIP solves
   kMipClockSubMipSolve,
@@ -138,11 +138,11 @@ class MipTimer {
     // clock[kMipClockHipoSolveAnalyticCentreLp] and
     // clock[kMipClockIpxSolveAnalyticCentreLp] aren't changed by inserting new
     // clocks
-    clock[kMipClockSimplexBasisSolveLp] =
-        timer_pointer->clock_def("Solve LP - simplex basis");
-    clock[kMipClockSimplexNoBasisSolveLp] =
-        timer_pointer->clock_def("Solve LP - simplex no basis");
-    assert(clock[kMipClockSimplexNoBasisSolveLp] == 8);
+    clock[kMipClockDuSimplexBasisSolveLp] =
+        timer_pointer->clock_def("Solve LP - du simplex basis");
+    clock[kMipClockDuSimplexNoBasisSolveLp] =
+        timer_pointer->clock_def("Solve LP - du simplex no basis");
+    assert(clock[kMipClockDuSimplexNoBasisSolveLp] == 8);
     clock[kMipClockHipoSolveAnalyticCentreLp] =
         timer_pointer->clock_def("Solve LP: HiPO analytic centre");
     clock[kMipClockIpxSolveAnalyticCentreLp] =
@@ -151,10 +151,10 @@ class MipTimer {
     assert(clock[kMipClockIpxSolveAnalyticCentreLp] == 10);
     clock[kMipClockHipoSolveLp] = timer_pointer->clock_def("Solve LP: HiPO");
     clock[kMipClockIpxSolveLp] = timer_pointer->clock_def("Solve LP: IPX");
-    clock[kMipClockPrimalSimplexBasisSolveLp] =
-        timer_pointer->clock_def("Solve LP - primal simplex basis");
-    clock[kMipClockPrimalSimplexNoBasisSolveLp] =
-        timer_pointer->clock_def("Solve LP - primal simplex no basis");
+    clock[kMipClockPrSimplexBasisSolveLp] =
+        timer_pointer->clock_def("Solve LP - pr simplex basis");
+    clock[kMipClockPrSimplexNoBasisSolveLp] =
+        timer_pointer->clock_def("Solve LP - pr simplex no basis");
 
     // Level 1 - Should correspond to kMipClockTotal
     clock[kMipClockInit] = timer_pointer->clock_def("Initialise");
@@ -372,10 +372,10 @@ class MipTimer {
 
   void reportMipSolveLpClock(const HighsTimerClock& mip_timer_clock) {
     const std::vector<HighsInt> mip_clock_list{
-        kMipClockSimplexBasisSolveLp,
-        kMipClockSimplexNoBasisSolveLp,
-        kMipClockPrimalSimplexBasisSolveLp,
-        kMipClockPrimalSimplexNoBasisSolveLp,
+        kMipClockDuSimplexBasisSolveLp,
+        kMipClockDuSimplexNoBasisSolveLp,
+        kMipClockPrSimplexBasisSolveLp,
+        kMipClockPrSimplexNoBasisSolveLp,
         kMipClockHipoSolveAnalyticCentreLp,
         kMipClockIpxSolveAnalyticCentreLp,
         kMipClockHipoSolveLp,

highs/simplex/HApp.h

@@ -44,17 +44,33 @@ inline HighsStatus returnFromSolveLpSimplex(HighsLpSolverObject& solver_object,
   // will generally be one after simplex, so have to deduce whether
   // there was one before
   HighsInt sub_solver_ix = -1;
-  if (solver_object.sub_solver_call_time_.run_time[kSubSolverSimplexBasis] < 0) sub_solver_ix = kSubSolverSimplexBasis;
-  if (solver_object.sub_solver_call_time_.run_time[kSubSolverSimplexNoBasis] < 0) sub_solver_ix = kSubSolverSimplexNoBasis;
-  if (solver_object.sub_solver_call_time_.run_time[kSubSolverPrimalSimplexBasis] < 0) sub_solver_ix = kSubSolverPrimalSimplexBasis;
-  if (solver_object.sub_solver_call_time_.run_time[kSubSolverPrimalSimplexNoBasis] < 0) sub_solver_ix = kSubSolverPrimalSimplexNoBasis;
+  if (solver_object.sub_solver_call_time_.run_time[kSubSolverDuSimplexBasis] <
+      0)
+    sub_solver_ix = kSubSolverDuSimplexBasis;
+  if (solver_object.sub_solver_call_time_.run_time[kSubSolverDuSimplexNoBasis] <
+      0)
+    sub_solver_ix = kSubSolverDuSimplexNoBasis;
+  if (solver_object.sub_solver_call_time_.run_time[kSubSolverPrSimplexBasis] <
+      0)
+    sub_solver_ix = kSubSolverPrSimplexBasis;
+  if (solver_object.sub_solver_call_time_.run_time[kSubSolverPrSimplexNoBasis] <
+      0)
+    sub_solver_ix = kSubSolverPrSimplexNoBasis;
   // Ensure that one clock has been identified
   assert(sub_solver_ix >= 0);
   // Check that only one clock was started
-  if (sub_solver_ix != kSubSolverSimplexBasis) assert(solver_object.sub_solver_call_time_.run_time[kSubSolverSimplexBasis] >= 0);
-  if (sub_solver_ix != kSubSolverSimplexNoBasis) assert(solver_object.sub_solver_call_time_.run_time[kSubSolverSimplexNoBasis] >= 0);
-  if (sub_solver_ix != kSubSolverPrimalSimplexBasis) assert(solver_object.sub_solver_call_time_.run_time[kSubSolverPrimalSimplexBasis] >= 0);
-  if (sub_solver_ix != kSubSolverPrimalSimplexNoBasis) assert(solver_object.sub_solver_call_time_.run_time[kSubSolverPrimalSimplexNoBasis] >= 0);
+  if (sub_solver_ix != kSubSolverDuSimplexBasis)
+    assert(solver_object.sub_solver_call_time_
+               .run_time[kSubSolverDuSimplexBasis] >= 0);
+  if (sub_solver_ix != kSubSolverDuSimplexNoBasis)
+    assert(solver_object.sub_solver_call_time_
+               .run_time[kSubSolverDuSimplexNoBasis] >= 0);
+  if (sub_solver_ix != kSubSolverPrSimplexBasis)
+    assert(solver_object.sub_solver_call_time_
+               .run_time[kSubSolverPrSimplexBasis] >= 0);
+  if (sub_solver_ix != kSubSolverPrSimplexNoBasis)
+    assert(solver_object.sub_solver_call_time_
+               .run_time[kSubSolverPrSimplexNoBasis] >= 0);
   // Update the call count and run time
   solver_object.sub_solver_call_time_.num_call[sub_solver_ix]++;
   solver_object.sub_solver_call_time_.run_time[sub_solver_ix] +=
@@ -122,15 +138,15 @@ inline HighsStatus solveLpSimplex(HighsLpSolverObject& solver_object) {
   HighsInt sub_solver_ix = -1;
   if (options.simplex_strategy == kSimplexStrategyPrimal) {
     if (basis.valid) {
-      sub_solver_ix = kSubSolverPrimalSimplexBasis;
+      sub_solver_ix = kSubSolverPrSimplexBasis;
     } else {
-      sub_solver_ix = kSubSolverPrimalSimplexNoBasis;
+      sub_solver_ix = kSubSolverPrSimplexNoBasis;
     }
   } else {
     if (basis.valid) {
-      sub_solver_ix = kSubSolverSimplexBasis;
+      sub_solver_ix = kSubSolverDuSimplexBasis;
     } else {
-      sub_solver_ix = kSubSolverSimplexNoBasis;
+      sub_solver_ix = kSubSolverDuSimplexNoBasis;
     }
   }
   assert(sub_solver_ix >= 0);