Verified that changeColsBounds clears solution, and suppressing presolve reduction statement when presolve is off

Author: jajhall

check/TestMipSolver.cpp

@@ -1055,17 +1055,57 @@ TEST_CASE("get-fixed-lp", "[highs_test_mip_solver]") {
   double mip_optimal_objective = h.getInfo().objective_function_value;
   HighsSolution solution = h.getSolution();
 
+  // Transform the incumbent MIP into the fixed LP
+  HighsLp mip = h.getLp();
+  std::vector<HighsInt> col_set;
+  std::vector<double> fixed_value;
+  std::vector<HighsVarType> integrality = mip.integrality_;
+  for (HighsInt iCol = 0; iCol < mip.num_col_; iCol++) {
+    if (mip.integrality_[iCol] == HighsVarType::kInteger) {
+      col_set.push_back(iCol);
+      fixed_value.push_back(solution.col_value[iCol]);
+      integrality[iCol] = HighsVarType::kContinuous;
+    }
+  }
+  h.clearIntegrality();
+  HighsInt num_set_entries = col_set.size();
+  h.changeColsBounds(num_set_entries, col_set.data(), fixed_value.data(),
+                     fixed_value.data());
+  h.setOptionValue("presolve", kHighsOffString);
+  REQUIRE(h.run() == HighsStatus::kOk);
+
+  REQUIRE(h.getInfo().objective_function_value == mip_optimal_objective);
+  // In calling changeColsBounds, the incumbent solution is cleared,
+  // so there is no information from which to construct an advanced
+  // basis. Hence simplex starts from a logical basis and requires a
+  // positive number of iterations (#2556)
+  REQUIRE(h.getInfo().simplex_iteration_count > 0);
+
+  // Now, passing the MIP solution, there is information from which to
+  // construct an advanced basis. In the case of flugpl, this is
+  // optimal, so no simplex iterations are required
+  h.clearSolver();
+  h.setSolution(solution);
+  REQUIRE(h.run() == HighsStatus::kOk);
+
+  REQUIRE(h.getInfo().objective_function_value == mip_optimal_objective);
+  REQUIRE(h.getInfo().simplex_iteration_count == 0);
+
+  // Now re-load the MIP, re-solve, and get the fixed LP
+  REQUIRE(h.passModel(mip) == HighsStatus::kOk);
+  REQUIRE(h.run() == HighsStatus::kOk);
+  REQUIRE(h.getInfo().objective_function_value == mip_optimal_objective);
+
   REQUIRE(h.getFixedLp(fixed_lp) == HighsStatus::kOk);
 
   REQUIRE(h.passModel(fixed_lp) == HighsStatus::kOk);
   REQUIRE(h.run() == HighsStatus::kOk);
 
   REQUIRE(h.getInfo().objective_function_value == mip_optimal_objective);
 
-  // Now run from saved solution without presolve
+  // Now run from saved solution (without presolve)
   h.clearSolver();
   h.setSolution(solution);
-  h.setOptionValue("presolve", kHighsOffString);
   REQUIRE(h.run() == HighsStatus::kOk);
 
   REQUIRE(h.getInfo().objective_function_value == mip_optimal_objective);
@@ -1074,7 +1114,7 @@ TEST_CASE("get-fixed-lp", "[highs_test_mip_solver]") {
   REQUIRE(h.readModel(model_file) == HighsStatus::kOk);
   // Perturb one of the integer variables for code coverage of
   // warning: makes fixed LP of flugpl infeasible
-  std::vector<HighsVarType> integrality = h.getLp().integrality_;
+  integrality = h.getLp().integrality_;
   for (HighsInt iCol = 0; iCol < fixed_lp.num_col_; iCol++) {
     if (integrality[iCol] != HighsVarType::kContinuous) {
       solution.col_value[iCol] -= 0.01;

highs/lp_data/Highs.cpp

@@ -1350,18 +1350,36 @@ HighsStatus Highs::optimizeModel() {
   }
   if (basis_.valid) assert(basis_.useful);
 
-  if ((has_basis || options_.presolve == kHighsOffString || unconstrained_lp) &&
+  const bool without_presolve = options_.presolve == kHighsOffString;
+  if ((unconstrained_lp || has_basis || without_presolve) &&
       solver_will_use_basis) {
     // There is a valid basis for the problem, presolve is off, or LP
     // has no constraint matrix, and the solver will use the basis
-    ekk_instance_.lp_name_ =
-        "LP without presolve, or with basis, or unconstrained";
+    // (otherwise it's better to use presolve, if it's not switched
+    // off)
+    //
+    // Determine a coherent message about how the LP is being solved
+    std::stringstream lp_solve_ss;
+    if (unconstrained_lp) {
+      lp_solve_ss << "Solving unconstrained LP";
+    } else if (has_basis) {
+      if (without_presolve) {
+        lp_solve_ss << "Solving LP with useful basis";
+      } else {
+        lp_solve_ss << "Solving LP with useful basis so presolve not used";
+      }
+    } else {
+      // One of unconstrained_lp, has_basis and without_presolve must
+      // be true, and the first two anren't
+      assert(without_presolve);
+      lp_solve_ss << "Solving LP without presolve or useful basis";
+    }
+    std::string lp_solve = lp_solve_ss.str();
+    ekk_instance_.lp_name_ = lp_solve;
     // If there is a valid HiGHS basis, refine any status values that
     // are simply HighsBasisStatus::kNonbasic
     if (basis_.useful) refineBasis(incumbent_lp, solution_, basis_);
-    solveLp(incumbent_lp,
-            "Solving LP without presolve, or with basis, or unconstrained",
-            this_solve_original_lp_time);
+    solveLp(incumbent_lp, lp_solve, this_solve_original_lp_time);
     return_status = interpretCallStatus(options_.log_options, call_status,
                                         return_status, "callSolveLp");
     if (return_status == HighsStatus::kError)

highs/mip/HighsMipSolverData.cpp

@@ -709,7 +709,8 @@ void HighsMipSolverData::runMipPresolve(
   }
   mipsolver.timer_.stop(mipsolver.timer_.presolve_clock);
 
-  if (numRestarts == 0)
+  // Report the final presolve reductions unless this is a restart
+  if (mipsolver.options_mip_->presolve != kHighsOffString && numRestarts == 0)
     reportPresolveReductions(mipsolver.options_mip_->log_options,
                              presolve_status, *mipsolver.orig_model_,
                              *mipsolver.model_);