lpsolver 0.1.0 → 0.2.1

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

@@ -0,0 +1,116 @@
+#include <cstdio>
+
+#include "HCheckConfig.h"
+#include "Highs.h"
+#include "catch.hpp"
+#include "io/HMPSIO.h"
+
+const bool dev_run = false;
+
+TEST_CASE("info-md", "[highs_info]") {
+  Highs h;
+  h.setOptionValue("output_flag", dev_run);
+  // Use this name so that it can be copied to docs and provides code
+  // coverage
+  const std::string info_file = "HighsInfo.md";
+  REQUIRE(h.writeInfo(info_file) == HighsStatus::kOk);
+  std::remove(info_file.c_str());
+}
+
+TEST_CASE("highs-info", "[highs_info]") {
+  const std::string test_name = Catch::getResultCapture().getCurrentTestName();
+  const std::string highs_info_file = test_name + ".info";
+  std::string filename;
+  filename = std::string(HIGHS_DIR) + "/check/instances/avgas.mps";
+  filename = std::string(HIGHS_DIR) + "/check/instances/adlittle.mps";
+  //  filename = std::string(HIGHS_DIR) + "/check/instances/25fv47.mps";
+
+  Highs highs;
+  if (!dev_run) highs.setOptionValue("output_flag", false);
+  const HighsInfo& highs_info = highs.getInfo();
+
+  HighsStatus return_status = highs.readModel(filename);
+  REQUIRE(return_status == HighsStatus::kOk);
+
+  // Cannot write info since not valid before run()
+  return_status = highs.writeInfo("");
+  REQUIRE(return_status == HighsStatus::kWarning);
+
+  return_status = highs.setOptionValue("solver", "ipm");
+  REQUIRE(return_status == HighsStatus::kOk);
+
+  HighsInfoType highs_info_type;
+  return_status = highs.getInfoType("objective_value", highs_info_type);
+  REQUIRE(return_status == HighsStatus::kError);
+  return_status =
+      highs.getInfoType("objective_function_value", highs_info_type);
+  REQUIRE(return_status == HighsStatus::kOk);
+  REQUIRE(highs_info_type == HighsInfoType::kDouble);
+
+  return_status = highs.getInfoType("iteration_count", highs_info_type);
+  REQUIRE(return_status == HighsStatus::kError);
+  return_status = highs.getInfoType("simplex_iteration_count", highs_info_type);
+  REQUIRE(return_status == HighsStatus::kOk);
+  REQUIRE(highs_info_type == HighsInfoType::kInt);
+
+  return_status = highs.getInfoType("mip_count", highs_info_type);
+  REQUIRE(return_status == HighsStatus::kError);
+  return_status = highs.getInfoType("mip_node_count", highs_info_type);
+  REQUIRE(return_status == HighsStatus::kOk);
+  REQUIRE(highs_info_type == HighsInfoType::kInt64);
+
+  // Info not valid before run()
+  double objective_function_value;
+  return_status =
+      highs.getInfoValue("objective_function_value", objective_function_value);
+  REQUIRE(return_status == HighsStatus::kWarning);
+
+  return_status = highs.run();
+  REQUIRE(return_status == HighsStatus::kOk);
+
+  if (dev_run) {
+    return_status = highs.writeInfo("");
+    REQUIRE(return_status == HighsStatus::kOk);
+  }
+
+  return_status = highs.writeInfo(highs_info_file);
+  REQUIRE(return_status == HighsStatus::kOk);
+
+  // Wrong name for objective
+  return_status =
+      highs.getInfoValue("objective_value", objective_function_value);
+  REQUIRE(return_status == HighsStatus::kError);
+
+  // Right name for objective
+  return_status =
+      highs.getInfoValue("objective_function_value", objective_function_value);
+  REQUIRE(return_status == HighsStatus::kOk);
+
+  if (dev_run)
+    printf("From getInfoValue: objective_function_value = %g\n",
+           objective_function_value);
+
+  HighsInt simplex_iteration_count;
+  // Wrong name for simplex iteration count
+  return_status =
+      highs.getInfoValue("iteration_count", simplex_iteration_count);
+  REQUIRE(return_status == HighsStatus::kError);
+
+  // Right name for simplex iteration count
+  return_status =
+      highs.getInfoValue("simplex_iteration_count", simplex_iteration_count);
+  REQUIRE(return_status == HighsStatus::kOk);
+
+  const HighsModelStatus model_status = highs.getModelStatus();
+  if (dev_run) {
+    printf("From getModelStatus: model_status = %s\n",
+           highs.modelStatusToString(model_status).c_str());
+    printf("From getInfo: objective_function_value = %g\n",
+           highs_info.objective_function_value);
+    printf("From getInfo: ipm_iteration_count = %" HIGHSINT_FORMAT "\n",
+           highs_info.ipm_iteration_count);
+  }
+  std::remove(highs_info_file.c_str());
+
+  highs.resetGlobalScheduler(true);
+}

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

