Generalise reportPresolveReductions

Author: jajhall

highs/lp_data/Highs.cpp

@@ -841,8 +841,9 @@ HighsStatus Highs::writeBasis(const std::string& filename) {
 }
 
 HighsStatus Highs::presolve() {
+  const HighsLogOptions& log_options = options_.log_options;
   if (model_.needsMods(options_.infinite_cost)) {
-    highsLogUser(options_.log_options, HighsLogType::kError,
+    highsLogUser(log_options, HighsLogType::kError,
                  "Model contains infinite costs or semi-variables, so cannot "
                  "be presolved independently\n");
     return HighsStatus::kError;
@@ -861,7 +862,7 @@ HighsStatus Highs::presolve() {
     max_threads = highs::parallel::num_threads();
     if (options_.threads != 0 && max_threads != options_.threads) {
       highsLogUser(
-          options_.log_options, HighsLogType::kError,
+          log_options, HighsLogType::kError,
           "Option 'threads' is set to %d but global scheduler has already been "
           "initialized to use %d threads. The previous scheduler instance can "
           "be destroyed by calling Highs::resetGlobalScheduler().\n",
@@ -873,6 +874,7 @@ HighsStatus Highs::presolve() {
   }
 
   bool using_reduced_lp = false;
+  HighsLp& incumbent_lp = model_.lp_;
   switch (model_presolve_status_) {
     case HighsPresolveStatus::kNotPresolved: {
       // Shouldn't happen
@@ -881,9 +883,12 @@ HighsStatus Highs::presolve() {
       break;
     }
     case HighsPresolveStatus::kNotReduced:
+      reportPresolveReductions(log_options, incumbent_lp, false);
     case HighsPresolveStatus::kInfeasible:
     case HighsPresolveStatus::kReduced:
+        reportPresolveReductions(log_options, incumbent_lp, presolve_.getReducedProblem());
     case HighsPresolveStatus::kReducedToEmpty:
+      reportPresolveReductions(log_options, incumbent_lp, true);
     case HighsPresolveStatus::kUnboundedOrInfeasible: {
       // All OK
       if (model_presolve_status_ == HighsPresolveStatus::kInfeasible) {
@@ -915,7 +920,7 @@ HighsStatus Highs::presolve() {
     default: {
       // case HighsPresolveStatus::kOutOfMemory
       assert(model_presolve_status_ == HighsPresolveStatus::kOutOfMemory);
-      highsLogUser(options_.log_options, HighsLogType::kError,
+      highsLogUser(log_options, HighsLogType::kError,
                    "Presolve fails due to memory allocation error\n");
       setHighsModelStatusAndClearSolutionAndBasis(
           HighsModelStatus::kPresolveError);
@@ -927,7 +932,7 @@ HighsStatus Highs::presolve() {
     presolved_model_.lp_.setMatrixDimensions();
   }
 
-  highsLogUser(options_.log_options, HighsLogType::kInfo,
+  highsLogUser(log_options, HighsLogType::kInfo,
                "Presolve status: %s\n",
                presolveStatusToString(model_presolve_status_).c_str());
   return returnFromHighs(return_status);
@@ -1400,6 +1405,7 @@ HighsStatus Highs::optimizeModel() {
     // presolved problem, since the iteration count is reset to zero
     // if PDLP is used to clean up after postsolve
     HighsInt presolved_lp_pdlp_iteration_count = 0;
+    //    reportPresolveReductions(log_options, model_presolve_status_, incumbent_lp, presolve_.getReducedProblem());
     switch (model_presolve_status_) {
       case HighsPresolveStatus::kNotPresolved: {
         ekk_instance_.lp_name_ = "Original LP";
@@ -3522,8 +3528,8 @@ HighsPresolveStatus Highs::runPresolve(const bool force_lp_presolve,
     // Start the MIP solver's timer so that timeout in presolve can be
     // identified
     solver.timer_.start();
-    // Only place that HighsMipSolver::runPresolve is called
-    solver.runPresolve(options_.presolve_reduction_limit);
+    // Only place that HighsMipSolver::runMipPresolve is called
+    solver.runMipPresolve(options_.presolve_reduction_limit);
     presolve_return_status = solver.getPresolveStatus();
     // Assign values to data members of presolve_
     presolve_.data_.reduced_lp_ = solver.getPresolvedModel();

highs/lp_data/HighsLpUtils.cpp

@@ -1808,8 +1808,8 @@ void reportLpDimensions(const HighsLogOptions& log_options, const HighsLp& lp) {
   else
     lp_num_nz = lp.a_matrix_.start_[lp.num_col_];
   highsLogUser(log_options, HighsLogType::kInfo,
-               "LP has %" HIGHSINT_FORMAT " columns, %" HIGHSINT_FORMAT " rows",
-               lp.num_col_, lp.num_row_);
+               "LP has %" HIGHSINT_FORMAT " rows, %" HIGHSINT_FORMAT " columns",
+               lp.num_row_, lp.num_col_);
   HighsInt num_int = getNumInt(lp);
   if (num_int) {
     highsLogUser(log_options, HighsLogType::kInfo,
@@ -2962,60 +2962,60 @@ void reportPresolveReductions(const HighsLogOptions& log_options,
                               const HighsLp& lp, const HighsLp& presolve_lp) {
   HighsInt num_col_from = lp.num_col_;
   HighsInt num_row_from = lp.num_row_;
-  HighsInt num_els_from = lp.a_matrix_.start_[num_col_from];
+  HighsInt num_nz_from = lp.a_matrix_.start_[num_col_from];
   HighsInt num_col_to = presolve_lp.num_col_;
   HighsInt num_row_to = presolve_lp.num_row_;
-  HighsInt num_els_to;
+  HighsInt num_nz_to;
   if (num_col_to) {
-    num_els_to = presolve_lp.a_matrix_.start_[num_col_to];
+    num_nz_to = presolve_lp.a_matrix_.start_[num_col_to];
   } else {
-    num_els_to = 0;
+    num_nz_to = 0;
   }
-  char elemsignchar = '-';
-  HighsInt elemdelta = num_els_from - num_els_to;
-  if (num_els_from < num_els_to) {
-    elemdelta = -elemdelta;
-    elemsignchar = '+';
+  char nz_sign_char = '-';
+  HighsInt delta_nz = num_nz_from - num_nz_to;
+  if (num_nz_from < num_nz_to) {
+    delta_nz = -delta_nz;
+    nz_sign_char = '+';
   }
   highsLogUser(
       log_options, HighsLogType::kInfo,
-      "Presolve : Reductions: rows %" HIGHSINT_FORMAT "(-%" HIGHSINT_FORMAT
+      "Presolve reductions: rows %" HIGHSINT_FORMAT "(-%" HIGHSINT_FORMAT
       "); columns %" HIGHSINT_FORMAT "(-%" HIGHSINT_FORMAT
       "); "
-      "elements %" HIGHSINT_FORMAT "(%c%" HIGHSINT_FORMAT ")\n",
+      "nonzeros %" HIGHSINT_FORMAT "(%c%" HIGHSINT_FORMAT ")\n",
       num_row_to, (num_row_from - num_row_to), num_col_to,
-      (num_col_from - num_col_to), num_els_to, elemsignchar, elemdelta);
+      (num_col_from - num_col_to), num_nz_to, nz_sign_char, delta_nz);
 }
 
 void reportPresolveReductions(const HighsLogOptions& log_options,
                               const HighsLp& lp, const bool presolve_to_empty) {
   HighsInt num_col_from = lp.num_col_;
   HighsInt num_row_from = lp.num_row_;
-  HighsInt num_els_from = lp.a_matrix_.start_[num_col_from];
+  HighsInt num_nz_from = lp.a_matrix_.start_[num_col_from];
   HighsInt num_col_to;
   HighsInt num_row_to;
-  HighsInt num_els_to;
+  HighsInt num_nz_to;
   std::string message;
   if (presolve_to_empty) {
     num_col_to = 0;
     num_row_to = 0;
-    num_els_to = 0;
+    num_nz_to = 0;
     message = "- Reduced to empty";
   } else {
     num_col_to = num_col_from;
     num_row_to = num_row_from;
-    num_els_to = num_els_from;
+    num_nz_to = num_nz_from;
     message = "- Not reduced";
   }
   highsLogUser(log_options, HighsLogType::kInfo,
-               "Presolve : Reductions: rows %" HIGHSINT_FORMAT
+               "Presolve reductions: rows %" HIGHSINT_FORMAT
                "(-%" HIGHSINT_FORMAT "); columns %" HIGHSINT_FORMAT
                "(-%" HIGHSINT_FORMAT
                "); "
-               "elements %" HIGHSINT_FORMAT "(-%" HIGHSINT_FORMAT ") %s\n",
+               "nonzeros %" HIGHSINT_FORMAT "(-%" HIGHSINT_FORMAT ") %s\n",
                num_row_to, (num_row_from - num_row_to), num_col_to,
-               (num_col_from - num_col_to), num_els_to,
-               (num_els_from - num_els_to), message.c_str());
+               (num_col_from - num_col_to), num_nz_to,
+               (num_nz_from - num_nz_to), message.c_str());
 }
 
 bool isLessInfeasibleDSECandidate(const HighsLogOptions& log_options,

highs/mip/HighsMipSolver.cpp

@@ -93,9 +93,10 @@ void HighsMipSolver::run() {
   std::swap(mipdata_->debugSolution.debugSolActive, debugSolActive);
 #endif
   analysis_.mipTimerStart(kMipClockRunPresolve);
-  mipdata_->runPresolve(options_mip_->presolve_reduction_limit);
+  mipdata_->runMipPresolve(options_mip_->presolve_reduction_limit);
   analysis_.mipTimerStop(kMipClockRunPresolve);
   analysis_.mipTimerStop(kMipClockPresolve);
+  
   if (analysis_.analyse_mip_time && !submip)
     highsLogUser(options_mip_->log_options, HighsLogType::kInfo,
                  "MIP-Timing: %11.2g - completed presolve\n", timer_.read());
@@ -865,10 +866,10 @@ void HighsMipSolver::cleanupSolve() {
 }
 
 // Only called in Highs::runPresolve
-void HighsMipSolver::runPresolve(const HighsInt presolve_reduction_limit) {
+void HighsMipSolver::runMipPresolve(const HighsInt presolve_reduction_limit) {
   mipdata_ = decltype(mipdata_)(new HighsMipSolverData(*this));
   mipdata_->init();
-  mipdata_->runPresolve(presolve_reduction_limit);
+  mipdata_->runMipPresolve(presolve_reduction_limit);
 }
 
 const HighsLp& HighsMipSolver::getPresolvedModel() const {

highs/mip/HighsMipSolver.h

@@ -97,7 +97,7 @@ class HighsMipSolver {
   mutable HighsTimer timer_;
   void cleanupSolve();
 
-  void runPresolve(const HighsInt presolve_reduction_limit);
+  void runMipPresolve(const HighsInt presolve_reduction_limit);
   const HighsLp& getPresolvedModel() const;
   HighsPresolveStatus getPresolveStatus() const;
   presolve::HighsPostsolveStack getPostsolveStack() const;

highs/mip/HighsMipSolverData.cpp

@@ -9,7 +9,6 @@
 
 #include <random>
 
-// #include "lp_data/HighsLpUtils.h"
 #include "../extern/pdqsort/pdqsort.h"
 #include "lp_data/HighsModelUtils.h"
 #include "mip/HighsPseudocost.h"
@@ -693,7 +692,7 @@ void HighsMipSolverData::init() {
     dispfreq = 100;
 }
 
-void HighsMipSolverData::runPresolve(const HighsInt presolve_reduction_limit) {
+void HighsMipSolverData::runMipPresolve(const HighsInt presolve_reduction_limit) {
   mipsolver.timer_.start(mipsolver.timer_.presolve_clock);
   presolve::HPresolve presolve;
   if (!presolve.okSetInput(mipsolver, presolve_reduction_limit)) {
@@ -704,6 +703,30 @@ void HighsMipSolverData::runPresolve(const HighsInt presolve_reduction_limit) {
     presolve_status = presolve.getPresolveStatus();
   }
   mipsolver.timer_.stop(mipsolver.timer_.presolve_clock);
+  const HighsLogOptions& log_options = mipsolver.options_mip_->log_options;
+  const HighsLp& incumbent_lp = *mipsolver.model_;
+  switch (presolve_status) {
+    case HighsPresolveStatus::kNotPresolved: {
+      // Shouldn't happen
+      assert(presolve_status != HighsPresolveStatus::kNotPresolved);
+      break;
+    }
+    case HighsPresolveStatus::kNotReduced:
+      reportPresolveReductions(log_options, incumbent_lp, false);
+    case HighsPresolveStatus::kInfeasible:
+    case HighsPresolveStatus::kReduced:
+      reportPresolveReductions(log_options, incumbent_lp, *mipsolver.model_);
+    case HighsPresolveStatus::kReducedToEmpty:
+      reportPresolveReductions(log_options, incumbent_lp, true);
+    case HighsPresolveStatus::kUnboundedOrInfeasible: 
+    case HighsPresolveStatus::kTimeout: {
+      break;
+    }
+    default: {
+      // case HighsPresolveStatus::kOutOfMemory
+      assert(presolve_status == HighsPresolveStatus::kOutOfMemory);
+    }
+  } 
 }
 
 void HighsMipSolverData::runSetup() {
@@ -1282,7 +1305,7 @@ void HighsMipSolverData::performRestart() {
       restart_presolve_reduction_limit >= 0
           ? num_reductions + restart_presolve_reduction_limit
           : -1;
-  runPresolve(further_presolve_reduction_limit);
+  runMipPresolve(further_presolve_reduction_limit);
 
   if (mipsolver.modelstatus_ != HighsModelStatus::kNotset) {
     // transform the objective limit to the current model

highs/mip/HighsMipSolverData.h

@@ -251,7 +251,7 @@ struct HighsMipSolverData {
   void init();
   void basisTransfer();
   void checkObjIntegrality();
-  void runPresolve(const HighsInt presolve_reduction_limit);
+  void runMipPresolve(const HighsInt presolve_reduction_limit);
   void setupDomainPropagation();
   void saveReportMipSolution(const double new_upper_limit = -kHighsInf);
   void runSetup();