Introducing a deterministic decision on whether to compute the analytic centre in MIP

check/TestLpSolvers.cpp

@@ -2,7 +2,7 @@
 #include "Highs.h"
 #include "catch.hpp"
 
-const bool dev_run = false;
+const bool dev_run = true;
 
 struct IterationCount {
   HighsInt simplex;
@@ -648,27 +648,58 @@ TEST_CASE("simplex-stats", "[highs_lp_solver]") {
 
   Highs h;
   const HighsSimplexStats& simplex_stats = h.getSimplexStats();
+  const HighsSimplexStats& presolved_lp_simplex_stats =
+      h.getPresolvedLpSimplexStats();
   h.setOptionValue("output_flag", dev_run);
+  // std::string model = "dcp2";
+  std::string model = "adlittle";
   std::string model_file =
-      std::string(HIGHS_DIR) + "/check/instances/adlittle.mps";
+      std::string(HIGHS_DIR) + "/check/instances/" + model + ".mps";
   REQUIRE(h.readModel(model_file) == HighsStatus::kOk);
 
   REQUIRE(h.run() == HighsStatus::kOk);
   REQUIRE(simplex_stats.valid);
-  REQUIRE(simplex_stats.iteration_count == 0);
-  REQUIRE(simplex_stats.num_invert == 1);
+  REQUIRE(simplex_stats.num_col > 0);
+  REQUIRE(simplex_stats.num_row > 0);
+  REQUIRE(simplex_stats.num_nz > 0);
+  REQUIRE(simplex_stats.iteration_count >= 0);
+  REQUIRE(simplex_stats.num_invert > 0);
   REQUIRE(simplex_stats.last_invert_num_el > 0);
   REQUIRE(simplex_stats.last_factored_basis_num_el > 0);
-  REQUIRE(simplex_stats.col_aq_density == 0);
-  REQUIRE(simplex_stats.row_ep_density == 0);
-  REQUIRE(simplex_stats.row_ap_density == 0);
-  REQUIRE(simplex_stats.row_DSE_density == 0);
+  if (simplex_stats.iteration_count > 0) {
+    REQUIRE(simplex_stats.col_aq_density > 0);
+    REQUIRE(simplex_stats.row_ep_density > 0);
+    REQUIRE(simplex_stats.row_ap_density > 0);
+    REQUIRE(simplex_stats.row_DSE_density > 0);
+  } else {
+    REQUIRE(simplex_stats.col_aq_density == 0);
+    REQUIRE(simplex_stats.row_ep_density == 0);
+    REQUIRE(simplex_stats.row_ap_density == 0);
+    REQUIRE(simplex_stats.row_DSE_density == 0);
+  }
   if (dev_run) h.reportSimplexStats(stdout);
 
+  REQUIRE(presolved_lp_simplex_stats.valid);
+  REQUIRE(presolved_lp_simplex_stats.num_col > 0);
+  REQUIRE(presolved_lp_simplex_stats.num_row > 0);
+  REQUIRE(presolved_lp_simplex_stats.num_nz > 0);
+  REQUIRE(presolved_lp_simplex_stats.iteration_count > 0);
+  REQUIRE(presolved_lp_simplex_stats.num_invert > 0);
+  REQUIRE(presolved_lp_simplex_stats.last_invert_num_el > 0);
+  REQUIRE(presolved_lp_simplex_stats.last_factored_basis_num_el > 0);
+  REQUIRE(presolved_lp_simplex_stats.col_aq_density > 0);
+  REQUIRE(presolved_lp_simplex_stats.row_ep_density > 0);
+  REQUIRE(presolved_lp_simplex_stats.row_ap_density > 0);
+  REQUIRE(presolved_lp_simplex_stats.row_DSE_density > 0);
+  if (dev_run) h.reportPresolvedLpSimplexStats(stdout);
+
   h.clearSolver();
   h.setOptionValue("presolve", kHighsOffString);
   REQUIRE(h.run() == HighsStatus::kOk);
   REQUIRE(simplex_stats.valid);
+  REQUIRE(simplex_stats.num_col > 0);
+  REQUIRE(simplex_stats.num_row > 0);
+  REQUIRE(simplex_stats.num_nz > 0);
   REQUIRE(simplex_stats.iteration_count > 0);
   REQUIRE(simplex_stats.num_invert > 0);
   REQUIRE(simplex_stats.last_invert_num_el > 0);
@@ -679,3 +710,36 @@ TEST_CASE("simplex-stats", "[highs_lp_solver]") {
   REQUIRE(simplex_stats.row_DSE_density > 0);
   if (dev_run) h.reportSimplexStats(stdout);
 }
+
+TEST_CASE("ipx-stats", "[highs_lp_solver]") {
+  HighsStatus return_status;
+
+  Highs h;
+  const HighsIpxStats& ipx_stats = h.getIpxStats();
+  h.setOptionValue("output_flag", dev_run);
+  // std::string model = "dcp2";
+  std::string model = "adlittle";
+  std::string model_file =
+      std::string(HIGHS_DIR) + "/check/instances/" + model + ".mps";
+  REQUIRE(h.readModel(model_file) == HighsStatus::kOk);
+  h.setOptionValue("solver", kIpmString);
+  REQUIRE(h.run() == HighsStatus::kOk);
+  REQUIRE(ipx_stats.valid);
+  REQUIRE(ipx_stats.num_col > 0);
+  REQUIRE(ipx_stats.num_row > 0);
+  REQUIRE(ipx_stats.num_nz > 0);
+  REQUIRE(ipx_stats.iteration_count > 0);
+  for (HighsInt iteration = 0; iteration < ipx_stats.iteration_count;
+       iteration++) {
+    REQUIRE(ipx_stats.cr_count[iteration] > 0);
+    if (ipx_stats.cr_type[iteration] == 2) {
+      REQUIRE(ipx_stats.factored_basis_num_el[iteration] > 0);
+      REQUIRE(ipx_stats.invert_num_el[iteration] > 0);
+    } else {
+      REQUIRE(ipx_stats.cr_type[iteration] == 1);
+      REQUIRE(ipx_stats.factored_basis_num_el[iteration] == 0);
+      REQUIRE(ipx_stats.invert_num_el[iteration] == 0);
+    }
+  }
+  if (dev_run) h.reportIpxStats(stdout);
+}

cmake/sources-python.cmake

@@ -312,6 +312,7 @@ set(highs_headers_python
     src/lp_data/HighsSolution.h
     src/lp_data/HighsSolutionDebug.h
     src/lp_data/HighsSolve.h
+    src/lp_data/HighsSolverStats.h
     src/lp_data/HighsStatus.h
     src/lp_data/HStruct.h
     src/mip/HighsCliqueTable.h

cmake/sources.cmake

@@ -316,6 +316,7 @@ set(highs_headers
     lp_data/HighsSolution.h
     lp_data/HighsSolutionDebug.h
     lp_data/HighsSolve.h
+    lp_data/HighsSolverStats.h
     lp_data/HighsStatus.h
     lp_data/HStruct.h
     mip/HighsCliqueTable.h

src/Highs.h

@@ -1216,11 +1216,35 @@ class Highs {
 
   // Start of advanced methods for HiGHS MIP solver
 
-  const HighsSimplexStats& getSimplexStats() const {
-    return ekk_instance_.getSimplexStats();
+  const HighsSimplexStats& getPresolvedLpSimplexStats() const {
+    return presolved_lp_simplex_stats_;
   }
-  void reportSimplexStats(FILE* file) const {
-    ekk_instance_.reportSimplexStats(file);
+
+  void reportPresolvedLpSimplexStats(
+      FILE* file, const HighsInt style = HighsSolverStatsReportPretty) const {
+    presolved_lp_simplex_stats_.report(file, "Presolved LP", style);
+  }
+
+  const HighsSimplexStats& getSimplexStats() const { return simplex_stats_; }
+
+  void reportSimplexStats(
+      FILE* file, const HighsInt style = HighsSolverStatsReportPretty) const {
+    simplex_stats_.report(file, "Original LP", style);
+  }
+
+  void passSimplexStats(const HighsSimplexStats simplex_stats) {
+    this->simplex_stats_ = simplex_stats;
+  }
+
+  const HighsIpxStats& getIpxStats() { return ipx_stats_; }
+
+  void reportIpxStats(FILE* file,
+                      const HighsInt style = HighsSolverStatsReportPretty) {
+    ipx_stats_.report(file, "Original LP", style);
+  }
+
+  void passIpxStats(const HighsIpxStats ipx_stats) {
+    this->ipx_stats_ = ipx_stats;
   }
 
   /**
@@ -1438,6 +1462,9 @@ class Highs {
   HighsSparseMatrix standard_form_matrix_;
 
   HEkk ekk_instance_;
+  HighsSimplexStats simplex_stats_;
+  HighsSimplexStats presolved_lp_simplex_stats_;
+  HighsIpxStats ipx_stats_;
 
   HighsPresolveLog presolve_log_;
 
@@ -1500,7 +1527,8 @@ class Highs {
   //
   // Invalidates all solver data in Highs class members by calling
   // invalidateModelStatus(), invalidateSolution(), invalidateBasis(),
-  // invalidateInfo() and invalidateEkk()
+  // invalidateInfo(), invalidateEkk(), invalidateIis(),
+  // invalidateSimplexStats() and invalidateIpxStats();
   void invalidateUserSolverData();
   //
   // Invalidates the model status, solution_ and info_
@@ -1527,6 +1555,12 @@ class Highs {
   // Invalidates iis_
   void invalidateIis();
 
+  // Invalidates simplex_stats_ and presolved_lp_simplex_stats_;
+  void invalidateSimplexStats();
+
+  // Invalidates ipx_stats_
+  void invalidateIpxStats();
+
   HighsStatus returnFromWriteSolution(FILE* file,
                                       const HighsStatus return_status);
   HighsStatus returnFromRun(const HighsStatus return_status,