Merge pull request #2636 from ERGO-Code/fix-2635

Fix 2635

Author: jajhall

check/TestCAPI.c

@@ -2238,6 +2238,107 @@ void testIis() {
     }
   }
 
+  // Re #2635 check with feasible LP
+  Highs_clearModel(highs);
+
+  ret = Highs_addCol(highs, 0.0, 0.0, inf, 0, NULL, NULL);
+  assert(ret == 0);
+  ret = Highs_addCol(highs, 0.0, 0.0, inf, 0, NULL, NULL);
+  assert(ret == 0);
+  index[0] = 0;
+  index[1] = 1;
+  value_1[0] = 1;
+  value_1[1] = 2;
+  value_2[0] = 1;
+  value_2[1] = 4;
+  ret = Highs_addRow(highs, -inf, 80, 2, index, value_1);
+  assert(ret == 0);
+  ret = Highs_addRow(highs, -inf, 120, 2, index, value_2);
+  assert(ret == 0);
+
+  ret = Highs_getLp(highs, kHighsMatrixFormatRowwise,
+		    &num_col, &num_row, &num_nz,
+		    &sense, &offset,
+		    NULL, NULL, NULL, 
+		    NULL, NULL,
+		    NULL, NULL, NULL,
+		    NULL);
+
+  HighsInt* col_index = NULL;
+  HighsInt* row_index = NULL;
+  HighsInt* col_bound = NULL;
+  HighsInt* row_bound = NULL;
+  HighsInt* col_status = (HighsInt*)malloc(sizeof(HighsInt) * num_col);
+  HighsInt* row_status = (HighsInt*)malloc(sizeof(HighsInt) * num_row);
+
+  // First try with kIisStrategyLight
+  Highs_setIntOptionValue(highs, "iis_strategy", kHighsIisStrategyLight);
+  
+  for (int k = 0 ; k < 2; k++) {
+    HighsInt iis_num_col;
+    HighsInt iis_num_row;
+    ret = Highs_getIis(highs,
+		       &iis_num_col, &iis_num_row,
+		       NULL, NULL,
+		       NULL, NULL,
+		       NULL, NULL);
+    assert(ret == 0);
+
+    assert(iis_num_col == 0);
+    assert(iis_num_row == 0);
+    ret = Highs_getIis(highs,
+		       &iis_num_col, &iis_num_row,
+		       col_index, row_index,
+		       col_bound, row_bound,
+		       col_status, row_status);
+    assert(ret == 0);
+    if (k == 0) {
+      // Before running HiGHS, model status is unknown
+      assert(col_status[0] == kHighsIisStatusMaybeInConflict);
+      assert(col_status[1] == kHighsIisStatusMaybeInConflict);
+      assert(row_status[0] == kHighsIisStatusMaybeInConflict);
+      assert(row_status[1] == kHighsIisStatusMaybeInConflict);
+    } else {
+      // After running HiGHS, model status is known to be optimal
+      assert(col_status[0] == kHighsIisStatusNotInConflict);
+      assert(col_status[1] == kHighsIisStatusNotInConflict);
+      assert(row_status[0] == kHighsIisStatusNotInConflict);
+      assert(row_status[1] == kHighsIisStatusNotInConflict);
+    }
+    Highs_run(highs);
+  }
+
+  // Now try with kHighsIisStrategyFromLpRowPriority
+  Highs_clearSolver(highs);
+  Highs_setIntOptionValue(highs, "iis_strategy",
+			  kHighsIisStrategyFromLpRowPriority);
+  HighsInt iis_num_col;
+  HighsInt iis_num_row;
+  ret = Highs_getIis(highs,
+		     &iis_num_col, &iis_num_row,
+		     NULL, NULL,
+		     NULL, NULL,
+		     NULL, NULL);
+  assert(ret == 0);
+
+  assert(iis_num_col == 0);
+  assert(iis_num_row == 0);
+  ret = Highs_getIis(highs,
+		     &iis_num_col, &iis_num_row,
+		     col_index, row_index,
+		     col_bound, row_bound,
+		     col_status, row_status);
+  assert(ret == 0);
+  // With kHighsIisStrategyFromLpRowPriority, model status is found to
+  // be feasible
+  assert(col_status[0] == kHighsIisStatusNotInConflict);
+  assert(col_status[1] == kHighsIisStatusNotInConflict);
+  assert(row_status[0] == kHighsIisStatusNotInConflict);
+  assert(row_status[1] == kHighsIisStatusNotInConflict);
+
+  free(col_status);
+  free(row_status);
+
   Highs_destroy(highs);
 }
 
