Clean up Knapsack MIPs logging

Author: jajhall

check/TestMipSolver.cpp

@@ -1003,30 +1003,65 @@ TEST_CASE("issue-2432", "[highs_test_mip_solver]") {
 }
 
 TEST_CASE("knapsack", "[highs_test_mip_solver]") {
-  std::vector<double> cost = {10, 20, 25, 40, 60, 70};
-  std::vector<double> weight = {1, 2, 3, 6, 7, 4};
-  HighsInt num_item = cost.size();
+  const std::vector<double> value = {10, 20, 25, 40, 60, 70};
+  const std::vector<double> weight = {1, 2, 3, 6, 7, 4};
+  HighsInt num_item = value.size();
   REQUIRE(num_item == weight.size());
-
+  const double capacity = 7;
+  const double offset = -100;
+  std::vector<double> neg_value(num_item);
+  std::vector<double> neg_weight(num_item);
+  for (HighsInt iItem = 0; iItem < num_item; iItem++) {
+    neg_value[iItem] = -value[iItem];
+    neg_weight[iItem] = -weight[iItem];
+  }
   HighsLp lp;
   lp.sense_ = ObjSense::kMaximize;
+  lp.offset_ = offset;
   lp.num_col_ = 6;
   lp.num_row_ = 1;
-  lp.col_cost_ = cost;
+  lp.col_cost_ = value;
   lp.col_lower_.assign(lp.num_col_, 0);
   lp.col_upper_.assign(lp.num_col_, 1);
   lp.integrality_.assign(lp.num_col_, HighsVarType::kInteger);
   lp.row_lower_ = {-kHighsInf};   
-  lp.row_upper_ = {7};
+  lp.row_upper_ = {capacity};
   lp.a_matrix_.format_ = MatrixFormat::kRowwise;
   lp.a_matrix_.start_ = {0, 6};
   lp.a_matrix_.index_ = {0, 1, 2, 3, 4, 5};
   lp.a_matrix_.value_ = weight;
   Highs h;
+  // highs.setOptionValue("output_flag", dev_run);
   h.setOptionValue("presolve", kHighsOffString);
-  h.setOptionValue("threads", 1);
-  REQUIRE(h.passModel(lp) == HighsStatus::kOk);
-  REQUIRE(h.run() == HighsStatus::kOk);   
+  //  h.setOptionValue("threads", 1);
+  double required_objective_value = 0;
+  for (int sense = 0; sense < 2; sense++) {
+    for (int sign = 0; sign < 2; sign++) {
+      if (sense == 0) {
+	lp.sense_ = ObjSense::kMaximize;
+	lp.col_cost_ = value;
+	required_objective_value = 0;
+      } else {
+	lp.sense_ = ObjSense::kMinimize;
+	lp.col_cost_ = neg_value;
+	required_objective_value = 2.0e0 * offset;
+      }
+      if (sign == 0) {
+	lp.a_matrix_.value_ = weight;
+	lp.row_lower_ = {-kHighsInf};
+	lp.row_upper_ = {capacity};
+      } else {
+	lp.a_matrix_.value_ = neg_weight;
+	lp.row_lower_ = {-capacity};
+	lp.row_upper_ = {kHighsInf};
+      }
+      REQUIRE(h.passModel(lp) == HighsStatus::kOk);
+      REQUIRE(h.run() == HighsStatus::kOk);
+      REQUIRE(h.getModelStatus() == HighsModelStatus::kOptimal);
+      REQUIRE(h.getInfo().objective_function_value == required_objective_value);
+    }
+  }  
+  h.resetGlobalScheduler(true);
 }
 
 

highs/mip/HighsMipSolver.cpp

@@ -8,7 +8,7 @@
 #include "mip/HighsMipSolver.h"
 
 #include "lp_data/HighsLpUtils.h"
-#include "lp_data/HighsModelUtils.h"
+#include "lp_data/HighsModelUtils.h"  // For utilModelStatusToString
 #include "mip/HighsCliqueTable.h"
 #include "mip/HighsCutPool.h"
 #include "mip/HighsDomain.h"
