Now using single method to report final presolve reductions

Author: jajhall

check/TestPresolve.cpp

@@ -837,4 +837,5 @@ TEST_CASE("presolve-egout-ac", "[highs_test_presolve]") {
           lp_presolve_requires_basis_postsolve);
 
   h.resetGlobalScheduler(true);
-}
+}
+

check/TestSemiVariables.cpp

@@ -17,7 +17,7 @@ TEST_CASE("semi-variable-model", "[highs_test_semi_variables]") {
   const HighsInfo& info = highs.getInfo();
   HighsStatus return_status;
   double optimal_objective_function_value;
-  if (!dev_run) highs.setOptionValue("output_flag", false);
+  highs.setOptionValue("output_flag", dev_run);
   HighsModel model;
   HighsLp& lp = model.lp_;
   semiModel0(lp);

highs/lp_data/Highs.cpp

@@ -874,7 +874,7 @@ HighsStatus Highs::presolve() {
   }
 
   bool using_reduced_lp = false;
-  HighsLp& incumbent_lp = model_.lp_;
+  reportPresolveReductions(log_options, model_presolve_status_, model_.lp_, presolve_.getReducedProblem());
   switch (model_presolve_status_) {
     case HighsPresolveStatus::kNotPresolved: {
       // Shouldn't happen
@@ -883,12 +883,9 @@ 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) {
@@ -1405,7 +1402,9 @@ 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());
+    // Log the presolve reductions
+    reportPresolveReductions(log_options, model_presolve_status_,
+			     incumbent_lp, presolve_.getReducedProblem());
     switch (model_presolve_status_) {
       case HighsPresolveStatus::kNotPresolved: {
         ekk_instance_.lp_name_ = "Original LP";
@@ -1420,7 +1419,6 @@ HighsStatus Highs::optimizeModel() {
       case HighsPresolveStatus::kNotReduced: {
         ekk_instance_.lp_name_ = "Unreduced LP";
         // Log the presolve reductions
-        reportPresolveReductions(log_options, incumbent_lp, false);
         solveLp(incumbent_lp, "Problem not reduced by presolve: solving the LP",
                 this_solve_original_lp_time);
         return_status = interpretCallStatus(options_.log_options, call_status,
@@ -1460,8 +1458,6 @@ HighsStatus Highs::optimizeModel() {
                                 return_status,
                                 "cleanBounds") == HighsStatus::kError)
           return HighsStatus::kError;
-        // Log the presolve reductions
-        reportPresolveReductions(log_options, incumbent_lp, reduced_lp);
         // Solving the presolved LP with strictly reduced dimensions
         // so ensure that the Ekk instance is cleared
         ekk_instance_.clear();
@@ -1501,7 +1497,6 @@ HighsStatus Highs::optimizeModel() {
         break;
       }
       case HighsPresolveStatus::kReducedToEmpty: {
-        reportPresolveReductions(log_options, incumbent_lp, true);
         // Create a trivial optimal solution for postsolve to use
         solution_.clear();
         basis_.clear();

highs/lp_data/HighsLpUtils.cpp

@@ -2959,21 +2959,52 @@ bool isMatrixDataNull(const HighsLogOptions& log_options,
 }
 
 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_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_nz_to;
-  if (num_col_to) {
-    num_nz_to = presolve_lp.a_matrix_.start_[num_col_to];
-  } else {
-    num_nz_to = 0;
+			      HighsPresolveStatus presolve_status,
+                              const HighsLp& lp,
+			      const HighsLp& presolved_lp) {
+  const HighsInt num_col_from = lp.num_col_;
+  const HighsInt num_row_from = lp.num_row_;
+  const HighsInt num_nz_from = lp.a_matrix_.numNz();
+  HighsInt num_col_to = 0;
+  HighsInt num_row_to = 0;
+  HighsInt num_nz_to = 0;
+  std::string message = "";
+  
+  switch (presolve_status) {
+    case HighsPresolveStatus::kNotPresolved: 
+    case HighsPresolveStatus::kInfeasible:
+    case HighsPresolveStatus::kUnboundedOrInfeasible: return;
+    case HighsPresolveStatus::kNotReduced: {
+      num_col_to = num_col_from;
+      num_row_to = num_row_from;
+      num_nz_to = num_nz_from;
+      message = "- Not reduced";
+      break;
+    }
+    case HighsPresolveStatus::kReduced:
+    case HighsPresolveStatus::kTimeout: {
+      num_col_to = presolved_lp.num_col_;
+      num_row_to = presolved_lp.num_row_;
+      num_nz_to = presolved_lp.a_matrix_.numNz();
+      message = presolve_status == HighsPresolveStatus::kTimeout ? "- Timeout" : "";
+      break;
+    }
+    case HighsPresolveStatus::kReducedToEmpty: {
+      num_col_to = 0;
+      num_row_to = 0;
+      num_nz_to = 0;
+      message = "- Reduced to empty";
+      break;
+    }
+    default: {
+      // case HighsPresolveStatus::kOutOfMemory
+      assert(presolve_status == HighsPresolveStatus::kOutOfMemory);
+      return;
+    }
   }
   char nz_sign_char = '-';
   HighsInt delta_nz = num_nz_from - num_nz_to;
-  if (num_nz_from < num_nz_to) {
+  if (num_nz_to > num_nz_from) {
     delta_nz = -delta_nz;
     nz_sign_char = '+';
   }
@@ -2982,40 +3013,9 @@ void reportPresolveReductions(const HighsLogOptions& log_options,
       "Presolve reductions: rows %" HIGHSINT_FORMAT "(-%" HIGHSINT_FORMAT
       "); columns %" HIGHSINT_FORMAT "(-%" HIGHSINT_FORMAT
       "); "
-      "nonzeros %" HIGHSINT_FORMAT "(%c%" HIGHSINT_FORMAT ")\n",
+      "nonzeros %" HIGHSINT_FORMAT "(%c%" HIGHSINT_FORMAT ") %s\n",
       num_row_to, (num_row_from - num_row_to), num_col_to,
-      (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_nz_from = lp.a_matrix_.start_[num_col_from];
-  HighsInt num_col_to;
-  HighsInt num_row_to;
-  HighsInt num_nz_to;
-  std::string message;
-  if (presolve_to_empty) {
-    num_col_to = 0;
-    num_row_to = 0;
-    num_nz_to = 0;
-    message = "- Reduced to empty";
-  } else {
-    num_col_to = num_col_from;
-    num_row_to = num_row_from;
-    num_nz_to = num_nz_from;
-    message = "- Not reduced";
-  }
-  highsLogUser(log_options, HighsLogType::kInfo,
-               "Presolve reductions: rows %" HIGHSINT_FORMAT
-               "(-%" HIGHSINT_FORMAT "); columns %" HIGHSINT_FORMAT
-               "(-%" HIGHSINT_FORMAT
-               "); "
-               "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_nz_to,
-               (num_nz_from - num_nz_to), message.c_str());
+      (num_col_from - num_col_to), num_nz_to, nz_sign_char, delta_nz, message.c_str());
 }
 
 bool isLessInfeasibleDSECandidate(const HighsLogOptions& log_options,
@@ -3212,6 +3212,10 @@ HighsLp withoutSemiVariables(const HighsLp& lp_, HighsSolution& solution,
   lp.num_col_ += num_semi_variables;
   lp.num_row_ += 2 * num_semi_variables;
   assert((HighsInt)index.size() == new_num_nz);
+  // Ensure that the matrix dimensions are consistent with the LP
+  // dimensions
+  lp.a_matrix_.num_col_ = lp.num_col_;
+  lp.a_matrix_.num_row_ = lp.num_row_;
   // Clear any modifications inherited from lp_
   lp.mods_.clear();
   return lp;

highs/lp_data/HighsLpUtils.h

@@ -260,10 +260,9 @@ bool isMatrixDataNull(const HighsLogOptions& log_options,
                       const double* usr_matrix_value);
 
 void reportPresolveReductions(const HighsLogOptions& log_options,
-                              const HighsLp& lp, const HighsLp& presolve_lp);
-
-void reportPresolveReductions(const HighsLogOptions& log_options,
-                              const HighsLp& lp, const bool presolve_to_empty);
+			      HighsPresolveStatus presolve_status,
+                              const HighsLp& lp,
+			      const HighsLp& presolved_lp);
 
 bool isLessInfeasibleDSECandidate(const HighsLogOptions& log_options,
                                   const HighsLp& lp);

highs/mip/HighsMipSolverData.cpp

@@ -703,30 +703,11 @@ void HighsMipSolverData::runMipPresolve(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);
-    }
-  } 
+
+  reportPresolveReductions(mipsolver.options_mip_->log_options,
+			   presolve_status,
+			   *mipsolver.orig_model_,
+			   *mipsolver.model_);
 }
 
 void HighsMipSolverData::runSetup() {

highs/presolve/HPresolve.cpp

@@ -4879,20 +4879,19 @@ HighsModelStatus HPresolve::run(HighsPostsolveStack& postsolve_stack) {
       mipsolver->mipdata_->lower_bound = 0;
     } else {
       // An LP with no columns must have no rows, unless the reduction
-      // limit has been reached
-      assert(model->num_row_ == 0 ||
-             postsolve_stack.numReductions() >= reductionLimit);
-      if (model->num_row_ != 0) {
+      // limit has been reached. As exposed when studying 2326
+      const bool num_row_ok = model->num_row_ == 0 ||
+	postsolve_stack.numReductions() >= reductionLimit;
+      assert(num_row_ok);
+      if (!num_row_ok) {
         presolve_status_ = HighsPresolveStatus::kNotPresolved;
         return HighsModelStatus::kNotset;
       }
     }
     presolve_status_ = HighsPresolveStatus::kReducedToEmpty;
-    // Make sure that zero row activity from the column-less model is
+    // Make sure that zero row activity from the columnless model is
     // consistent with the bounds
-    return model->num_row_ == 0 || zeroRowActivityFeasible()
-               ? HighsModelStatus::kOptimal
-               : HighsModelStatus::kInfeasible;
+    return zeroRowActivityFeasible() ? HighsModelStatus::kOptimal : HighsModelStatus::kInfeasible;
   } else if (postsolve_stack.numReductions() > 0) {
     // Reductions performed
     presolve_status_ = HighsPresolveStatus::kReduced;