@@ -2351,30 +2452,30 @@ void testFixedLp() {
 }
 
 int main() {
-    minimalApiIllegalLp();
-    testCallback();
-    versionApi();
-    fullApi();
-    minimalApiLp();
-    minimalApiMip();
-    minimalApiQp();
-    fullApiOptions();
-    fullApiLp();
-    fullApiMip();
-    fullApiQp();
-    passPresolveGetLp();
-    options();
-    testGetColsByRange();
-    testPassHessian();
-    testRanging();
-    testFeasibilityRelaxation();
-    testGetModel();
-    testMultiObjective();
-    testQpIndefiniteFailure();
-    testDualRayTwice();
-    testDeleteRowResolveWithBasis();
-    testIis();
-    testFixedLp();
+  minimalApiIllegalLp();
+  testCallback();
+  versionApi();
+  fullApi();
+  minimalApiLp();
+  minimalApiMip();
+  minimalApiQp();
+  fullApiOptions();
+  fullApiLp();
+  fullApiMip();
+  fullApiQp();
+  passPresolveGetLp();
+  options();
+  testGetColsByRange();
+  testPassHessian();
+  testRanging();
+  testFeasibilityRelaxation();
+  testGetModel();
+  testMultiObjective();
+  testQpIndefiniteFailure();
+  testDualRayTwice();
+  testDeleteRowResolveWithBasis();
+  testIis();
+  testFixedLp();
   return 0;
 }
 //  testSetSolution();

check/TestIis.cpp

@@ -442,3 +442,59 @@ void testFeasibilityRelaxation(
   REQUIRE(h.getInfo().objective_function_value ==
           require_feasibility_objective_function_value);
 }
+
+TEST_CASE("feasible-lp-iis", "[iis]") {
+  HighsLp lp;
+  lp.model_name_ = "chip";
+  lp.sense_ = ObjSense::kMaximize;
+  lp.num_col_ = 2;
+  lp.num_row_ = 2;
+  lp.col_cost_ = {10, 25};
+  lp.col_lower_ = {0, 0};
+  lp.col_upper_ = {inf, inf};
+  lp.col_names_ = {"Tables", "SetsOfChairs"};
+  lp.row_lower_ = {-inf, -inf};
+  lp.row_upper_ = {80, 120};
+  lp.row_names_ = {"Assembly", "Finishng"};
+  lp.a_matrix_.start_ = {0, 2, 4};
+  lp.a_matrix_.index_ = {0, 1, 0, 1};
+  lp.a_matrix_.value_ = {1, 1, 2, 4};
+  Highs h;
+  h.setOptionValue("output_flag", dev_run);
+  h.passModel(lp);
+  HighsIis iis;
+  // With kIisStrategyLight, feasibility of the LP is not determined
+  // until it's been solved
+  h.getIis(iis);
+  REQUIRE(iis.col_index_.size() == 0);
+  REQUIRE(iis.row_index_.size() == 0);
+  REQUIRE(iis.col_status_[0] == kIisStatusMaybeInConflict);
+  REQUIRE(iis.col_status_[1] == kIisStatusMaybeInConflict);
+  REQUIRE(iis.row_status_[0] == kIisStatusMaybeInConflict);
+  REQUIRE(iis.row_status_[1] == kIisStatusMaybeInConflict);
+
+  h.run();
+
+  h.getIis(iis);
+  REQUIRE(iis.col_index_.size() == 0);
+  REQUIRE(iis.row_index_.size() == 0);
+  REQUIRE(iis.col_status_[0] == kIisStatusNotInConflict);
+  REQUIRE(iis.col_status_[1] == kIisStatusNotInConflict);
+  REQUIRE(iis.row_status_[0] == kIisStatusNotInConflict);
+  REQUIRE(iis.row_status_[1] == kIisStatusNotInConflict);
+
+  h.passModel(lp);
+  // With kIisStrategyFromLpRowPriority, feasibility of the LP is
+  // determined
+  h.setOptionValue("iis_strategy", kIisStrategyFromLpRowPriority);
+
+  h.getIis(iis);
+  REQUIRE(iis.col_index_.size() == 0);
+  REQUIRE(iis.row_index_.size() == 0);
+  REQUIRE(iis.col_status_[0] == kIisStatusNotInConflict);
+  REQUIRE(iis.col_status_[1] == kIisStatusNotInConflict);
+  REQUIRE(iis.row_status_[0] == kIisStatusNotInConflict);
+  REQUIRE(iis.row_status_[1] == kIisStatusNotInConflict);
+
+  h.resetGlobalScheduler(true);
+}

highs/lp_data/HighsInterface.cpp

