Added IisStrategy and IisStatus enums contents to highs_c_api.h

Author: jajhall

highs/Highs.h

@@ -1662,6 +1662,7 @@ class Highs {
   HighsStatus getRangingInterface();
 
   HighsStatus getIisInterface();
+  HighsStatus getIisInterfaceReturn(const HighsStatus return_status);
 
   HighsStatus elasticityFilterReturn(
       const HighsStatus return_status, const bool feasible_model,

highs/highs_bindings.cpp

@@ -1679,6 +1679,14 @@ PYBIND11_MODULE(_core, m, py::mod_gil_not_used()) {
       .value("kDevex", EdgeWeightMode::kDevex)
       .value("kSteepestEdge", EdgeWeightMode::kSteepestEdge)
       .value("kCount", EdgeWeightMode::kCount);
+  
+  py::module_ iis = m.def_submodule("iis", "IIS interface submodule");
+  py::enum_<HighsIisStatus>(iis, "HighsIisStatus",
+			    py::module_local())
+    .value("kIisStatusInConflict", HighsIisStatus::kIisStatusInConflict)
+    .value("kIisStatusNotInConflict", HighsIisStatus::kIisStatusNotInConflict)
+    .value("kIisStatusMaybeInConflict", HighsIisStatus::kIisStatusMaybeInConflict);
+  
   py::module_ callbacks = m.def_submodule("cb", "Callback interface submodule");
   // Types for interface
   py::enum_<HighsCallbackType>(callbacks, "HighsCallbackType",

highs/interfaces/highs_c_api.h

@@ -133,6 +133,14 @@ const char* const kHighsCallbackDataOutCutpoolValueName = "cutpool_value";
 const char* const kHighsCallbackDataOutCutpoolLowerName = "cutpool_lower";
 const char* const kHighsCallbackDataOutCutpoolUpperName = "cutpool_upper";
 
+const HighsInt kHighsIisStrategyLight = 0;
+// const HighsInt kHighsIisStrategyFromLpRowPriority = 1; // WIP
+// const HighsInt kHighsIisStrategyFromLpColPriority = 2; // WIP
+
+const HighsInt kHighsIisStatusInConflict = 0;
+const HighsInt kHighsIisStatusNotInConflict = 1;
+const HighsInt kHighsIisStatusMaybeInConflict = 2;
+
 #ifdef __cplusplus
 extern "C" {
 #endif

highs/lp_data/HConst.h

@@ -268,7 +268,7 @@ enum PresolveRuleType : int {
   kPresolveRuleCount,
 };
 
-enum IisStrategy {
+enum IisStrategy : int {
   kIisStrategyMin = 0,
   kIisStrategyLight = kIisStrategyMin,  // 0
   kIisStrategyFromLpRowPriority,        // 1
@@ -278,6 +278,14 @@ enum IisStrategy {
   kIisStrategyMax = kIisStrategyFromLpColPriority
 };
 
+enum IisStatus {
+  kIisStatusMin = 0,
+  kIisStatusInConflict = kIisStatusMin,  // 0
+  kIisStatusNotInConflict,  // 1
+  kIisStatusMaybeInConflict,  // 2
+  kIisStatusMax = kIisStatusMaybeInConflict
+};
+
 // Default KKT tolerance
 const double kDefaultKktTolerance = 1e-7;
 

highs/lp_data/HighsIis.cpp

@@ -20,6 +20,8 @@ void HighsIis::invalidate() {
   this->row_index_.clear();
   this->col_bound_.clear();
   this->row_bound_.clear();
+  this->col_status_.clear();
+  this->row_status_.clear();
   this->info_.clear();
   this->lp_.clear();
 }
@@ -120,8 +122,6 @@ bool HighsIis::trivial(const HighsLp& lp, const HighsOptions& options) {
            num_iis_col + num_iis_row < 2);
     this->valid_ = true;
     this->strategy_ = options.iis_strategy;
-    // Construct the ISS LP
-    this->getLp(lp);
     return true;
   }
   // Now look for empty rows that cannot have zero activity
@@ -143,8 +143,6 @@ bool HighsIis::trivial(const HighsLp& lp, const HighsOptions& options) {
     if (this->row_index_.size() > 0) {
       this->valid_ = true;
       this->strategy_ = options.iis_strategy;
-      // Construct the ISS LP
-      this->getLp(lp);
       return true;
     }
   }
@@ -280,6 +278,18 @@ void HighsIis::getLp(const HighsLp& lp) {
   iis_lp.model_name_ = lp.model_name_ + "_IIS";
 }
 
+void HighsIis::getStatus(const HighsLp& lp) {
+  if (!this->valid_) return;
+  this->col_status_.assign(lp.num_col_, kIisStatusNotInConflict);
+  this->row_status_.assign(lp.num_row_, kIisStatusNotInConflict);
+  HighsInt iis_num_col = this->col_index_.size();
+  HighsInt iis_num_row = this->row_index_.size();
+  for (HighsInt iisCol = 0; iisCol < iis_num_col; iisCol++) 
+    this->col_status_[this->col_index_[iisCol]] = kIisStatusInConflict;
+  for (HighsInt iisRow = 0; iisRow < iis_num_row; iisRow++) 
+    this->row_status_[this->row_index_[iisRow]] = kIisStatusInConflict;
+}
+
 HighsStatus HighsIis::compute(const HighsLp& lp, const HighsOptions& options,
                               const HighsBasis* basis) {
   const HighsLogOptions& log_options = options.log_options;

highs/lp_data/HighsIis.h

@@ -44,6 +44,7 @@ class HighsIis {
                       const HighsBasis& basis,
                       const std::vector<HighsInt>& infeasible_row);
   void getLp(const HighsLp& lp);
+  void getStatus(const HighsLp& lp);
 
   HighsStatus compute(const HighsLp& lp, const HighsOptions& options,
                       const HighsBasis* basis = nullptr);
@@ -59,6 +60,8 @@ class HighsIis {
   std::vector<HighsInt> row_index_;
   std::vector<HighsInt> col_bound_;
   std::vector<HighsInt> row_bound_;
+  std::vector<HighsInt> col_status_;
+  std::vector<HighsInt> row_status_;
   std::vector<HighsIisInfo> info_;
   HighsLp lp_;
 };

highs/lp_data/HighsInterface.cpp

@@ -1862,6 +1862,16 @@ HighsStatus Highs::getRangingInterface() {
   return getRangingData(this->ranging_, solver_object);
 }
 
+HighsStatus Highs::getIisInterfaceReturn(const HighsStatus return_status) {
+  if (return_status != HighsStatus::kError) {
+    // Construct the ISS LP
+    this->iis_.getLp(model_.lp_);
+    // Construct the ISS status vectors
+    this->iis_.getStatus(model_.lp_);
+  }
+  return return_status;  
+}
+
 HighsStatus Highs::getIisInterface() {
   if (this->model_status_ == HighsModelStatus::kOptimal ||
       this->model_status_ == HighsModelStatus::kUnbounded) {
@@ -1872,7 +1882,7 @@ HighsStatus Highs::getIisInterface() {
     this->iis_.invalidate();
     // No IIS exists, so validate the empty HighsIis instance
     this->iis_.valid_ = true;
-    return HighsStatus::kOk;
+    return this->getIisInterfaceReturn(HighsStatus::kOk);
   }
   HighsStatus return_status = HighsStatus::kOk;
   if (this->model_status_ != HighsModelStatus::kNotset &&
@@ -1882,30 +1892,30 @@ HighsStatus Highs::getIisInterface() {
                  "Calling Highs::getIis for a model with status %s\n",
                  this->modelStatusToString(this->model_status_).c_str());
   }
-  if (this->iis_.valid_) return HighsStatus::kOk;
+  if (this->iis_.valid_) return this->getIisInterfaceReturn(HighsStatus::kOk);
   this->iis_.invalidate();
   const HighsLp& lp = model_.lp_;
   // Check for trivial IIS: empty infeasible row or inconsistent bounds
   if (this->iis_.trivial(lp, options_)) {
     this->model_status_ = HighsModelStatus::kInfeasible;
-    return HighsStatus::kOk;
+    return this->getIisInterfaceReturn(HighsStatus::kOk);
   }
   HighsInt num_row = lp.num_row_;
   if (num_row == 0) {
     // For an LP with no rows, the only scope for infeasibility is
     // inconsistent columns bounds - which has already been assessed,
     // so validate the empty HighsIis instance
     this->iis_.valid_ = true;
-    return HighsStatus::kOk;
+    return this->getIisInterfaceReturn(HighsStatus::kOk);
   }
   // Look for infeasible rows based on row value bounds
   if (this->iis_.rowValueBounds(lp, options_)) {
     this->model_status_ = HighsModelStatus::kInfeasible;
-    return HighsStatus::kOk;
+    return this->getIisInterfaceReturn(HighsStatus::kOk);
   }
   // Don't continue with more expensive techniques if using the IIS
   // light strategy
-  if (options_.iis_strategy == kIisStrategyLight) return HighsStatus::kOk;
+  if (options_.iis_strategy == kIisStrategyLight) return this->getIisInterfaceReturn(HighsStatus::kOk);
   const bool ray_option = false;
   //      options_.iis_strategy == kIisStrategyFromRayRowPriority ||
   //      options_.iis_strategy == kIisStrategyFromRayColPriority;
@@ -2015,9 +2025,7 @@ HighsStatus Highs::getIisInterface() {
                  int(max_iterations), min_time,
                  num_lp_solved > 0 ? sum_time / num_lp_solved : 0, max_time);
   }
-  // Construct the ISS LP
-  this->iis_.getLp(lp);
-  return return_status;
+  return this->getIisInterfaceReturn(return_status);
 }
 
 HighsStatus Highs::elasticityFilterReturn(