@@ -0,0 +1,226 @@
+#include <cmath>
+
+#include "HCheckConfig.h"
+#include "Highs.h"
+#include "catch.hpp"
+
+// I use dev_run to switch on/off printing and logging used for
+// development of the unit test
+const bool dev_run = false;
+const double inf = kHighsInf;
+
+TEST_CASE("test-analytic-centre", "[highs_ipm]") {
+  //  std::string model = "greenbea.mps";
+  //  std::string model = "adlittle.mps";
+  std::string model = "afiro.mps";
+  std::string filename = std::string(HIGHS_DIR) + "/check/instances/" + model;
+  Highs highs;
+  highs.setOptionValue("output_flag", dev_run);
+  highs.readModel(filename);
+  HighsLp lp = highs.getLp();
+  lp.col_cost_.assign(lp.num_col_, 0);
+  highs.passModel(lp);
+  highs.setOptionValue("run_centring", true);
+  highs.setOptionValue("ipm_optimality_tolerance", 1e-2);
+  HighsStatus run_status = highs.run();
+  REQUIRE(run_status == HighsStatus::kOk);
+
+  highs.resetGlobalScheduler(true);
+}
+
+TEST_CASE("test-analytic-centre-infeasible", "[highs_ipm]") {
+  Highs highs;
+  highs.setOptionValue("output_flag", dev_run);
+  HighsLp lp;
+  lp.num_col_ = 2;
+  lp.num_row_ = 1;
+  lp.col_cost_.assign(lp.num_col_, 0);
+  lp.col_lower_.assign(lp.num_col_, 0);
+  lp.col_upper_.assign(lp.num_col_, inf);
+  lp.row_lower_ = {-inf};
+  lp.row_upper_ = {-1};
+  lp.a_matrix_.start_ = {0, 1, 2};
+  lp.a_matrix_.index_ = {0, 0};
+  lp.a_matrix_.value_ = {1, 1};
+  highs.passModel(lp);
+  highs.setOptionValue("presolve", kHighsOffString);
+  highs.setOptionValue("run_centring", true);
+  highs.setOptionValue("ipm_optimality_tolerance", 1e-2);
+  HighsStatus run_status = highs.run();
+  REQUIRE(run_status == HighsStatus::kOk);
+  REQUIRE(highs.getModelStatus() == HighsModelStatus::kInfeasible);
+
+  highs.resetGlobalScheduler(true);
+}
+
+TEST_CASE("test-analytic-centre-box", "[highs_ipm]") {
+  Highs highs;
+  highs.setOptionValue("output_flag", dev_run);
+  const HighsInt dim = 4;
+  HighsLp lp;
+  lp.num_col_ = dim;
+  lp.col_cost_.assign(dim, 0);
+  lp.col_lower_.assign(dim, -1);
+  lp.col_upper_.assign(dim, 1);
+  highs.passModel(lp);
+
+  std::vector<HighsInt> index = {0, 1};
+  std::vector<double> value = {1, 1};
+
+  const double root2 = std::sqrt(2.0);
+  highs.addRow(-root2, root2, 2, index.data(), value.data());
+  value[1] = -1;
+  highs.addRow(-root2, root2, 2, index.data(), value.data());
+  highs.setOptionValue("run_centring", true);
+  highs.setOptionValue("presolve", kHighsOffString);
+  highs.setOptionValue("ipm_optimality_tolerance", 1e-2);
+  highs.run();
+  const HighsSolution& solution = highs.getSolution();
+  double solution_norm = 0;
+  for (HighsInt ix = 0; ix < dim; ix++) {
+    if (dev_run)
+      printf("Analytic centre solution %d is %g\n", int(ix),
+             solution.col_value[ix]);
+    solution_norm += std::fabs(solution.col_value[ix]);
+  }
+  REQUIRE(solution_norm < 1e-6);
+  if (dev_run) printf("Analytic centre solution norm is %g\n", solution_norm);
+
+  highs.resetGlobalScheduler(true);
+}
+
+TEST_CASE("test-1966", "[highs_ipm]") {
+  // This is the primal-dual infeasible instance
+  // ("PrimalAndDualInfeasible") from OR-Tools that exposed the need
+  // for primal_solution_status and dual_solution_status not to be set
+  // to kSolutionStatusFeasible when there are no primal/dual
+  // infeasiblities, but meaningful primal/dual residual errors
+  //
+  // Takehome: make sure HiGHS unit tests include what failed in unit
+  // tests elsewhere!
+  Highs highs;
+  highs.setOptionValue("output_flag", dev_run);
+  const HighsInfo& info = highs.getInfo();
+  HighsLp lp;
+  lp.sense_ = ObjSense::kMaximize;
+  lp.num_col_ = 2;
+  lp.num_row_ = 2;
+  lp.col_cost_ = {2, -1};
+  lp.col_lower_ = {0, 0};
+  lp.col_upper_ = {kHighsInf, kHighsInf};
+  lp.row_lower_ = {-kHighsInf, 2};
+  lp.row_upper_ = {1, kHighsInf};
+  lp.a_matrix_.start_ = {0, 2, 4};
+  lp.a_matrix_.index_ = {0, 1, 0, 1};
+  lp.a_matrix_.value_ = {1, -1, 1, -1};
+  lp.a_matrix_.format_ = MatrixFormat::kRowwise;
+  highs.passModel(lp);
+  highs.setOptionValue("presolve", kHighsOffString);
+  //  if (dev_run) highs.writeModel("");
+  HighsModelStatus require_model_status = HighsModelStatus::kNotset;
+  int to_k = 2;
+#ifdef HIPO
+  // to_k = 3;
+#endif
+  for (int k = 0; k < to_k; k++) {
+    if (k == 0) {
+      highs.setOptionValue("solver", kPdlpString);
+      if (dev_run) printf("Solving with PDLP\n");
+      require_model_status = HighsModelStatus::kUnboundedOrInfeasible;
+    } else if (k == 1) {
+      highs.setOptionValue("solver", kIpxString);
+      if (dev_run) printf("Solving with IPX\n");
+      require_model_status = HighsModelStatus::kInfeasible;
+    } else {
+      highs.setOptionValue("solver", kHipoString);
+      if (dev_run) printf("Solving with HiPO\n");
+      require_model_status = HighsModelStatus::kInfeasible;
+    }
+    highs.run();
+    REQUIRE(info.primal_solution_status != kSolutionStatusFeasible);
+    REQUIRE(info.dual_solution_status != kSolutionStatusFeasible);
+    REQUIRE(highs.getModelStatus() == require_model_status);
+    if (dev_run) {
+      // Nice illustration that IPX
+      //
+      // * identifies "infeasible"
+      //
+      // * gets no primal or dual infeasibilies
+      //
+      // * gets primal and dual residual errors
+      //
+      // whereas PDLP
+      //
+      // * identifies only "infeasible or unbounded"
+      //
+      // * gets primal infeasibilies and no primal residual errors
+      //
+      // * gets no primal infeasibilies but primal residual errors
+      //
+      //    highs.writeSolution("", kSolutionStylePretty);
+      printf("Primal solution status = %d\n", int(info.primal_solution_status));
+      printf("Dual solution status = %d\n", int(info.dual_solution_status));
+      printf("Num primal infeasibilities   = %d\n",
+             int(info.num_primal_infeasibilities));
+      printf("Max primal infeasibility     = %g\n",
+             info.max_primal_infeasibility);
+      printf("Sum primal infeasibilities   = %g\n",
+             info.sum_primal_infeasibilities);
+      printf("Num   dual infeasibilities   = %d\n",
+             int(info.num_dual_infeasibilities));
+      printf("Max   dual infeasibility     = %g\n",
+             info.max_dual_infeasibility);
+      printf("Sum   dual infeasibilities   = %g\n",
+             info.sum_dual_infeasibilities);
+      printf("Num   primal residual errors = %d\n",
+             int(info.num_primal_residual_errors));
+      printf("Max   primal residual error  = %g\n",
+             info.max_primal_residual_error);
+      printf("Num   dual residual errors   = %d\n",
+             int(info.num_dual_residual_errors));
+      printf("Max   dual residual error    = %g\n",
+             info.max_dual_residual_error);
+      printf("Primal-dual objective error  = %g\n",
+             info.primal_dual_objective_error);
+    }
+    highs.clearSolver();
+  }
+  highs.resetGlobalScheduler(true);
+}
+
+TEST_CASE("test-2087", "[highs_ipm]") {
+  // Make sure that presolve is performed when re-solving using IPM,
+  // since optimal basis cannot be used, and ensure that the offset is
+  // used in IPX
+  Highs h;
+  h.setOptionValue("output_flag", dev_run);
+  // Use shell since it yields an offset after presolve
+  std::string model = "shell.mps";
+  std::string filename = std::string(HIGHS_DIR) + "/check/instances/" + model;
+  h.readModel(filename);
+
+  h.setOptionValue("solver", kIpmString);
+  h.run();
+  const HighsInt first_ipm_iteration_count = h.getInfo().ipm_iteration_count;
+
+  h.run();
+  REQUIRE(first_ipm_iteration_count == h.getInfo().ipm_iteration_count);
+
+  h.resetGlobalScheduler(true);
+}
+
+TEST_CASE("test-2527", "[highs_ipm]") {
+  std::string filename =
+      std::string(HIGHS_DIR) + "/check/instances/primal1.mps";
+  Highs h;
+  h.setOptionValue("output_flag", dev_run);
+  REQUIRE(h.readModel(filename) == HighsStatus::kOk);
+  HighsLp lp = h.getLp();
+  lp.col_cost_.assign(lp.num_col_, 0);
+  REQUIRE(h.passModel(lp) == HighsStatus::kOk);
+  h.setOptionValue("solver", kIpmString);
+  h.setOptionValue("presolve", kHighsOffString);
+  REQUIRE(h.run() == HighsStatus::kOk);
+
+  h.resetGlobalScheduler(true);
+}

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

