lpsolver 0.1.0 → 0.2.1

data/ext/lpsolver-highs/check/TestModelProperties.cpp

@@ -0,0 +1,143 @@
+#include <cmath>
+
+#include "HCheckConfig.h"
+#include "Highs.h"
+#include "catch.hpp"
+
+const bool dev_run = false;
+const double inf = kHighsInf;
+
+TEST_CASE("simplest-ill-conditioning", "[highs_model_properties]") {
+  Highs highs;
+  highs.setOptionValue("output_flag", dev_run);
+  HighsLp lp;
+  const double epsilon = 1e-4;
+  const double ill_conditioning_bound = 1;
+  lp.num_col_ = 2;
+  lp.num_row_ = 2;
+  lp.col_cost_ = {2, 2 + epsilon};
+  lp.col_lower_ = {0, 0};
+  lp.col_upper_ = {inf, inf};
+  lp.row_lower_ = {2, 2 + epsilon};
+  lp.row_upper_ = {inf, inf};
+  lp.a_matrix_.start_ = {0, 2, 4};
+  lp.a_matrix_.index_ = {0, 1, 0, 1};
+  lp.a_matrix_.value_ = {1, 1, 1, 1 + epsilon};
+  highs.passModel(lp);
+  highs.run();
+  if (dev_run) highs.writeSolution("", 1);
+  HighsIllConditioning ill_conditioning;
+
+  const bool constraint = true;
+  highs.getIllConditioning(ill_conditioning, constraint);
+  REQUIRE(ill_conditioning.record.size() == 2);
+  // Both multipliers should be large
+  for (HighsInt iX = 0; iX < 2; iX++) {
+    REQUIRE(std::fabs(ill_conditioning.record[iX].multiplier) > 0.45);
+    REQUIRE(std::fabs(ill_conditioning.record[iX].multiplier) < 0.55);
+  }
+  highs.getIllConditioning(ill_conditioning, !constraint);
+
+  REQUIRE(highs.getIllConditioning(ill_conditioning, constraint, 1, 0.1) ==
+          HighsStatus::kOk);
+  REQUIRE(highs.getIllConditioning(ill_conditioning, constraint, 1,
+                                   ill_conditioning_bound) == HighsStatus::kOk);
+  REQUIRE(highs.getIllConditioning(ill_conditioning, constraint, 1, 10) ==
+          HighsStatus::kOk);
+  highs.resetGlobalScheduler(true);
+}
+
+TEST_CASE("simple-ill-conditioning", "[highs_model_properties]") {
+  Highs highs;
+  highs.setOptionValue("output_flag", dev_run);
+  HighsLp lp;
+  const double epsilon = 1e-4;
+  lp.num_col_ = 3;
+  lp.num_row_ = 3;
+  lp.col_cost_ = {3, 2, 3 + epsilon};
+  lp.col_lower_ = {0, 0, 0};
+  lp.col_upper_ = {inf, inf, inf};
+  lp.row_lower_ = {3, 2, 3 + epsilon};
+  lp.row_upper_ = {inf, inf, inf};
+  lp.a_matrix_.start_ = {0, 3, 5, 8};
+  lp.a_matrix_.index_ = {0, 1, 2, 0, 2, 0, 1, 2};
+  lp.a_matrix_.value_ = {1, 1, 1, 1, 1, 1, 1, 1 + epsilon};
+
+  highs.passModel(lp);
+  highs.run();
+  if (dev_run) highs.writeSolution("", 1);
+  HighsIllConditioning ill_conditioning;
+  const bool constraint = true;
+  highs.getIllConditioning(ill_conditioning, constraint);
+  REQUIRE(ill_conditioning.record.size() == 3);
+  // First two multipliers should be the large ones
+  for (HighsInt iX = 0; iX < 2; iX++) {
+    REQUIRE(std::fabs(ill_conditioning.record[iX].multiplier) > 0.45);
+    REQUIRE(std::fabs(ill_conditioning.record[iX].multiplier) < 0.55);
+  }
+  highs.getIllConditioning(ill_conditioning, !constraint);
+}
+
+TEST_CASE("afiro-ill-conditioning", "[highs_model_properties]") {
+  std::string filename = std::string(HIGHS_DIR) + "/check/instances/afiro.mps";
+  Highs highs;
+  highs.setOptionValue("output_flag", dev_run);
+  highs.readModel(filename);
+  const HighsLp& lp = highs.getLp();
+  HighsInt num_nz;
+  std::vector<HighsInt> index(lp.num_col_);
+  std::vector<double> value(lp.num_col_);
+  highs.run();
+  const HighsBasis& highs_basis = highs.getBasis();
+  lp.a_matrix_.getRow(0, num_nz, index.data(), value.data());
+  if (dev_run) {
+    for (HighsInt iEl = 0; iEl < num_nz; iEl++) {
+      HighsInt iCol = index[iEl];
+      printf("%s: %d %19.12g (%s)\n", lp.col_names_[iCol].c_str(), int(iCol),
+             value[iEl],
+             highs.basisStatusToString(highs_basis.col_status[iCol]).c_str());
+    }
+  }
+  value[0] += 1e-4;
+
+  const bool negate_bad_row = false;
+  if (negate_bad_row)
+    for (HighsInt iEl = 0; iEl < num_nz; iEl++) value[iEl] *= -1;
+
+  highs.addRow(0, 0, num_nz, index.data(), value.data());
+  HighsInt bad_row = lp.num_row_ - 1;
+  highs.passRowName(bad_row, "R09bad");
+  // Find a nonbasic row to replace bad row in the basis
+  HighsInt nonbasic_row = -1;
+  for (HighsInt iRow = 1; iRow < lp.num_row_; iRow++) {
+    if (dev_run) {
+      printf("Row %d (%s) has status %s\n", int(iRow),
+             lp.row_names_[iRow].c_str(),
+             highs.basisStatusToString(highs_basis.row_status[iRow]).c_str());
+    }
+    if (highs_basis.row_status[iRow] != HighsBasisStatus::kBasic) {
+      nonbasic_row = iRow;
+      break;
+    }
+  }
+  // Bad row should be basic - since it's been added
+  REQUIRE(highs_basis.row_status[bad_row] == HighsBasisStatus::kBasic);
+  REQUIRE(nonbasic_row >= 0);
+  HighsBasis basis = highs_basis;
+  // Make the bad row nonbasic at lower bound - it's FX - and make the
+  // nonbasic_row basic
+  basis.row_status[bad_row] = HighsBasisStatus::kLower;
+  basis.row_status[nonbasic_row] = HighsBasisStatus::kBasic;
+  highs.setBasis(basis);
+  if (dev_run) {
+    for (HighsInt iRow = 0; iRow < lp.num_row_; iRow++) {
+      printf("Row %d (%s) has status %s\n", int(iRow),
+             lp.row_names_[iRow].c_str(),
+             highs.basisStatusToString(highs_basis.row_status[iRow]).c_str());
+    }
+  }
+  HighsIllConditioning ill_conditioning;
+  const bool constraint = true;
+  highs.getIllConditioning(ill_conditioning, constraint);
+  highs.getIllConditioning(ill_conditioning, !constraint);
+}

