Now have MipProblemData as record of sub-mip dimensions and largest knapsack or Ines sub-MIP; tracking max_submip_level more clearly; and added writeLpToMps for dumping out Ines MIPs

jajhall · jajhall · commit 74b4e7ddbaf0 · 2025-08-03T23:33:56.000+01:00
diff --git a/highs/lp_data/HighsLpUtils.cpp b/highs/lp_data/HighsLpUtils.cpp
@@ -15,6 +15,7 @@
 
 #include "HConfig.h"
 #include "io/Filereader.h"
+#include "io/FilereaderMps.h"
 #include "io/HMPSIO.h"
 #include "io/HighsIO.h"
 #include "lp_data/HighsModelUtils.h"
@@ -3513,3 +3514,13 @@ void getSubVectorsTranspose(const HighsIndexCollection& index_collection,
     }
   }
 }
+
+HighsStatus writeLpToMps(const HighsOptions& options, const HighsLp& lp,
+                         const std::string& file_name_prefix) {
+  HighsModel model;
+  model.lp_ = lp;
+  HighsStatus call_status = normaliseNames(options.log_options, model.lp_);
+  if (call_status == HighsStatus::kError) return call_status;
+  const std::string file_name = file_name_prefix + ".mps";
+  return FilereaderMps().writeModelToFile(options, file_name, model);
+}
diff --git a/highs/lp_data/HighsLpUtils.h b/highs/lp_data/HighsLpUtils.h
@@ -305,4 +305,6 @@ void getSubVectorsTranspose(const HighsIndexCollection& index_collection,
                             HighsInt* sub_matrix_index,
                             double* sub_matrix_value);
 
+HighsStatus writeLpToMps(const HighsOptions& options, const HighsLp& lp,
+                         const std::string& file_name_prefix);
 #endif  // LP_DATA_HIGHSLPUTILS_H_
diff --git a/highs/mip/HighsMipSolver.cpp b/highs/mip/HighsMipSolver.cpp
@@ -30,20 +30,20 @@ using std::fabs;
 HighsMipSolver::HighsMipSolver(HighsCallback& callback,
                                const HighsOptions& options, const HighsLp& lp,
                                const HighsSolution& solution, bool submip,
-                               HighsInt submip_level)
+                               HighsInt global_submip_level)
     : callback_(&callback),
       options_mip_(&options),
       model_(&lp),
       orig_model_(&lp),
       solution_objective_(kHighsInf),
       submip(submip),