@@ -0,0 +1,96 @@
+#include "HCheckConfig.h"
+#include "Highs.h"
+#include "catch.hpp"
+#include "ipm/ipx/ipx_status.h"
+#include "ipm/ipx/lp_solver.h"
+#include "lp_data/HConst.h"
+#include "lp_data/HighsCallback.h"
+#include "lp_data/HighsLp.h"
+#include "lp_data/HighsStatus.h"
+#include "parallel/HighsParallel.h"
+
+// Example for using IPX from its C++ interface. The program solves the Netlib
+// problem afiro.
+
+#include <cmath>
+#include <iostream>
+
+#include "ipm/ipx/lp_solver.h"
+
+const bool dev_run = false;
+
+using Int = ipxint;
+
+constexpr HighsInt num_var = 12;
+constexpr HighsInt num_constr = 9;
+const double offset = 0;
+const double obj[] = {-0.2194, 0.0, 0.0,   0.0,     0.0, 0.0,
+                      0.0,     0.0, -0.32, -0.5564, 0.6, -0.48};
+const double lb[num_var] = {0.0};
+const double ub[] = {80.0,     283.303,  283.303, 312.813, 349.187, INFINITY,
+                     INFINITY, INFINITY, 57.201,  500.0,   500.501, 357.501};
+// Constraint matrix in CSC format with 0-based indexing.
+const HighsInt Ap[] = {0, 2, 6, 10, 14, 18, 20, 22, 24, 26, 28, 30, 32};
+const HighsInt Ai[] = {0, 5, 1, 6, 7, 8, 2, 6, 7, 8, 3, 6, 7, 8, 4, 6,
+                       7, 8, 1, 2, 2, 3, 2, 4, 0, 6, 0, 5, 2, 5, 5, 7};
+const double Ax[] = {-1.0,      0.301,   1.0,   -1.0, 0.301, 1.06,    1.0,
+                     -1.0,      0.313,   1.06,  1.0,  -1.0,  0.313,   0.96,
+                     1.0,       -1.0,    0.326, 0.86, -1.0,  0.99078, 1.00922,
+                     -1.0,      1.01802, -1.0,  1.4,  1.0,   0.109,   -1.0,
+                     -0.419111, 1.0,     1.4,   -1.0};
+const double rhs[] = {0.0, 80.0, 0.0, 0.0, 0.0, 0.0, 0.0, 44.0, 300.0};
+const char constr_type[] = {'<', '<', '=', '<', '<', '=', '<', '<', '<'};
+
+TEST_CASE("test-ipx", "[highs_ipx]") {
+  ipx::LpSolver lps;
+  ipx::Parameters parameters;
+  if (!dev_run) parameters.display = 0;
+  parameters.highs_logging = false;
+  parameters.timeless_log = false;
+  lps.SetParameters(parameters);
+
+  // Solve the LP.
+  Int load_status = lps.LoadModel(num_var, offset, obj, lb, ub, num_constr, Ap,
+                                  Ai, Ax, rhs, constr_type);
+  REQUIRE(load_status == 0);
+
+  highs::parallel::initialize_scheduler();
+
+  // set empty callback to avoid issues
+  HighsCallback callback(nullptr);
+  lps.SetCallback(&callback);
+
+  Int status = lps.Solve();
+  bool is_solved = status == IPX_STATUS_solved;
+  REQUIRE(is_solved);
+
+  // Get solver and solution information.
+  ipx::Info info = lps.GetInfo();
+
+  // Get the interior solution (available if IPM was started).
+  double x[num_var], xl[num_var], xu[num_var], slack[num_constr];
+  double y[num_constr], zl[num_var], zu[num_var];
+  lps.GetInteriorSolution(x, xl, xu, slack, y, zl, zu);
+
+  REQUIRE(fabs(x[11] - 339.9) < 1.0);
+  REQUIRE(fabs(xl[11] - 339.94) < 1.0);
+  REQUIRE(fabs(xu[11] - 17.55) < 1.0);
+  REQUIRE(fabs(slack[8] - 234.76) < 1.0);
+  REQUIRE(fabs(y[8]) < 1.0);
+  REQUIRE(fabs(zl[11]) < 1.0);
+  REQUIRE(fabs(zu[11]) < 1.0);
+
+  // Get the basic solution (available if crossover terminated without error).
+  double ipx_col_value[num_var], ipx_row_value[num_constr];
+  double ipx_row_dual[num_constr], ipx_col_dual[num_var];
+  Int ipx_row_status[num_constr], ipx_col_status[num_var];
+  lps.GetBasicSolution(ipx_col_value, ipx_row_value, ipx_row_dual, ipx_col_dual,
+                       ipx_row_status, ipx_col_status);
+  REQUIRE(fabs(ipx_col_value[11] - 339.9) < 1);
+
+  (void)(info);  // surpress unused variable.
+
+  // hack to reset global scheduler
+  Highs h;
+  h.resetGlobalScheduler(true);
+}

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