data/ext/lpsolver-highs/check/TestMultiObjective.cpp

@@ -0,0 +1,198 @@
+#include "Highs.h"
+#include "catch.hpp"
+
+const bool dev_run = false;
+
+bool smallDoubleDifference(double v0, double v1) {
+  double difference = std::fabs(v0 - v1);
+  //  printf("smallDoubleDifference = %g\n", difference);
+  return difference < 1e-4;
+}
+
+TEST_CASE("multi-objective", "[util]") {
+  HighsLp lp;
+  lp.num_col_ = 2;
+  lp.num_row_ = 3;
+  lp.col_cost_ = {0, 0};
+  lp.col_lower_ = {0, 0};
+  lp.col_upper_ = {kHighsInf, kHighsInf};
+  lp.row_lower_ = {-kHighsInf, -kHighsInf, -kHighsInf};
+  lp.row_upper_ = {18, 8, 14};
+  lp.a_matrix_.start_ = {0, 3, 6};
+  lp.a_matrix_.index_ = {0, 1, 2, 0, 1, 2};
+  lp.a_matrix_.value_ = {3, 1, 1, 1, 1, 2};
+  Highs h;
+  h.setOptionValue("output_flag", dev_run);
+
+  for (HighsInt k = 0; k < 2; k++) {
+    // Pass 0 is continuous; pass 1 integer
+    if (dev_run)
+      printf(
+          "\n******************\nPass %d: var type is %s\n******************\n",
+          int(k), k == 0 ? "continuous" : "integer");
+    for (HighsInt l = 0; l < 2; l++) {
+      // Pass 0 is with unsigned weights and coefficients
+      double obj_mu = l == 0 ? 1 : -1;
+      if (dev_run)
+        printf(
+            "\n******************\nPass %d: objective multiplier is "
+            "%g\n******************\n",
+            int(l), obj_mu);
+
+      if (k == 0) {
+        lp.integrality_.clear();
+      } else if (k == 1) {
+        lp.integrality_ = {HighsVarType::kInteger, HighsVarType::kInteger};
+      }
+      h.passModel(lp);
+
+      h.setOptionValue("blend_multi_objectives", true);
+
+      HighsLinearObjective linear_objective;
+      std::vector<HighsLinearObjective> linear_objectives;
+      REQUIRE(h.clearLinearObjectives() == HighsStatus::kOk);
+
+      // Begin with an illegal linear objective
+      if (dev_run) printf("\nPass illegal linear objective\n");
+      linear_objective.weight = -obj_mu;
+      linear_objective.offset = -obj_mu;
+      linear_objective.coefficients = {obj_mu * 1, obj_mu * 1, obj_mu * 0};
+      linear_objective.abs_tolerance = 0.0;
+      linear_objective.rel_tolerance = 0.0;
+      REQUIRE(h.addLinearObjective(linear_objective) == HighsStatus::kError);
+      // Now legalise the linear objective so LP has nonunique optimal
+      // solutions on the line joining (2, 6) and (5, 3)
+      if (dev_run) printf("\nPass legal linear objective\n");
+      linear_objective.coefficients = {obj_mu * 1, obj_mu * 1};
+      REQUIRE(h.addLinearObjective(linear_objective) == HighsStatus::kOk);
+
+      REQUIRE(h.run() == HighsStatus::kOk);
+      h.writeSolution("", kSolutionStylePretty);
+      REQUIRE(smallDoubleDifference(h.getInfo().objective_function_value, -7));
+      // Save the linear objective for the next
+      linear_objectives.push_back(linear_objective);
+
+      // Add a second linear objective with a very small minimization
+      // weight that should push the optimal solution to (2, 6)
+      if (dev_run) printf("\nPass second linear objective\n");
+      linear_objective.weight = obj_mu * 1e-4;
+      linear_objective.offset = 0;
+      linear_objective.coefficients = {obj_mu * 1, obj_mu * 0};
+      REQUIRE(h.addLinearObjective(linear_objective) == HighsStatus::kOk);
+
+      REQUIRE(h.run() == HighsStatus::kOk);
+      h.writeSolution("", kSolutionStylePretty);
+      REQUIRE(smallDoubleDifference(h.getSolution().col_value[0], 2));
+      REQUIRE(smallDoubleDifference(h.getSolution().col_value[1], 6));
+      linear_objectives.push_back(linear_objective);
+
+      if (dev_run) printf("\nClear and pass two linear objectives\n");
+      REQUIRE(h.clearLinearObjectives() == HighsStatus::kOk);
+      REQUIRE(h.passLinearObjectives(2, linear_objectives.data()) ==
+              HighsStatus::kOk);
+      REQUIRE(h.run() == HighsStatus::kOk);
+      h.writeSolution("", kSolutionStylePretty);
+      REQUIRE(smallDoubleDifference(h.getSolution().col_value[0], 2));
+      REQUIRE(smallDoubleDifference(h.getSolution().col_value[1], 6));
+
+      // Set illegal priorities - that can be passed OK since
+      // blend_multi_objectives = true
+      if (dev_run)
+        printf(
+            "\nSetting priorities that will be illegal when using "
+            "lexicographic "
+            "optimization\n");
+      linear_objectives[0].priority = 0;
+      linear_objectives[1].priority = 0;
+      REQUIRE(h.passLinearObjectives(2, linear_objectives.data()) ==
+              HighsStatus::kOk);
+
+      // Now test lexicographic optimization
+      h.setOptionValue("blend_multi_objectives", false);
+
+      if (dev_run) printf("\nLexicographic using illegal priorities\n");
+      REQUIRE(h.run() == HighsStatus::kError);
+
+      if (dev_run)
+        printf(
+            "\nSetting priorities that are illegal now blend_multi_objectives "
+            "= "
+            "false\n");
+      REQUIRE(h.passLinearObjectives(2, linear_objectives.data()) ==
+              HighsStatus::kError);
+
+      if (dev_run)
+        printf(
+            "\nSetting legal priorities for blend_multi_objectives = false\n");
+      linear_objectives[0].priority = 10;
+      REQUIRE(h.passLinearObjectives(2, linear_objectives.data()) ==
+              HighsStatus::kOk);
+
+      if (dev_run)
+        printf("\nLexicographic using existing multi objective data\n");
+      REQUIRE(h.run() == HighsStatus::kOk);
+      h.writeSolution("", kSolutionStylePretty);
+      REQUIRE(smallDoubleDifference(h.getSolution().col_value[0], 2));
+      REQUIRE(smallDoubleDifference(h.getSolution().col_value[1], 6));
+
+      // Back to blending
+      h.setOptionValue("blend_multi_objectives", true);
+      //  h.setOptionValue("output_flag", true);
+      REQUIRE(h.clearLinearObjectives() == HighsStatus::kOk);
+      linear_objectives[0].coefficients = {obj_mu * 1.0001, obj_mu * 1};
+      linear_objectives[0].abs_tolerance = 1e-5;
+      linear_objectives[0].rel_tolerance = 0.05;
+      linear_objectives[1].weight = obj_mu * 1e-3;
+      if (dev_run)
+        printf(
+            "\nBlending: first solve objective just giving unique optimal "
+            "solution\n");
+      REQUIRE(h.passLinearObjectives(1, linear_objectives.data()) ==
+              HighsStatus::kOk);
+
+      REQUIRE(h.run() == HighsStatus::kOk);
+      h.writeSolution("", kSolutionStylePretty);
+
+      REQUIRE(h.passLinearObjectives(2, linear_objectives.data()) ==
+              HighsStatus::kOk);
+
+      REQUIRE(h.run() == HighsStatus::kOk);
+      h.writeSolution("", kSolutionStylePretty);
+
+      // Back to lexicographic optimization
+      h.setOptionValue("blend_multi_objectives", false);
+
+      if (dev_run) printf("\nLexicographic using non-trivial tolerances\n");
+      REQUIRE(h.run() == HighsStatus::kOk);
+      h.writeSolution("", kSolutionStylePretty);
+
+      if (k == 0) {
+        REQUIRE(smallDoubleDifference(h.getSolution().col_value[0], 4.9));
+        REQUIRE(smallDoubleDifference(h.getSolution().col_value[1], 3.1));
+      } else {
+        REQUIRE(smallDoubleDifference(h.getSolution().col_value[0], 5));
+        REQUIRE(smallDoubleDifference(h.getSolution().col_value[1], 3));
+      }
+
+      linear_objectives[0].abs_tolerance = kHighsInf;
+
+      REQUIRE(h.passLinearObjectives(2, linear_objectives.data()) ==
+              HighsStatus::kOk);
+
+      REQUIRE(h.run() == HighsStatus::kOk);
+      h.writeSolution("", kSolutionStylePretty);
+
+      //  printf("Solution = [%23.18g, %23.18g]\n",
+      //  h.getSolution().col_value[0], h.getSolution().col_value[1]);
+      if (k == 0) {
+        REQUIRE(smallDoubleDifference(h.getSolution().col_value[0], 1.30069));
+        REQUIRE(smallDoubleDifference(h.getSolution().col_value[1], 6.34966));
+      } else {
+        REQUIRE(smallDoubleDifference(h.getSolution().col_value[0], 2));
+        REQUIRE(smallDoubleDifference(h.getSolution().col_value[1], 6));
+      }
+    }
+  }
+
+  h.resetGlobalScheduler(true);
+}

