Now tracking problems suitable for Ines

Author: jajhall

check/TestMipSolver.cpp

@@ -1109,3 +1109,32 @@ TEST_CASE("knapsack", "[highs_test_mip_solver]") {
 
   h.resetGlobalScheduler(true);
 }
+
+TEST_CASE("ines", "[highs_test_mip_solver]") {
+  const std::vector<double> value = {10, 20, 25, 40, 60, 70};
+  const std::vector<double> weight = {1, 2, 3, 6, 7, 4};
+  HighsLp lp;
+  lp.sense_ = ObjSense::kMaximize;
+  lp.num_col_ = 6;
+  lp.num_row_ = 2;
+  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, -4};
+  lp.row_upper_ = {6, kHighsInf};
+  lp.a_matrix_.format_ = MatrixFormat::kRowwise;
+  lp.a_matrix_.start_ = {0, 6, 12};
+  lp.a_matrix_.index_ = {0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5};
+  lp.a_matrix_.value_ = {1, -2, 3, -6, 7, 4, -6, 7, -4, -1, 2, -3};
+  double required_objective_value = 215;
+  Highs h;
+  //  h.setOptionValue("output_flag", dev_run);
+  h.setOptionValue("presolve", kHighsOffString);
+  REQUIRE(h.passModel(lp) == HighsStatus::kOk);
+  REQUIRE(h.run() == HighsStatus::kOk);
+  if (dev_run) h.writeSolution("", 1);
+  REQUIRE(h.getInfo().objective_function_value == required_objective_value);
+
+  h.resetGlobalScheduler(true);
+}

highs/mip/HighsMipSolver.cpp

@@ -152,6 +152,8 @@ void HighsMipSolver::run() {
     }
     analysis_.mipTimerStop(kMipClockKnapsack);
   }
+  // See whether the presolved problem is suitable for Ines
+  mipdata_->mipIsInes();
 
   analysis_.mipTimerStart(kMipClockSolve);
 
@@ -900,6 +902,27 @@ void HighsMipSolver::cleanupSolve(const bool mip_logging) {
         int((1.0 * knapsack_data.sum_capacity) / knapsack_data.num_problem));
   highsLogUser(options_mip_->log_options, HighsLogType::kInfo, "%s\n",
                ss.str().c_str());
+  const HighsInesData& ines_data = this->mipdata_->ines_data_;
+  ss.str(std::string());
+  ss << highsFormatToString("  Ines MIPs         %d",
+                            int(ines_data.num_problem));
+  if (ines_data.num_problem > 0)
+    ss << highsFormatToString(
+        " (mean columns %d; mean rows %d)",
+        int((1.0 * ines_data.sum_col) / ines_data.num_problem),
+        int((1.0 * ines_data.sum_row) / ines_data.num_problem));
+  highsLogUser(options_mip_->log_options, HighsLogType::kInfo, "%s\n",
+               ss.str().c_str());
+
+  if (knapsack_data.num_problem > 0 || ines_data.num_problem > 0)
+    highsLogUser(options_mip_->log_options, HighsLogType::kInfo,
+                 "grep-knapsack-ines,%s,%s,%d,%" PRId64 ",%" PRId64
+                 ",%d,%" PRId64 ",%" PRId64 "\n",
+                 model_->model_name_.c_str(), options_mip_->presolve.c_str(),
+                 knapsack_data.num_problem, knapsack_data.sum_variables,
+                 knapsack_data.sum_capacity, ines_data.num_problem,
+                 ines_data.sum_col, ines_data.sum_row);
+
   if (!timeless_log) analysis_.reportMipTimer();
 
   assert(modelstatus_ != HighsModelStatus::kNotset);

highs/mip/HighsMipSolverData.cpp

@@ -687,6 +687,7 @@ void HighsMipSolverData::init() {
   knapsack_data_.initialise();
   knapsack_capacity_ = 0;
   knapsack_integral_scale_ = 0;
+  ines_data_.initialise();
 
   if (mipsolver.options_mip_->mip_report_level == 0)
     dispfreq = 0;
@@ -2693,6 +2694,31 @@ bool HighsMipSolverData::mipIsKnapsack(const bool silent) {
   return true;
 }
 
+bool HighsMipSolverData::mipIsInes(const bool silent) {
+  // Silent is to prevent duplicate logging and data collection when
+  // using assert(mipIsInes(true));
+  const HighsLp& lp = *(mipsolver.model_);
+  // Has to have at least one constraint
+  if (lp.num_row_ < 1) return false;
+  // Has to be a binary integer programming problem
+  if (!lp.isBip()) return false;
+  // Origin must be feasible
+  const double ines_feas_tol = 0;
+  for (HighsInt iRow = 0; iRow < lp.num_row_; iRow++) {
+    if (lp.row_lower_[0] - ines_feas_tol > 0 ||
+        lp.row_upper_[0] + ines_feas_tol < 0)
+      return false;
+  }
+  if (!silent) {
+    highsLogUser(mipsolver.options_mip_->log_options, HighsLogType::kInfo,
+                 "MIP is an Ines problem\n");
+    this->ines_data_.num_problem++;
+    this->ines_data_.sum_col += lp.num_col_;
+    this->ines_data_.sum_row += lp.num_row_;
+  }
+  return true;
+}
+
 static double possInfRelDiff(const double v0, const double v1,
                              const double den) {
   double rel_diff;
@@ -2840,3 +2866,15 @@ void HighsKnapsackData::add(const HighsKnapsackData& knapsack_data) {
   this->sum_variables += knapsack_data.sum_variables;
   this->sum_capacity += knapsack_data.sum_capacity;
 }
+
+void HighsInesData::initialise() {
+  num_problem = 0;
+  sum_col = 0;
+  sum_row = 0;
+}
+
+void HighsInesData::add(const HighsInesData& ines_data) {
+  this->num_problem += ines_data.num_problem;
+  this->sum_col += ines_data.sum_col;
+  this->sum_row += ines_data.sum_row;
+}

highs/mip/HighsMipSolverData.h

@@ -38,6 +38,14 @@ struct HighsKnapsackData {
   void add(const HighsKnapsackData& knapsack_data);
 };
 
+struct HighsInesData {
+  HighsInt num_problem;
+  int64_t sum_col;
+  int64_t sum_row;
+  void initialise();
+  void add(const HighsInesData& ines_data);
+};
+
 struct HighsPrimaDualIntegral {
   double value;
   double prev_lb;
@@ -165,6 +173,8 @@ struct HighsMipSolverData {
   HighsInt knapsack_capacity_;
   HighsInt knapsack_integral_scale_;
 
+  HighsInesData ines_data_;
+
   HighsMipSolverData(HighsMipSolver& mipsolver)
       : mipsolver(mipsolver),
         cutpool(mipsolver.numCol(), mipsolver.options_mip_->mip_pool_age_limit,
@@ -314,6 +324,7 @@ struct HighsMipSolverData {
       const double mipsolver_objective_value,
       const userMipSolutionCallbackOrigin user_solution_callback_origin);
   bool mipIsKnapsack(const bool silent = false);
+  bool mipIsInes(const bool silent = false);
 };
 
 #endif