@@ -0,0 +1,22 @@
+#include "HCheckConfig.h"
+#include "Highs.h"
+#include "catch.hpp"
+#include "io/filereaderlp/reader.hpp"
+
+const bool dev_run = false;
+
+TEST_CASE("lp-file-format-quad-no-space", "[LpFileFormat]") {
+  std::string filename = std::string(HIGHS_DIR) + "/check/instances/qcqp.lp";
+
+  // HiGHS cannot handle quadratic constraints as there are in qcqp.lp
+
+  // Test that filereaderlp does not throw an exception
+  REQUIRE_NOTHROW(readinstance(filename));
+
+  // Test that HiGHS returns an error when passes a QCQP problem
+  Highs highs;
+  highs.setOptionValue("output_flag", dev_run);
+  REQUIRE(highs.readModel(filename) == HighsStatus::kError);
+
+  // todo: read the coefficients/variables off the highs model
+}

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

@@ -0,0 +1,69 @@
+#include <cstdio>
+
+#include "HCheckConfig.h"
+#include "Highs.h"
+#include "catch.hpp"
+
+const bool dev_run = false;
+
+TEST_CASE("logging", "[highs_logging]") {
+  const std::string test_name = Catch::getResultCapture().getCurrentTestName();
+  const std::string log_file = test_name + ".log";
+  std::string model;
+  std::string model_file;
+  HighsStatus return_status;
+
+  model = "avgas";
+  model_file = std::string(HIGHS_DIR) + "/check/instances/" + model + ".mps";
+
+  Highs highs;
+  if (!dev_run) highs.setOptionValue("output_flag", false);
+  // By default, initial output is just to to console
+  return_status = highs.readModel(model_file);
+  REQUIRE(return_status == HighsStatus::kOk);
+
+  // Setting log_file to a non-empty string opens the file
+  highs.setOptionValue(kLogFileString, log_file);
+
+  return_status = highs.run();
+  REQUIRE(return_status == HighsStatus::kOk);
+
+  // Setting log_file to an empty string closes the file and prevents
+  // further logging to file
+  highs.setOptionValue(kLogFileString, "");
+
+  // Setting log_to_console false suppresses logging to console
+  highs.setOptionValue("log_to_console", false);
+  // Writing out the the info should puroduce no output to console or file
+  highs.run();
+
+  // Setting log_to_console true restores logging to console
+  highs.setOptionValue("log_to_console", true);
+  if (dev_run) printf("After setting log_to_console = true\n");
+  // Writing out the the info should puroduce output to console
+  highs.run();
+
+  if (!dev_run) std::remove(log_file.c_str());
+
+  highs.resetGlobalScheduler(true);
+}
+
+TEST_CASE("no-logging", "[highs_logging]") {
+  std::string model;
+  std::string model_file;
+  std::string log_file;
+  HighsStatus return_status;
+
+  model = "adlittle";
+  model_file = std::string(HIGHS_DIR) + "/check/instances/" + model + ".mps";
+
+  Highs highs;
+  if (!dev_run) highs.setOptionValue("output_flag", false);
+  return_status = highs.readModel(model_file);
+  REQUIRE(return_status == HighsStatus::kOk);
+
+  return_status = highs.run();
+  REQUIRE(return_status == HighsStatus::kOk);
+
+  highs.resetGlobalScheduler(true);
+}