data/ext/lpsolver-highs/check/TestNames.cpp

@@ -0,0 +1,187 @@
+#include <sstream>
+
+#include "HCheckConfig.h"
+#include "Highs.h"
+#include "catch.hpp"
+
+const bool dev_run = false;
+TEST_CASE("highs-names", "[highs_names]") {
+  const std::string test_name = Catch::getResultCapture().getCurrentTestName();
+  const std::string solution_file = test_name + ".sol";
+  std::string name;
+  const std::string model = "avgas";
+  const std::string model_file =
+      std::string(HIGHS_DIR) + "/check/instances/" + model + ".mps";
+
+  Highs highs;
+  highs.setOptionValue("output_flag", dev_run);
+  highs.readModel(model_file);
+  const HighsLp& lp = highs.getLp();
+
+  HighsInt iCol, iRow;
+  HighsStatus status;
+
+  HighsInt ck_iCol;
+  for (HighsInt iCol = 0; iCol < lp.num_col_; iCol++) {
+    status = highs.getColName(iCol, name);
+    REQUIRE(status == HighsStatus::kOk);
+    status = highs.getColByName(name, ck_iCol);
+    REQUIRE(ck_iCol == iCol);
+  }
+  HighsInt ck_iRow;
+  for (HighsInt iRow = 0; iRow < lp.num_row_; iRow++) {
+    status = highs.getRowName(iRow, name);
+    REQUIRE(status == HighsStatus::kOk);
+    status = highs.getRowByName(name, ck_iRow);
+    REQUIRE(ck_iRow == iRow);
+  }
+
+  // Change all names to distinct new names
+  REQUIRE(highs.passColName(-1, "FRED") == HighsStatus::kError);
+  REQUIRE(highs.passColName(lp.num_col_, "FRED") == HighsStatus::kError);
+  REQUIRE(highs.passColName(0, "") == HighsStatus::kError);
+  std::string col0_name;
+  for (HighsInt iCol = 0; iCol < lp.num_col_; iCol++) {
+    std::stringstream ss;
+    ss.str(std::string());
+    ss << model << "_col_" << iCol << "\0";
+    const std::string name = ss.str();
+    if (iCol == 0) col0_name = name;
+    if (dev_run) printf("Col %d name is to be %s\n", int(iCol), name.c_str());
+    REQUIRE(highs.passColName(iCol, name) == HighsStatus::kOk);
+  }
+  REQUIRE(highs.passRowName(-1, "FRED") == HighsStatus::kError);
+  REQUIRE(highs.passRowName(lp.num_row_, "FRED") == HighsStatus::kError);
+  REQUIRE(highs.passRowName(0, "") == HighsStatus::kError);
+  std::string row0_name;
+  for (HighsInt iRow = 0; iRow < lp.num_row_; iRow++) {
+    std::stringstream ss;
+    ss.str(std::string());
+    ss << model << "_row_" << iRow << "\0";
+    const std::string name = ss.str();
+    if (iRow == 0) row0_name = name;
+    if (dev_run) printf("Row %d name is to be %s\n", int(iRow), name.c_str());
+    REQUIRE(highs.passRowName(iRow, name) == HighsStatus::kOk);
+  }
+  highs.run();
+  REQUIRE(highs.writeModel("") == HighsStatus::kOk);
+  if (dev_run) highs.writeSolution("", 1);
+
+  status = highs.getColByName(col0_name, iCol);
+  REQUIRE(status == HighsStatus::kOk);
+  REQUIRE(iCol == 0);
+  status = highs.getRowByName(row0_name, iRow);
+  REQUIRE(status == HighsStatus::kOk);
+  REQUIRE(iRow == 0);
+
+  // Change name of column num_col/2 to be the same as column 0
+  REQUIRE(highs.getColName(0, name) == HighsStatus::kOk);
+  REQUIRE(name == col0_name);
+  iCol = lp.num_col_ / 2;
+  std::string iCol_name;
+  REQUIRE(highs.getColName(iCol, iCol_name) == HighsStatus::kOk);
+  REQUIRE(highs.passColName(iCol, col0_name) == HighsStatus::kOk);
+
+  // column num_col/2 is no longer called iCol_name
+  status = highs.getColByName(iCol_name, iCol);
+  REQUIRE(status == HighsStatus::kError);
+
+  status = highs.getColByName(col0_name, iCol);
+  REQUIRE(status == HighsStatus::kError);
+
+  // Model can (since duplicates lead to generic names in fix-2887) be
+  // written
+  REQUIRE(highs.writeModel("") == HighsStatus::kWarning);
+  if (dev_run) highs.writeSolution("", 1);
+
+  // Reinstate name and model writes OK
+  REQUIRE(highs.passColName(iCol, iCol_name) == HighsStatus::kOk);
+  REQUIRE(highs.writeModel("") == HighsStatus::kOk);
+
+  // Change name of row num_row/2 to be the same as row 0
+  REQUIRE(highs.getRowName(0, name) == HighsStatus::kOk);
+  REQUIRE(name == row0_name);
+  iRow = lp.num_row_ / 2;
+  REQUIRE(highs.passRowName(iRow, row0_name) == HighsStatus::kOk);
+  // Model can (since duplicates lead to generic names in fix-2887) be
+  // written
+  REQUIRE(highs.writeModel("") == HighsStatus::kWarning);
+  if (dev_run) highs.writeSolution("", 1);
+
+  // Now work with a name-less model
+  HighsLp local_lp = lp;
+  local_lp.col_names_.clear();
+  local_lp.row_names_.clear();
+  highs.passModel(local_lp);
+  REQUIRE(highs.writeSolution(solution_file, 1) == HighsStatus::kWarning);
+
+  std::remove(solution_file.c_str());
+}
+
+TEST_CASE("highs-model-name", "[model_names]") {
+  Highs highs;
+  const HighsLp& lp = highs.getLp();
+
+  std::string name = lp.model_name_;
+  REQUIRE(name == "");
+
+  highs.passModelName("new_name");
+  name = lp.model_name_;
+  REQUIRE(name == "new_name");
+}
+
+TEST_CASE("highs-illegal-col-row-name", "[model_names]") {
+  const std::string test_name = Catch::getResultCapture().getCurrentTestName();
+  const std::string lp_file = test_name + ".lp";
+  const std::string mps_file = test_name + ".mps";
+  Highs h;
+  h.setOptionValue("output_flag", dev_run);
+  HighsLp lp;
+  lp.num_col_ = 2;
+  lp.num_row_ = 1;
+  lp.col_cost_ = {1, 2};
+  lp.col_lower_ = {0, 0};
+  lp.col_upper_ = {1, 1};
+  lp.row_lower_ = {-kHighsInf};
+  lp.row_upper_ = {5};
+  lp.a_matrix_.start_ = {0, 1, 2};
+  lp.a_matrix_.index_ = {0, 0};
+  lp.a_matrix_.value_ = {1, 1};
+
+  HighsStatus mps_write_return = HighsStatus::kWarning;
+  HighsStatus lp_write_return = HighsStatus::kWarning;
+  HighsStatus status = HighsStatus::kOk;
+  for (HighsInt k = 0; k < 3; k++) {
+    if (k == 0) {
+      // Repacing space with "_" is OK, but "^" is illegal for LP
+      lp.col_names_ = {"Col 0", "Col^1"};
+      lp.row_names_ = {"Row 0"};
+    } else if (k == 1) {
+      // Replacing blank with "c_ekk0" is OK, but "^" is illegal for
+      // LP
+      lp.col_names_ = {"", "Col^1"};
+      lp.row_names_ = {"Row 0"};
+    } else {
+      // Repacing space yields duplicate, and "^" is illegal for
+      // LP
+      lp.col_names_ = {"Col 0", "Col_0"};
+      lp.row_names_ = {"Row^0"};
+    }
+    status = h.passModel(lp);
+    REQUIRE(status != HighsStatus::kError);
+
+    status = h.writeModel(mps_file);
+    REQUIRE(status == mps_write_return);
+
+    status = h.writeModel(lp_file);
+    REQUIRE(status == lp_write_return);
+  }
+  status = h.readModel(mps_file);
+  REQUIRE(status == HighsStatus::kOk);
+
+  status = h.readModel(lp_file);
+  REQUIRE(status == HighsStatus::kOk);
+
+  std::remove(mps_file.c_str());
+  std::remove(lp_file.c_str());
+}