Formatted

Author: jajhall

check/TestMipSolver.cpp

@@ -1038,19 +1038,19 @@ TEST_CASE("issue-2432", "[highs_test_mip_solver]") {
 
 TEST_CASE("mip-race", "[highs_test_mip_solver]") {
   const bool ci_test = true;
-  const std::string test_build_model = "fiball";//"neos-3381206-awhea";  //
+  const std::string test_build_model = "fiball";  //"neos-3381206-awhea";  //
   const std::string model = ci_test ? "flugpl" : test_build_model;
   // "neos-3381206-awhea";
   const std::string model_file =
       ci_test ? std::string(HIGHS_DIR) + "/check/instances/" + model + ".mps"
               : "/srv/miplib2017/" + model + ".mps.gz";
   Highs h;
-  //  if (ci_test) h.setOptionValue("output_flag", dev_run);
+  if (ci_test) h.setOptionValue("output_flag", dev_run);
   const HighsInt mip_race_concurrency = ci_test ? 2 : 4;
   h.setOptionValue("mip_race_concurrency", mip_race_concurrency);
   h.setOptionValue("mip_race_read_solutions", true);
-  for (HighsInt k = 0; k < 1; k++) {
-    bool mip_race_single_presolve = k == 1 ? false : true;
+  for (HighsInt k = 0; k < 2; k++) {
+    bool mip_race_single_presolve = k == 0 ? false : true;
     h.setOptionValue("mip_race_single_presolve", mip_race_single_presolve);
     REQUIRE(h.readModel(model_file) == HighsStatus::kOk);
     REQUIRE(h.run() == HighsStatus::kOk);

highs/Highs.h

@@ -1503,8 +1503,9 @@ class Highs {
   HighsStatus callSolveLp(HighsLp& lp, const string message);
   HighsStatus callSolveQp();
   HighsStatus callSolveMip();
-  HighsStatus callRunPostsolve(const HighsSolution& solution,
-                               const HighsBasis& basis);
+  HighsStatus callRunPostsolve(
+      const HighsSolution& solution, const HighsBasis& basis,
+      const bool suppress_mip_model_status_warning = false);
 
   PresolveComponent presolve_;
   HighsPresolveStatus runPresolve(const bool force_lp_presolve,
@@ -1715,7 +1716,7 @@ class Highs {
   void saveHighsFiles();
   void getHighsFiles();
   HighsStatus mipRaceResults(bool use_mip_race_single_presolve,
-			     HighsMipSolverInfo& mip_solver_info,
+                             HighsMipSolverInfo& mip_solver_info,
                              const std::vector<HighsMipSolverInfo>& worker_info,
                              const std::vector<double>& mip_time,
                              double mip_race_time);

highs/lp_data/Highs.cpp

@@ -4043,10 +4043,8 @@ HighsStatus Highs::callSolveMip() {
   // converted into the use_lp instance, and this->presolve(); works
   // on the incumbent model
   const bool use_mip_race_single_presolve =
-    run_mip_race &&
-    options_.mip_race_single_presolve &&
-    options_.presolve != kHighsOffString &&
-    !has_semi_variables;
+      run_mip_race && options_.mip_race_single_presolve &&
+      options_.presolve != kHighsOffString && !has_semi_variables;
   // Take a copy of the presolve option in case it's switched off for
   // a single presolve MIP race
   const std::string presolve = this->options_.presolve;
@@ -4060,16 +4058,20 @@ HighsStatus Highs::callSolveMip() {
     // the call to presolve...
     assert(!this->called_return_from_optimize_model);
     this->called_return_from_optimize_model = true;
-    this->presolve();
+    HighsStatus call_status = this->presolve();
     // ... then set it back to false and restart the run clock
     this->called_return_from_optimize_model = false;
     this->timer_.start();
+    if (call_status != HighsStatus::kOk) return call_status;
     presolved_lp = this->getPresolvedLp();
     this->options_.presolve = kHighsOffString;
   }
   // Create the master MIP solver instance that will exist beyond any
   // MIP race
-  HighsLp& lp = has_semi_variables ? use_lp : (use_mip_race_single_presolve ? presolved_lp : model_.lp_);
+  HighsLp& lp =
+      has_semi_variables
+          ? use_lp
+          : (use_mip_race_single_presolve ? presolved_lp : model_.lp_);
   HighsMipSolver solver(callback_, options_, lp, solution_);
   HighsMipSolverInfo mip_solver_info;
   if (run_mip_race) {
@@ -4084,7 +4086,7 @@ HighsStatus Highs::callSolveMip() {
     worker_callback.clear();
     // Race the MIP solver!
     highsLogUser(options_.log_options, HighsLogType::kInfo,
-                 "Starting MIP race with %d instances: behaviour is "
+                 "\nStarting MIP race with %d instances: behaviour is "
                  "non-deterministic!\n",
                  int(mip_race_concurrency));
     // Define the HighsMipSolverInfo record for each worker
@@ -4133,9 +4135,9 @@ HighsStatus Highs::callSolveMip() {
           }
         });
     // Determine the winner and report on the solution
-    HighsStatus call_status = this->mipRaceResults(use_mip_race_single_presolve,
-						   mip_solver_info, worker_info,
-                                                   mip_time, mip_race_time);
+    HighsStatus call_status =
+        this->mipRaceResults(use_mip_race_single_presolve, mip_solver_info,
+                             worker_info, mip_time, mip_race_time);
     // Restore the presolve option - that will have been set to
     // kHighsOffString for a single presolve MIP race
     this->options_.presolve = presolve;
@@ -4238,9 +4240,10 @@ HighsStatus Highs::callSolveMip() {
   return return_status;
 }
 
-// Only called from Highs::postsolve
-HighsStatus Highs::callRunPostsolve(const HighsSolution& solution,
-                                    const HighsBasis& basis) {
+// Only called from Highs::postsolve and Highs::mipRaceResults
+HighsStatus Highs::callRunPostsolve(
+    const HighsSolution& solution, const HighsBasis& basis,
+    const bool suppress_mip_model_status_warning) {
   HighsStatus return_status = HighsStatus::kOk;
   HighsStatus call_status;
   const HighsLp& presolved_lp = presolve_.getReducedProblem();
@@ -4305,9 +4308,12 @@ HighsStatus Highs::callRunPostsolve(const HighsSolution& solution,
                        max_integrality_violation);
         }
       }
-      highsLogUser(
-          options_.log_options, HighsLogType::kWarning,
-          "Postsolve performed for MIP, but model status cannot be known\n");
+      // When calling postsolve after MIP race on presolved model,
+      // model status can be trusted so suppress the warning message
+      if (!suppress_mip_model_status_warning)
+        highsLogUser(
+            options_.log_options, HighsLogType::kWarning,
+            "Postsolve performed for MIP, but model status cannot be known\n");
     } else {
       highsLogUser(options_.log_options, HighsLogType::kError,
                    "Postsolve return status is %d\n", (int)postsolve_status);

highs/lp_data/HighsInterface.cpp

@@ -4261,11 +4261,10 @@ void HighsMipSolverInfo::clear() {
   this->primal_dual_integral = -kHighsInf;
 }
 
-HighsStatus Highs::mipRaceResults(bool use_mip_race_single_presolve,
-				  HighsMipSolverInfo& mip_solver_info,
-				  const std::vector<HighsMipSolverInfo>& worker_info,
-				  const std::vector<double>& mip_time,
-				  double mip_race_time) {
+HighsStatus Highs::mipRaceResults(
+    bool use_mip_race_single_presolve, HighsMipSolverInfo& mip_solver_info,
+    const std::vector<HighsMipSolverInfo>& worker_info,
+    const std::vector<double>& mip_time, double mip_race_time) {
   const HighsInt mip_race_concurrency = this->options_.mip_race_concurrency;
   HighsInt winning_instance = -1;
   HighsModelStatus winning_model_status = HighsModelStatus::kNotset;
@@ -4310,22 +4309,34 @@ HighsStatus Highs::mipRaceResults(bool use_mip_race_single_presolve,
     solution.col_value = mip_solver_info.solution;
     // Perform postsolve after the MIP race
     //
-    // NB Highs::postsolve() is normally called externally, so calls
-    // returnFromHighs(). This will stop the run clock, and check that
-    // called_return_from_optimize_model is true - when it isn't. So,
-    // add a hack to set called_return_from_optimize_model true before
-    // the call to postsolve...
-    assert(!this->called_return_from_optimize_model);
-    this->called_return_from_optimize_model = true;
-   
-    this->postsolve(solution);
-    // ... then set it back to false and restart the run clock
-    this->called_return_from_optimize_model = false;
-    this->timer_.start();
-    
+    // Set up an empty basis so that callRunPostsolve can be used
+    HighsBasis basis;
+    // Need to suppress the warning about the HighsModelStatus for
+    // MIPs that (in general) can't be set after postsolve
+    const bool suppress_mip_model_status_warning = true;
+    HighsStatus call_status = this->callRunPostsolve(
+        solution, basis, suppress_mip_model_status_warning);
+    // call_status will be HighsStatus::kWarning, since model_status_
+    // is typically HighsModelStatus::kUnknown due to the lack of
+    // optimality test for a MIP. However, since this postsolve was
+    // run for a solution that was optimal for the presolved problem
+    // (and that status is in mip_solver_info) the warning can be
+    // ignored.
+    if (call_status == HighsStatus::kError) return call_status;
     // Now update the MipSolverInfo with the postsolved solution
-    mip_solver_info.solution = this->getSolution().col_value;
+    mip_solver_info.solution = this->solution_.col_value;
   }
+  const HighsInt mip_solver_info_solution_size =
+      mip_solver_info.solution.size();
+  if (0 < mip_solver_info_solution_size &&
+      mip_solver_info_solution_size < this->model_.lp_.num_col_) {
+    printf(
+        "Highs::mipRaceResults MipSolverInfo solution size = %d < %d = "
+        "num_col\n",
+        int(mip_solver_info_solution_size), int(this->model_.lp_.num_col_));
+    assert(11 == 33);
+  }
+
   mip_race_time += this->timer_.read();
 
   std::array<char, 128> gapString = getGapString(

highs/lp_data/HighsOptions.h

@@ -580,7 +580,7 @@ struct HighsOptionsStruct {
         mip_allow_restart(false),
         mip_race_concurrency(0),
         mip_race_read_solutions(false),
-	mip_race_single_presolve(false),
+        mip_race_single_presolve(false),
         mip_max_nodes(0),
         mip_max_stall_nodes(0),
         mip_max_start_nodes(0),

highs/mip/HighsMipSolverData.cpp

@@ -8,6 +8,7 @@
 #include "mip/HighsMipSolverData.h"
 
 #include <random>
+#include <sstream>
 
 // #include "lp_data/HighsLpUtils.h"
 #include "../extern/pdqsort/pdqsort.h"
@@ -1400,19 +1401,24 @@ bool HighsMipSolverData::addIncumbent(const std::vector<double>& sol,
       get_transformed_solution ? transformNewIntegerFeasibleSolution(
                                      sol, possibly_store_as_new_incumbent)
                                : 0;
-  const bool highs_solution_report = true;
-  if (solution_source == kSolutionSourceHighsSolution
-      && highs_solution_report
+  const bool highs_solution_report = false;
+  if (solution_source == kSolutionSourceHighsSolution && highs_solution_report
       //&& possibly_store_as_new_incumbent
-      ) {
+  ) {
+    std::stringstream ss;
+    ss.str(std::string());
+    ss << highsFormatToString(
+        "HighsMipSolverData::addIncumbent HiGHS solution Obj "
+        "= %15.8g; UB = %15.8g; Obj-UB = %11.4g; PossAdd = %s",
+        solobj, upper_bound, solobj - upper_bound,
+        possibly_store_as_new_incumbent ? "T" : "F");
+    if (possibly_store_as_new_incumbent)
+      ss << highsFormatToString(
+          "; TransObj = %15.8g; TransObj-UB = %11.4g; TransSolobj < UB %s",
+          transformed_solobj, transformed_solobj - upper_bound,
+          transformed_solobj < upper_bound ? "T" : "F");
     highsLogUser(mipsolver.options_mip_->log_options, HighsLogType::kInfo,
-		 "HighsMipSolverData::addIncumbent HiGHS solution Obj "
-		 "= %15.8g; UB = %15.8g; Obj-UB = %11.4g; PossAdd = %s; TransObj = %15.8g; TransObj-UB = %11.4g; TransSolobj < UB %s \n",
-		 solobj, upper_bound,
-		 solobj-upper_bound,
-		 possibly_store_as_new_incumbent ? "T" : "F", transformed_solobj,
-		 transformed_solobj - upper_bound,
-		 transformed_solobj < upper_bound ? "T" : "F");
+                 "%s\n", ss.str().c_str());
     fflush(stdout);
   }
   if (possibly_store_as_new_incumbent) {
@@ -2731,17 +2737,19 @@ void HighsMipSolverData::queryExternalSolution(
     if (!checkSolution(reduced_instance_solution)) {
       const bool feasibility_warning = true;
       if (feasibility_warning) {
-	highsLogUser(mipsolver.options_mip_->log_options, HighsLogType::kWarning,
-		     "Solution from instance %2d is not feasible for instance %2d\n",
-		     int(instance), int(mip_race.my_instance));
+        highsLogUser(
+            mipsolver.options_mip_->log_options, HighsLogType::kWarning,
+            "Solution from instance %2d is not feasible for instance %2d\n",
+            int(instance), int(mip_race.my_instance));
       }
       continue;
     }
     HighsCDouble reduced_instance_quad_objective_value = 0;
     for (HighsInt iCol = 0; iCol < mipsolver.model_->num_col_; iCol++)
       reduced_instance_quad_objective_value +=
-	mipsolver.colCost(iCol) * reduced_instance_solution[iCol];
-    double reduced_instance_objective_value = double(reduced_instance_quad_objective_value);
+          mipsolver.colCost(iCol) * reduced_instance_solution[iCol];
+    double reduced_instance_objective_value =
+        double(reduced_instance_quad_objective_value);
     addIncumbent(reduced_instance_solution, reduced_instance_objective_value,
                  kSolutionSourceHighsSolution);
   }