@@ -98,7 +98,8 @@ void HighsMipSolver::run() {
     // Solve as a knapsack
     HighsStatus call_status = mipdata_->heuristics.solveMipKnapsack();
     assert(call_status == HighsStatus::kOk);
-    cleanupSolve();
+    const bool mip_logging = false;
+    cleanupSolve(mip_logging);
     return;
   }
 
@@ -704,9 +705,9 @@ void HighsMipSolver::run() {
   cleanupSolve();
 }
 
-void HighsMipSolver::cleanupSolve() {
-  // Force a final logging line
-  mipdata_->printDisplayLine(kSolutionSourceCleanup);
+void HighsMipSolver::cleanupSolve(const bool mip_logging) {
+  // Generally force a final MIP logging line
+  if (mip_logging) mipdata_->printDisplayLine(kSolutionSourceCleanup);
   // Stop the solve clock - which won't be running if presolve
   // determines the model status
   if (analysis_.mipTimerRunning(kMipClockSolve))
@@ -865,7 +866,7 @@ void HighsMipSolver::cleanupSolve() {
                (long long unsigned)mipdata_->heuristic_lp_iterations);
   const HighsKnapsackData& knapsack_data = this->mipdata_->knapsack_data_;
   highsLogUser(options_mip_->log_options, HighsLogType::kInfo,
-               "  Knapsack sub-MIPs %d\n", knapsack_data.num_problem);
+               "  Knapsack MIPs     %d\n", knapsack_data.num_problem);
   if (knapsack_data.num_problem > 0)
     highsLogUser(options_mip_->log_options, HighsLogType::kInfo,
                "     Mean var count %d\n     Mean capacity  %d\n",

highs/mip/HighsMipSolver.h

@@ -95,7 +95,7 @@ class HighsMipSolver {
   }
 
   mutable HighsTimer timer_;
-  void cleanupSolve();
+  void cleanupSolve(const bool mip_logging = true);
 
   void runPresolve(const HighsInt presolve_reduction_limit);
   const HighsLp& getPresolvedModel() const;

highs/mip/HighsPrimalHeuristics.cpp

@@ -14,6 +14,7 @@
 #include "io/HighsIO.h"
 #include "lp_data/HConst.h"
 #include "lp_data/HighsLpUtils.h"
+#include "lp_data/HighsModelUtils.h" // For utilModelStatusToString
 #include "mip/HighsCutGeneration.h"
 #include "mip/HighsDomainChange.h"
 #include "mip/HighsLpRelaxation.h"
@@ -1717,6 +1718,11 @@ HighsModelStatus solveKnapsack(const HighsLogOptions& log_options,
 
 HighsStatus HighsPrimalHeuristics::solveMipKnapsackReturn(const HighsStatus& return_status) {
   const HighsLp& lp = *(mipsolver.model_);
+  std::stringstream ss;
+  if (!mipsolver.submip) {
+    ss.str(std::string());
+    ss << "MIP is a knapsack problem: ";
+  }
   if (mipsolver.modelstatus_ == HighsModelStatus::kOptimal) {
     // mipsolver.solution_objective_ is the objective value for the
     // original problem - using the offset and ignoring the
@@ -1731,9 +1737,17 @@ HighsStatus HighsPrimalHeuristics::solveMipKnapsackReturn(const HighsStatus& ret
     mipsolver.mipdata_->lower_bound = mipsolver_objective;
     mipsolver.mipdata_->upper_bound = mipsolver_objective;
     mipsolver.gap_ = 0;
+    if (!mipsolver.submip)
+      ss << highsFormatToString("optimal objective by dynamic programming is %g",
+				mipsolver.solution_objective_);
   } else {
+    if (!mipsolver.submip)
+      ss << highsFormatToString("model status is %s",
+				utilModelStatusToString(mipsolver.modelstatus_).c_str());
     mipsolver.solution_.clear();
   }
+  if (!mipsolver.submip) highsLogUser(mipsolver.options_mip_->log_options, HighsLogType::kInfo,
+				      "\n%s\n", ss.str().c_str());
   return return_status;
 }