-      submip_level(submip_level),
+      global_submip_level(global_submip_level),
       rootbasis(nullptr),
       pscostinit(nullptr),
       clqtableinit(nullptr),
       implicinit(nullptr) {
-  assert(!submip || submip_level > 0);
-  this->max_submip_level = 0;
+  assert(!submip || global_submip_level > 0);
+  this->max_local_submip_level = 0;
   if (solution.value_valid) {
 #ifndef NDEBUG
     // MIP solver doesn't check row residuals, but they should be OK
@@ -894,9 +894,9 @@ void HighsMipSolver::cleanupSolve(const bool mip_logging) {
                (long long unsigned)mipdata_->sepa_lp_iterations,
                (long long unsigned)mipdata_->heuristic_lp_iterations);
 
-  const std::vector<HighsMipProblemData>& mip_problem_data =
-      this->mipdata_->mip_problem_data_;
-  HighsInt num_mip = static_cast<HighsInt>(mip_problem_data.size());
+  const std::vector<HighsMipProblemRecord>& record =
+      this->mipdata_->mip_problem_data_.record;
+  HighsInt num_mip = static_cast<HighsInt>(record.size());
   HighsInt num_knapsack_mip = 0;
   size_t sum_knapsack_num_col = 0;
   HighsInt num_ines_mip = 0;
@@ -907,59 +907,60 @@ void HighsMipSolver::cleanupSolve(const bool mip_logging) {
   HighsInt min_submip_num_col = kHighsIInf;
   HighsInt min_submip_num_row = kHighsIInf;
   const bool full_submip_logging = true;
+  // Must at least have a record for the MIP itself
+  assert(num_mip > 0);
   for (HighsInt iMip = 0; iMip < num_mip; iMip++) {
-    switch (mip_problem_data[iMip].type) {
+    switch (record[iMip].type) {
       case HighsMipProblemType::kKnapsack:
         num_knapsack_mip++;
-        sum_knapsack_num_col += mip_problem_data[iMip].num_binary;
+        sum_knapsack_num_col += record[iMip].num_binary;
         break;
       case HighsMipProblemType::kInes:
         num_ines_mip++;
-        sum_ines_num_col += mip_problem_data[iMip].num_binary;
-        sum_ines_num_row += mip_problem_data[iMip].num_row;
+        sum_ines_num_col += record[iMip].num_binary;
+        sum_ines_num_row += record[iMip].num_row;
         break;
       case HighsMipProblemType::kOther:
       default:
         break;
     }
-    HighsInt global_submip_level = mip_problem_data[iMip].submip_level;
-    max_global_submip_level = std::max(global_submip_level, max_global_submip_level);
-    HighsInt submip_num_col = mip_problem_data[iMip].num_continuous +
-                              mip_problem_data[iMip].num_binary +
-                              mip_problem_data[iMip].num_general_integer +
-                              mip_problem_data[iMip].num_implied_integer;
-    HighsInt submip_num_row = mip_problem_data[iMip].num_row;
+    HighsInt global_submip_level = record[iMip].global_submip_level;
+    max_global_submip_level =
+        std::max(global_submip_level, max_global_submip_level);
+    HighsInt submip_num_col =
+        record[iMip].num_continuous + record[iMip].num_binary +
+        record[iMip].num_general_integer + record[iMip].num_implied_integer;
+    HighsInt submip_num_row = record[iMip].num_row;
     HighsInt submip_sum_dim = submip_num_col + submip_num_row;
-    if (min_submip_sum_dim > submip_sum_dim) {
+    if (min_submip_sum_dim > submip_sum_dim && submip_sum_dim > 0) {
       min_submip_sum_dim = submip_sum_dim;
       min_submip_num_col = submip_num_col;
       min_submip_num_row = submip_num_row;
     }
-    if (full_submip_logging)
-      highsLogUser(options_mip_->log_options, HighsLogType::kInfo,
-                   "  MIP               %3d (level = %2d; %6d conts; %6d bin; "
-                   "%6d gen; %6d impl; cols / rows: %6d / %6d; type %s)\n",
-                   int(iMip), int(global_submip_level),
-                   int(mip_problem_data[iMip].num_continuous),
-                   int(mip_problem_data[iMip].num_binary),
-                   int(mip_problem_data[iMip].num_general_integer),
-                   int(mip_problem_data[iMip].num_implied_integer),
-                   int(submip_num_col), int(submip_num_row),
-                   mip_problem_data[iMip].type == HighsMipProblemType::kKnapsack
-                       ? "Knapsack"
-                   : mip_problem_data[iMip].type == HighsMipProblemType::kInes
-                       ? "Ines"
-                       : "Other");
+    if (full_submip_logging && record[iMip].type != HighsMipProblemType::kOther)
+      highsLogUser(
+          options_mip_->log_options, HighsLogType::kInfo,
+          "  MIP               %3d (level = %2d; %6d conts; %6d bin; "
+          "%6d gen; %6d impl; cols / rows: %6d / %6d; type %s)\n",
+          int(iMip), int(global_submip_level), int(record[iMip].num_continuous),
+          int(record[iMip].num_binary), int(record[iMip].num_general_integer),
+          int(record[iMip].num_implied_integer), int(submip_num_col),
+          int(submip_num_row),
+          record[iMip].type == HighsMipProblemType::kKnapsack ? "Knapsack"
+          : record[iMip].type == HighsMipProblemType::kInes   ? "Ines"
+                                                              : "Other");
   }
   highsLogUser(options_mip_->log_options, HighsLogType::kInfo,
                "  MIPs              %d (%d knapsack; %d Ines)\n", int(num_mip),
                int(num_knapsack_mip), int(num_ines_mip));
 
   std::stringstream ss;
   ss.str(std::string());
-  assert(submip_level + max_submip_level == max_global_submip_level);
-  ss << highsFormatToString("  Max sub-MIP level %d", int(submip_level + max_submip_level));
-  if (max_submip_level > 0)
+  assert(global_submip_level + max_local_submip_level ==
+         max_global_submip_level);
+  ss << highsFormatToString("  Max sub-MIP level %d",
+                            int(global_submip_level + max_local_submip_level));
+  if (max_local_submip_level > 0)
     ss << highsFormatToString(" (min cols/rows: %d/%d)\n",
                               int(min_submip_num_col), int(min_submip_num_row));
   highsLogUser(options_mip_->log_options, HighsLogType::kInfo, "%s\n",
@@ -974,9 +975,21 @@ void HighsMipSolver::cleanupSolve(const bool mip_logging) {
                  num_knapsack_mip, sum_knapsack_num_col, num_ines_mip,
                  sum_ines_num_col, sum_ines_num_row);
 
-  if (max_submip_level > 0) {
+  const bool write_ines_model = false;
+  if (write_ines_model) {
+    if (!submip && mipdata_->mip_problem_data_.ines_mip.num_col_ > 0) {
+      const std::string file_name_prefix = model_->model_name_ + "_ines";
+      highsLogUser(options_mip_->log_options, HighsLogType::kInfo,
+                   "Generating MPS file %s.mps for Ines MIP with %d columns "
+                   "and %d rows\n",
+                   file_name_prefix.c_str(),
+                   int(mipdata_->mip_problem_data_.ines_mip.num_col_),
+                   int(mipdata_->mip_problem_data_.ines_mip.num_row_));
+      HighsStatus call_status =
+          writeLpToMps(*options_mip_, mipdata_->mip_problem_data_.ines_mip,
+                       file_name_prefix);
+    }
   }
-
   if (!timeless_log) analysis_.reportMipTimer();
 
   assert(modelstatus_ != HighsModelStatus::kNotset);
diff --git a/highs/mip/HighsMipSolver.h b/highs/mip/HighsMipSolver.h
@@ -44,8 +44,8 @@ class HighsMipSolver {
   std::vector<HighsObjectiveSolution> saved_objective_and_solution_;
 
   bool submip;
-  HighsInt submip_level;
-  HighsInt max_submip_level;
+  HighsInt global_submip_level;
+  HighsInt max_local_submip_level;
   const HighsBasis* rootbasis;
   const HighsPseudocostInitialization* pscostinit;
   const HighsCliqueTable* clqtableinit;
@@ -85,7 +85,7 @@ class HighsMipSolver {
 
   HighsMipSolver(HighsCallback& callback, const HighsOptions& options,
                  const HighsLp& lp, const HighsSolution& solution,
-                 bool submip = false, HighsInt submip_level = 0);
+                 bool submip = false, HighsInt global_submip_level = 0);
 
   ~HighsMipSolver();
 
diff --git a/highs/mip/HighsMipSolverData.cpp b/highs/mip/HighsMipSolverData.cpp
@@ -2686,13 +2686,15 @@ bool HighsMipSolverData::mipIsKnapsack(const bool silent) {
   this->knapsack_capacity_ = std::floor(double_capacity + capacity_margin);
   // Problem is knapsack!
   if (!silent) {
-    HighsMipProblemData mip_problem_data;
-    mip_problem_data.clear();
-    mip_problem_data.submip_level = mipsolver.submip_level;
-    mip_problem_data.num_binary = lp.num_col_;
-    mip_problem_data.num_row = lp.num_row_;
-    mip_problem_data.type = HighsMipProblemType::kKnapsack;
-    this->mip_problem_data_.push_back(mip_problem_data);
+    HighsMipProblemRecord mip_problem_record;
+    mip_problem_record.clear();
+    mip_problem_record.global_submip_level = mipsolver.global_submip_level;
+    mip_problem_record.num_binary = lp.num_col_;
+    mip_problem_record.num_row = lp.num_row_;
+    mip_problem_record.type = HighsMipProblemType::kKnapsack;
+    this->mip_problem_data_.record.push_back(mip_problem_record);
+    if (this->mip_problem_data_.knapsack_mip.num_col_ == 0)
+      this->mip_problem_data_.knapsack_mip = lp;
   }
   return true;
 }
@@ -2708,47 +2710,49 @@ bool HighsMipSolverData::mipIsInes(const bool silent) {
   // 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)
+    if (lp.row_lower_[iRow] - ines_feas_tol > 0 ||
+        lp.row_upper_[iRow] + ines_feas_tol < 0)
       return false;
   }
   if (!silent) {
     highsLogUser(mipsolver.options_mip_->log_options, HighsLogType::kInfo,
                  "MIP is an Ines problem\n");
-    HighsMipProblemData mip_problem_data;
-    mip_problem_data.clear();
-    mip_problem_data.submip_level = mipsolver.submip_level;
-    mip_problem_data.num_binary = lp.num_col_;
-    mip_problem_data.num_row = lp.num_row_;
-    mip_problem_data.type = HighsMipProblemType::kInes;
-    this->mip_problem_data_.push_back(mip_problem_data);
+    HighsMipProblemRecord mip_problem_record;
+    mip_problem_record.clear();
+    mip_problem_record.global_submip_level = mipsolver.global_submip_level;
+    mip_problem_record.num_binary = lp.num_col_;
+    mip_problem_record.num_row = lp.num_row_;
+    mip_problem_record.type = HighsMipProblemType::kInes;
+    this->mip_problem_data_.record.push_back(mip_problem_record);
+    if (this->mip_problem_data_.ines_mip.num_col_ == 0)
+      this->mip_problem_data_.ines_mip = lp;
   }
   return true;
 }
 
 void HighsMipSolverData::mipIsOther() {
   const HighsLp& lp = *(mipsolver.model_);
-  HighsMipProblemData mip_problem_data;
-  mip_problem_data.clear();
-  mip_problem_data.submip_level = mipsolver.submip_level;
+  HighsMipProblemRecord mip_problem_record;
+  mip_problem_record.clear();
+  mip_problem_record.global_submip_level = mipsolver.global_submip_level;
   for (HighsInt iCol = 0; iCol < lp.num_col_; iCol++) {
     if (lp.integrality_[iCol] == HighsVarType::kContinuous) {
-      mip_problem_data.num_continuous++;
+      mip_problem_record.num_continuous++;
     } else if (lp.integrality_[iCol] == HighsVarType::kInteger) {
       if (lp.col_lower_[iCol] == 0 && lp.col_upper_[iCol] == 1) {
-        mip_problem_data.num_binary++;
+        mip_problem_record.num_binary++;
       } else {
-        mip_problem_data.num_general_integer++;
+        mip_problem_record.num_general_integer++;
       }
     } else if (lp.integrality_[iCol] == HighsVarType::kImplicitInteger) {
-      mip_problem_data.num_implied_integer++;
+      mip_problem_record.num_implied_integer++;
     } else {
       assert(111 == 234);
     }
   }
-  mip_problem_data.num_row = lp.num_row_;
-  mip_problem_data.type = HighsMipProblemType::kOther;
-  this->mip_problem_data_.push_back(mip_problem_data);
+  mip_problem_record.num_row = lp.num_row_;
+  mip_problem_record.type = HighsMipProblemType::kOther;
+  this->mip_problem_data_.record.push_back(mip_problem_record);
 }
 
 static double possInfRelDiff(const double v0, const double v1,
@@ -2887,12 +2891,48 @@ void HighsMipSolverData::updatePrimalDualIntegral(const double from_lower_bound,
 
 void HighsPrimaDualIntegral::initialise() { this->value = -kHighsInf; }
 
-void HighsMipProblemData::clear() {
-  this->submip_level = -1;
+void HighsMipProblemRecord::clear() {
+  this->global_submip_level = -1;
   this->num_continuous = 0;
   this->num_binary = 0;
   this->num_implied_integer = 0;
   this->num_general_integer = 0;
   this->num_row = 0;
   this->type = HighsMipProblemType::kOther;
 }
+
+void HighsMipProblemData::clear() { this->record.clear(); }
+
+void HighsMipProblemData::append(const HighsMipProblemData& mip_problem_data) {
+  this->record.insert(this->record.end(), mip_problem_data.record.begin(),
+                      mip_problem_data.record.end());
+  HighsInt current_sum =
+      this->knapsack_mip.num_col_ + this->knapsack_mip.num_row_;
+  HighsInt append_sum = mip_problem_data.knapsack_mip.num_col_ +
+                        mip_problem_data.knapsack_mip.num_row_;
+  if (current_sum < append_sum)
+    this->knapsack_mip = mip_problem_data.knapsack_mip;
+  current_sum = this->ines_mip.num_col_ + this->ines_mip.num_row_;
+  append_sum =
+      mip_problem_data.ines_mip.num_col_ + mip_problem_data.ines_mip.num_row_;
+  if (current_sum < append_sum) this->ines_mip = mip_problem_data.ines_mip;
+}
+
+HighsInt HighsMipProblemData::numRecord() {
+  return static_cast<HighsInt>(record.size());
+}
+
+HighsInt HighsMipProblemData::numKnapsack() {
+  HighsInt num_knapsack = 0;
+  for (HighsInt iMip = 0; iMip < this->numRecord(); iMip++)
+    if (this->record[iMip].type == HighsMipProblemType::kKnapsack)
+      num_knapsack++;
+  return num_knapsack;
+}
+
+HighsInt HighsMipProblemData::numInes() {
+  HighsInt num_ines = 0;
+  for (HighsInt iMip = 0; iMip < this->numRecord(); iMip++)
+    if (this->record[iMip].type == HighsMipProblemType::kInes) num_ines++;
+  return num_ines;
+}
diff --git a/highs/mip/HighsMipSolverData.h b/highs/mip/HighsMipSolverData.h
@@ -32,8 +32,8 @@
 
 enum class HighsMipProblemType { kKnapsack = 0, kInes, kOther };
 
-struct HighsMipProblemData {
-  HighsInt submip_level;
+struct HighsMipProblemRecord {
+  HighsInt global_submip_level;
   HighsInt num_continuous;
   HighsInt num_binary;
   HighsInt num_general_integer;
@@ -43,6 +43,17 @@ struct HighsMipProblemData {
   void clear();
 };
 
+struct HighsMipProblemData {
+  std::vector<HighsMipProblemRecord> record;
+  HighsLp ines_mip;
+  HighsLp knapsack_mip;
+  void clear();
+  void append(const HighsMipProblemData& mip_problem_data);
+  HighsInt numRecord();
+  HighsInt numKnapsack();
+  HighsInt numInes();
+};
+
 struct HighsPrimaDualIntegral {
   double value;
   double prev_lb;
@@ -169,7 +180,7 @@ struct HighsMipSolverData {
   HighsInt knapsack_capacity_;
   HighsInt knapsack_integral_scale_;
 
-  std::vector<HighsMipProblemData> mip_problem_data_;
+  HighsMipProblemData mip_problem_data_;
 
   HighsMipSolverData(HighsMipSolver& mipsolver)
       : mipsolver(mipsolver),
diff --git a/highs/mip/HighsPrimalHeuristics.cpp b/highs/mip/HighsPrimalHeuristics.cpp