@@ -1828,23 +1828,40 @@ HighsStatus Highs::getRangingInterface() {
 
 HighsStatus Highs::getIisInterfaceReturn(const HighsStatus return_status) {
   if (return_status != HighsStatus::kError) {
-    // Construct the ISS LP
-    this->iis_.getLp(this->model_.lp_);
-    // Check that the IIS LP data are OK (correspond to original model
-    // reduced to IIS col/row and bound data).
-    if (!this->iis_.lpDataOk(this->model_.lp_, this->options_))
-      return HighsStatus::kError;
-    // Check that the IIS LP is OK (infeasible and optimal/unbounded
-    // is any bound is relaxed)
-    if (!this->iis_.lpOk(this->options_)) return HighsStatus::kError;
-    // Construct the ISS status vectors for cols and rows of original
-    // model
-    this->iis_.getStatus(model_.lp_);
+    // A valid IIS is one for which the IIS information is known to be
+    // correct. In the case of a system that's feasible this will give
+    // empty HighsIis::col_index_ and HighsIis::col_index_.
+    HighsLp& lp = this->model_.lp_;
+    HighsLp& iis_lp = this->iis_.model_.lp_;
+    const bool has_iis =
+        this->iis_.col_index_.size() || this->iis_.row_index_.size();
+    if (has_iis) {
+      assert(this->iis_.valid_);
+      // Construct the ISS LP
+      this->iis_.getLp(lp);
+      // Check that the IIS LP data are OK (correspond to original model
+      // reduced to IIS col/row and bound data).
+      if (!this->iis_.lpDataOk(lp, this->options_)) return HighsStatus::kError;
+      // Check that the IIS LP is OK (infeasible and optimal/unbounded
+      // is any bound is relaxed)
+      if (!this->iis_.lpOk(this->options_)) return HighsStatus::kError;
+      // Construct the ISS status vectors for cols and rows of original
+      // model
+      this->iis_.getStatus(lp);
+    } else {
+      // No IIS, so check that the IIS LP is empty
+      assert(iis_lp.num_col_ == 0);
+      assert(iis_lp.num_row_ == 0);
+      // Make sure that col_status_ and row_status_ have been assigned
+      assert(this->iis_.col_status_.size() == static_cast<size_t>(lp.num_col_));
+      assert(this->iis_.row_status_.size() == static_cast<size_t>(lp.num_row_));
+    }
   }
   return return_status;
 }
 
 HighsStatus Highs::getIisInterface() {
+  const HighsLp& lp = model_.lp_;
   if (this->model_status_ == HighsModelStatus::kOptimal ||
       this->model_status_ == HighsModelStatus::kUnbounded) {
     // Strange to call getIis for a model that's known to be feasible
@@ -1854,6 +1871,8 @@ HighsStatus Highs::getIisInterface() {
     this->iis_.invalidate();
     // No IIS exists, so validate the empty HighsIis instance
     this->iis_.valid_ = true;
+    this->iis_.col_status_.assign(lp.num_col_, kIisStatusNotInConflict);
+    this->iis_.row_status_.assign(lp.num_row_, kIisStatusNotInConflict);
     return this->getIisInterfaceReturn(HighsStatus::kOk);
   }
   HighsStatus return_status = HighsStatus::kOk;
@@ -1866,7 +1885,6 @@ HighsStatus Highs::getIisInterface() {
   }
   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;
@@ -1887,8 +1905,11 @@ HighsStatus Highs::getIisInterface() {
   }
   // Don't continue with more expensive techniques if using the IIS
   // light strategy
-  if (options_.iis_strategy == kIisStrategyLight)
+  if (options_.iis_strategy == kIisStrategyLight) {
+    this->iis_.col_status_.assign(lp.num_col_, kIisStatusMaybeInConflict);
+    this->iis_.row_status_.assign(lp.num_row_, kIisStatusMaybeInConflict);
     return this->getIisInterfaceReturn(HighsStatus::kOk);
+  }
   const bool ray_option = false;
   //      options_.iis_strategy == kIisStrategyFromRayRowPriority ||
   //      options_.iis_strategy == kIisStrategyFromRayColPriority;
@@ -1962,6 +1983,8 @@ HighsStatus Highs::getIisInterface() {
   if (infeasible_row_subset.size() == 0) {
     // No subset of infeasible rows, so model is feasible
     this->iis_.valid_ = true;
+    this->iis_.col_status_.assign(lp.num_col_, kIisStatusNotInConflict);
+    this->iis_.row_status_.assign(lp.num_row_, kIisStatusNotInConflict);
   } else {
     return_status =
         this->iis_.getData(lp, options_, basis_, infeasible_row_subset);