lpsolver 0.1.0 → 0.2.1

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

@@ -0,0 +1,277 @@
+#include "HCheckConfig.h"
+
+#if 0
+#include <omp.h>
+#endif
+
+#include <iostream>
+
+#include "catch.hpp"
+#include "matrix_multiplication.hpp"
+#include "parallel/HighsParallel.h"
+
+using namespace highs;
+
+const int numThreads = (std::thread::hardware_concurrency() + 1) / 2;
+const bool dev_run = false;
+
+int64_t fib_sequential(const int64_t n) {
+  if (n <= 1) return 1;
+  return fib_sequential(n - 1) + fib_sequential(n - 2);
+}
+
+int64_t fib(const int64_t n) {
+  if (n <= 20) return fib_sequential(n);
+
+  int64_t n1;
+  parallel::spawn([&]() {
+    n1 = fib(n - 1);
+    TSAN_ANNOTATE_HAPPENS_BEFORE(&n1);
+  });
+
+  int64_t n2 = fib(n - 2);
+  TSAN_ANNOTATE_HAPPENS_BEFORE(&n2);
+
+  parallel::sync();
+
+  TSAN_ANNOTATE_HAPPENS_AFTER(&n1);
+  TSAN_ANNOTATE_HAPPENS_AFTER(&n2);
+  // printf("fib(%ld) = %ld + %ld = %ld\n", n, n1, n2, n1 + n2);
+  return n1 + n2;
+}
+#if 0
+int64_t fib_omp(const int64_t n) {
+  if (n <= 20) return fib_sequential(n);
+
+  int64_t n1;
+#pragma omp task shared(n1)
+  n1 = fib_omp(n - 1);
+
+  int64_t n2 = fib_omp(n - 2);
+
+#pragma omp taskwait
+
+  // printf("fib(%ld) = %ld + %ld = %ld\n", n, n1, n2, n1 + n2);
+  return n1 + n2;
+}
+
+// matrix_multiplication_omp
+// reference: https://computing.llnl.gov/tutorials/openMP/samples/C/omp_mm.c
+void matrix_multiplication_omp(unsigned nthreads) {
+  omp_set_num_threads(nthreads);
+
+  int i, j, k;
+
+#pragma omp parallel for private(i, j)
+  for (i = 0; i < N; ++i) {
+    for (j = 0; j < N; j++) {
+      a[i][j] = i + j;
+    }
+  }
+
+#pragma omp parallel for private(i, j)
+  for (i = 0; i < N; ++i) {
+    for (j = 0; j < N; j++) {
+      b[i][j] = i * j;
+    }
+  }
+
+#pragma omp parallel for private(i, j)
+  for (i = 0; i < N; ++i) {
+    for (j = 0; j < N; j++) {
+      c[i][j] = 0;
+    }
+  }
+
+#pragma omp parallel for private(i, j, k)
+  for (i = 0; i < N; ++i) {
+    for (j = 0; j < N; j++) {
+      for (k = 0; k < N; k++) {
+        c[i][j] += a[i][k] * b[k][j];
+      }
+    }
+  }
+
+  // int edge;
+
+  //#pragma omp parallel shared(a, b, c, nthreads) private(i, j, k)
+  //{
+  //  #pragma omp single private(i, j)
+  //  for(i = 0; i<N; i++) {
+  //    #pragma omp task private(j) firstprivate(i) depend(out: edge)
+  //    for (j=0; j<N; j++)
+  //      a[i][j]= i+j;
+  //  }
+
+  //  #pragma omp single private(i, j)
+  //  for(i = 0; i<N; i++) {
+  //    #pragma omp task private(j) firstprivate(i) depend(out: edge)
+  //    for (j=0; j<N; j++)
+  //      b[i][j]= i*j;
+  //  }
+
+  //  #pragma omp single private(i, j)
+  //  for(i = 0; i<N; i++) {
+  //    #pragma omp task private(j) firstprivate(i) depend(out: edge)
+  //    for (j=0; j<N; j++)
+  //      c[i][j]= 0;
+  //  }
+
+  //  #pragma omp single private(i, j)
+  //  for(i = 0; i<N; i++) {
+  //    #pragma omp task private(j, k) firstprivate(i) depend(in: edge)
+  //    for(j=0; j<N; j++) {
+  //      for (k=0; k<N; k++) {
+  //        c[i][j] += a[i][k] * b[k][j];
+  //      }
+  //    }
+  //  }
+  //}
+
+  // std::cout << reduce_sum() << std::endl;
+}
+#endif
+void matrix_multiplication_highs(unsigned nthreads) {
+  // #pragma omp parallel for private(i, j)
+  parallel::for_each(0, N, [&](HighsInt start, HighsInt end) {
+    for (int i = start; i < end; ++i) {
+      for (int j = 0; j < N; j++) {
+        a[i][j] = i + j;
+      }
+    }
+  });
+
+  parallel::for_each(0, N, [&](HighsInt start, HighsInt end) {
+    for (int i = start; i < end; ++i) {
+      for (int j = 0; j < N; j++) {
+        b[i][j] = i * j;
+      }
+    }
+  });
+
+  parallel::for_each(0, N, [&](HighsInt start, HighsInt end) {
+    for (int i = start; i < end; ++i) {
+      for (int j = 0; j < N; j++) {
+        c[i][j] = 0;
+      }
+    }
+  });
+
+  parallel::for_each(0, N, [&](HighsInt start, HighsInt end) {
+    for (int i = start; i < end; ++i) {
+      for (int j = 0; j < N; j++) {
+        for (int k = 0; k < N; k++) {
+          c[i][j] += a[i][k] * b[k][j];
+        }
+      }
+    }
+  });
+}
+#if 0
+std::chrono::microseconds measure_time_omp(unsigned num_threads) {
+  auto beg = std::chrono::high_resolution_clock::now();
+  matrix_multiplication_omp(num_threads);
+  auto end = std::chrono::high_resolution_clock::now();
+  return std::chrono::duration_cast<std::chrono::microseconds>(end - beg);
+}
+#endif
+std::chrono::microseconds measure_time_highs(unsigned num_threads) {
+  auto beg = std::chrono::high_resolution_clock::now();
+  matrix_multiplication_highs(num_threads);
+  auto end = std::chrono::high_resolution_clock::now();
+  return std::chrono::duration_cast<std::chrono::microseconds>(end - beg);
+}
+
+int N = 0;
+double **a = nullptr, **b = nullptr, **c = nullptr;
+
+void matrix_multiplication(const std::string& model, const unsigned num_threads,
+                           const unsigned num_rounds) {
+  if (dev_run)
+    std::cout << std::setw(12) << "size" << std::setw(12) << "runtime"
+              << std::endl;
+
+  for (int i = 128; i <= 512; i += 128) {
+    N = i;
+
+    allocate_matrix();
+
+    double runtime{0.0};
+
+    for (unsigned j = 0; j < num_rounds; ++j) {
+#if 0
+      if (model == "highs") {
+        runtime += measure_time_highs(num_threads).count();
+      } else if (model == "omp") {
+        runtime += measure_time_omp(num_threads).count();
+      } else
+        assert(false);
+#else
+      runtime += measure_time_highs(num_threads).count();
+#endif
+    }
+
+    if (dev_run)
+      std::cout << std::setw(12) << N << std::setw(12)
+                << runtime / num_rounds / 1e3 << std::endl;
+
+    deallocate_matrix();
+  }
+}
+
+TEST_CASE("MatrixMultHighs", "[parallel]") {
+  HighsTaskExecutor::shutdown();
+  parallel::initialize_scheduler(numThreads);
+  if (dev_run) std::cout << "\nhighs workstealing for loop:" << std::endl;
+  matrix_multiplication("highs", parallel::num_threads(), 1);
+  HighsTaskExecutor::shutdown();
+}
+
+TEST_CASE("FibonacciTasksHighs", "[parallel]") {
+  HighsTaskExecutor::shutdown();
+  auto beg = std::chrono::high_resolution_clock::now();
+  parallel::initialize_scheduler(numThreads);
+  int64_t result = fib(41);
+  auto end = std::chrono::high_resolution_clock::now();
+
+  if (dev_run)
+    std::cout << "time elapsed for fib(41) with HiGHS work stealing: "
+              << (std::chrono::duration_cast<std::chrono::microseconds>(end -
+                                                                        beg)
+                      .count() /
+                  1e3)
+              << "ms" << std::endl;
+
+  // REQUIRE(result == 4807526976);
+  // REQUIRE(result == 20365011074);
+  // fib 41
+  REQUIRE(result == 267914296);
+  HighsTaskExecutor::shutdown();
+}
+
+#if 0
+TEST_CASE("MatrixMultOmp", "[parallel]") {
+  if (dev_run)
+    std::cout << "\nomp for loop:" << std::endl;
+  matrix_multiplication("omp", numThreads, 1);
+}
+TEST_CASE("FibonacciTasksOmp", "[parallel]") {
+  int64_t result;
+  auto beg = std::chrono::high_resolution_clock::now();
+#pragma omp parallel num_threads(numThreads)
+  {
+#pragma omp single
+    { result = fib_omp(41); }
+  }
+  auto end = std::chrono::high_resolution_clock::now();
+
+  if (dev_run)
+    std::cout << "time elapsed for fib(41) with omp tasks: "
+	      << (std::chrono::duration_cast<std::chrono::microseconds>(end - beg)
+		  .count() / 1e3)
+	      << "ms" << std::endl;
+
+  // fib 41
+  REQUIRE(result == 267914296);
+}
+#endif

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

@@ -0,0 +1,109 @@
+#include <numeric>
+
+#include "HCheckConfig.h"
+#include "catch.hpp"
+#include "util/HighsRandom.h"
+#include "util/HighsRbTree.h"
+
+using namespace highs;
+
+struct Node {
+  HighsInt key;
+  RbTreeLinks<HighsInt> links;
+};
+
+class MyRbTree;
+
+namespace highs {
+template <>
+struct RbTreeTraits<MyRbTree> {
+  using KeyType = HighsInt;
+  using LinkType = HighsInt;
+};
+}  // namespace highs
+
+class MyRbTree : public RbTree<MyRbTree> {
+ public:
+  HighsInt root = -1;
+  std::vector<Node> nodes;
+
+  MyRbTree() : RbTree<MyRbTree>(root) {}
+
+  RbTreeLinks<HighsInt>& getRbTreeLinks(HighsInt node) {
+    return nodes[node].links;
+  }
+  const RbTreeLinks<HighsInt>& getRbTreeLinks(HighsInt node) const {
+    return nodes[node].links;
+  }
+  HighsInt getKey(HighsInt node) const { return nodes[node].key; }
+
+  bool insert(HighsInt x) {
+    std::pair<HighsInt, bool> p = find(x);
+
+    if (p.second) return false;
+
+    HighsInt newNode = nodes.size();
+    nodes.emplace_back();
+    nodes.back().key = x;
+    link(newNode, p.first);
+    return true;
+  }
+
+  void erase(HighsInt node) { unlink(node); }
+
+  bool contains(HighsInt x) { return find(x).second; }
+};
+
+static void checkRbTree(MyRbTree& tree, HighsInt* expectedKeys,
+                        HighsInt numExpectedKeys) {
+  std::vector<HighsInt> keys;
+  keys.reserve(numExpectedKeys);
+  if (tree.root != -1) REQUIRE(tree.nodes[tree.root].links.isBlack());
+
+  HighsInt x = tree.first();
+  while (x != -1) {
+    keys.push_back(tree.nodes[x].key);
+    if (tree.nodes[x].links.isRed()) {
+      HighsInt lChild = tree.nodes[x].links.child[0];
+      HighsInt rChild = tree.nodes[x].links.child[1];
+      if (lChild != -1) REQUIRE(tree.nodes[lChild].links.isBlack());
+      if (rChild != -1) REQUIRE(tree.nodes[rChild].links.isBlack());
+    }
+    x = tree.successor(x);
+    REQUIRE((HighsInt)keys.size() <= numExpectedKeys);
+  }
+
+  REQUIRE((HighsInt)keys.size() == numExpectedKeys);
+  std::sort(expectedKeys, expectedKeys + numExpectedKeys);
+  bool isOk = std::equal(keys.begin(), keys.end(), expectedKeys);
+  REQUIRE(isOk);
+}
+
+TEST_CASE("HighsRbTree", "[util]") {
+  std::vector<HighsInt> keys;
+  keys.resize(1000);
+  std::iota(keys.begin(), keys.end(), 0);
+
+  HighsRandom rand;
+  rand.shuffle(keys.data(), keys.size());
+  MyRbTree rbTree;
+
+  for (size_t i = 0; i < keys.size(); ++i) {
+    HighsInt x = keys[i];
+    bool inserted = rbTree.insert(x);
+    REQUIRE(inserted);
+    checkRbTree(rbTree, keys.data(), i + 1);
+  }
+
+  // randomly delete half of the elements and check the tree after each deletion
+
+  for (size_t i = keys.size() - 1; i > keys.size() / 2; --i) {
+    HighsInt k = rand.integer(i + 1);
+    std::swap(keys[k], keys[i]);
+    HighsInt x = keys[i];
+    std::pair<HighsInt, bool> node = rbTree.find(x);
+    REQUIRE(node.second);
+    rbTree.erase(node.first);
+    checkRbTree(rbTree, keys.data(), i);
+  }
+}

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

@@ -0,0 +1,126 @@
+#include <algorithm>
+#include <cassert>
+
+#include "HCheckConfig.h"
+#include "Highs.h"
+#include "catch.hpp"
+
+const bool dev_run = false;
+bool infNormDiffOk(const std::vector<double> x0, const std::vector<double> x1) {
+  assert(x1.size() >= x0.size());
+  double norm_diff = 0;
+  for (HighsInt ix = 0; ix < HighsInt(x0.size()); ix++)
+    norm_diff = std::max(std::abs(x0[ix] - x1[ix]), norm_diff);
+  return norm_diff < 1e-12;
+}
+
+// No commas in test case name.
+TEST_CASE("Sparse-matrix-products", "[highs_sparse_matrix]") {
+  Highs highs;
+  HighsRandom random;
+  for (int k = 0; k < 2; k++) {
+    std::string filename;
+    if (k == 0) {
+      filename = std::string(HIGHS_DIR) + "/check/instances/avgas.mps";
+    } else {
+      filename = std::string(HIGHS_DIR) + "/check/instances/adlittle.mps";
+    }
+    if (!dev_run) highs.setOptionValue("output_flag", false);
+    highs.readModel(filename);
+    HighsSparseMatrix matrix = highs.getLp().a_matrix_;
+    REQUIRE(matrix.isColwise());
+    if (k == 0) {
+      REQUIRE(matrix.num_row_ > matrix.num_col_);
+    } else {
+      REQUIRE(matrix.num_col_ > matrix.num_row_);
+    }
+    // Set up x and y for computing Ax and A^Ty
+    std::vector<double> x;
+    std::vector<double> y;
+    for (HighsInt ix = 0; ix < matrix.num_col_; ix++)
+      x.push_back(random.fraction());
+    for (HighsInt ix = 0; ix < matrix.num_row_; ix++)
+      y.push_back(random.fraction());
+    std::vector<double> at_y;
+    std::vector<double> a_x;
+    // Form Ax
+    std::vector<double> exact_a_x;
+    matrix.product(exact_a_x, x);
+    // Form A^Ty
+    std::vector<double> exact_at_y;
+    matrix.productTranspose(exact_at_y, y);
+    // Now repeat with matrix rowwise
+    matrix.ensureRowwise();
+
+    matrix.product(a_x, x);
+    REQUIRE(infNormDiffOk(a_x, exact_a_x));
+
+    matrix.productTranspose(at_y, y);
+    REQUIRE(infNormDiffOk(at_y, exact_at_y));
+
+    // Now test the quad precision products
+    matrix.ensureColwise();
+
+    matrix.productQuad(a_x, x);
+    REQUIRE(infNormDiffOk(a_x, exact_a_x));
+
+    std::vector<HighsInt> at_y_index;
+    std::vector<double> at_y_value;
+    HVector y_HVector;
+    y_HVector.setup(matrix.num_row_);
+    y_HVector.array = y;
+    matrix.productTransposeQuad(at_y_value, at_y_index, y_HVector);
+    at_y.assign(matrix.num_col_, 0);
+    for (HighsInt ix = 0; ix < int(at_y_index.size()); ix++)
+      at_y[at_y_index[ix]] = at_y_value[ix];
+    REQUIRE(infNormDiffOk(at_y, exact_at_y));
+
+    // Now repeat with matrix rowwise
+    matrix.ensureRowwise();
+    matrix.productQuad(a_x, x);
+    REQUIRE(infNormDiffOk(a_x, exact_a_x));
+
+    at_y_index.clear();
+    at_y_value.clear();
+    matrix.productTransposeQuad(at_y_value, at_y_index, y_HVector);
+    at_y.assign(matrix.num_col_, 0);
+    for (HighsInt ix = 0; ix < int(at_y_index.size()); ix++)
+      at_y[at_y_index[ix]] = at_y_value[ix];
+    REQUIRE(infNormDiffOk(at_y, exact_at_y));
+
+    // Now test y := y + alpha Ax and x := x + alphaA^Ty
+    //
+    // Test y := y + alpha Ax
+    const double alpha = random.fraction();
+
+    // First column-wise
+    matrix.ensureColwise();
+    for (HighsInt orientation = 0; orientation < 2; orientation++) {
+      std::vector<double> initial_y;
+      for (HighsInt ix = 0; ix < matrix.num_row_; ix++) initial_y.push_back(1);
+      std::vector<double> exact_result;
+      for (HighsInt ix = 0; ix < matrix.num_row_; ix++)
+        exact_result.push_back(initial_y[ix] + alpha * exact_a_x[ix]);
+
+      std::vector<double> result = initial_y;
+      matrix.alphaProductPlusY(alpha, x, result);
+      REQUIRE(infNormDiffOk(result, exact_result));
+
+      // Test x := x + alphaA^Ty
+      std::vector<double> initial_x;
+      for (HighsInt ix = 0; ix < matrix.num_col_; ix++) initial_x.push_back(1);
+      exact_result.clear();
+      for (HighsInt ix = 0; ix < matrix.num_col_; ix++)
+        exact_result.push_back(initial_x[ix] + alpha * exact_at_y[ix]);
+
+      result = initial_x;
+      matrix.alphaProductPlusY(alpha, y, result, true);
+      REQUIRE(infNormDiffOk(result, exact_result));
+
+      // Switch to row-wise for second pass
+      matrix.ensureRowwise();
+    }
+
+    highs.clear();
+  }
+}

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

@@ -0,0 +1,61 @@
+#include <cassert>
+#include <sstream>
+
+#include "HCheckConfig.h"
+#include "Highs.h"
+#include "catch.hpp"
+
+const bool dev_run = false;
+
+// No commas in test case name.
+TEST_CASE("HighsVersion", "[highs_version]") {
+  std::string version = std::string(highsVersion());
+  const HighsInt major = highsVersionMajor();
+  const HighsInt minor = highsVersionMinor();
+  const HighsInt patch = highsVersionPatch();
+  const std::string compilation = highsCompilationDate();
+  const std::string githash = std::string(highsGithash());
+  std::stringstream ss;
+  ss << major << "." << minor << "." << patch;
+  std::string local_version = ss.str();
+  if (dev_run) {
+    printf("HiGHS version: %s\n", version.c_str());
+    printf("HiGHS major version %d\n", int(major));
+    printf("HiGHS minor version %d\n", int(minor));
+    printf("HiGHS patch version %d\n", int(patch));
+    printf("HiGHS githash: %s\n", githash.c_str());
+    // Compilation date is deprecated, but make sure that the
+    // deprecated method is still tested.
+    printf("HiGHS compilation date: %s\n", compilation.c_str());
+    printf("HiGHS local version: %s\n", local_version.c_str());
+  }
+  REQUIRE(major == HIGHS_VERSION_MAJOR);
+  REQUIRE(minor == HIGHS_VERSION_MINOR);
+  REQUIRE(patch == HIGHS_VERSION_PATCH);
+  REQUIRE(githash == std::string(HIGHS_GITHASH));
+  REQUIRE(version == local_version);
+  // Check that the corresponding methods
+  Highs highs;
+  const std::string version0 = highs.version();
+  REQUIRE(version0 == version);
+  const HighsInt major0 = highs.versionMajor();
+  REQUIRE(major0 == major);
+  const HighsInt minor0 = highs.versionMinor();
+  REQUIRE(minor0 == minor);
+  const HighsInt patch0 = highs.versionPatch();
+  REQUIRE(patch0 == patch);
+  const std::string githash0 = highs.githash();
+  REQUIRE(githash0 == githash);
+  const std::string compilation0 = highs.compilationDate();
+  REQUIRE(compilation == compilation);
+}
+
+TEST_CASE("sizeof-highs-int", "[highs_version]") {
+  Highs highs;
+  HighsInt sizeof_highs_int = highs.getSizeofHighsInt();
+#ifdef HIGHSINT64
+  REQUIRE(sizeof_highs_int == 8);
+#else
+  REQUIRE(sizeof_highs_int == 4);
+#endif
+}

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

@@ -0,0 +1,122 @@
+#include <cmath>
+#include <iostream>
+#include <vector>
+
+#include "HCheckConfig.h"
+#include "Highs.h"
+#include "catch.hpp"
+#include "io/Filereader.h"
+#include "ipm/hipo/ipm/Solver.h"
+#include "ipm/hipo/ipm/Status.h"
+#include "lp_data/HighsCallback.h"
+#include "parallel/HighsParallel.h"
+
+const bool dev_run = false;
+
+void runHipoTest(
+    Highs& highs, const std::string& model, const double expected_obj,
+    const HighsModelStatus& expected_model_status = HighsModelStatus::kOptimal,
+    const std::string& presolve = kHighsOnString) {
+  highs.setOptionValue("output_flag", dev_run);
+  highs.setOptionValue("solver", kHipoString);
+  highs.setOptionValue("timeless_log", kHighsOnString);
+  highs.setOptionValue("presolve", presolve);
+
+  std::string filename = std::string(HIGHS_DIR) + "/check/instances/" + model;
+  highs.readModel(filename);
+
+  HighsStatus status = highs.run();
+  REQUIRE(status == HighsStatus::kOk);
+  REQUIRE(highs.getModelStatus() == expected_model_status);
+
+  if (expected_model_status == HighsModelStatus::kOptimal) {
+    const double actual_obj = highs.getObjectiveValue();
+    REQUIRE(std::abs(actual_obj - expected_obj) / std::abs(expected_obj) <
+            1e-4);
+  }
+}
+
+TEST_CASE("test-hipo-afiro", "[highs_hipo]") {
+  Highs highs;
+  runHipoTest(highs, "afiro.mps", -464.753);
+  highs.resetGlobalScheduler(true);
+}
+
+TEST_CASE("test-hipo-deterministic", "[highs_hipo]") {
+  // Test that hipo finds the exact same solution if run twice
+
+  std::string model = "80bau3b.mps";
+  const double expected_obj = 9.8722e5;
+
+  HighsInt iter_1, iter_2;
+  HighsSolution solution_1, solution_2;
+
+  Highs highs;
+  highs.setOptionValue(kRunCrossoverString, kHighsOffString);
+
+  runHipoTest(highs, model, expected_obj);
+  solution_1 = highs.getSolution();
+  iter_1 = highs.getInfo().ipm_iteration_count;
+
+  runHipoTest(highs, model, expected_obj);
+  solution_2 = highs.getSolution();
+  iter_2 = highs.getInfo().ipm_iteration_count;
+
+  REQUIRE(iter_1 == iter_2);
+  REQUIRE(solution_1.value_valid == solution_2.value_valid);
+  REQUIRE(solution_1.dual_valid == solution_2.dual_valid);
+  REQUIRE(solution_1.col_value == solution_2.col_value);
+  REQUIRE(solution_1.row_value == solution_2.row_value);
+  REQUIRE(solution_1.col_dual == solution_2.col_dual);
+  REQUIRE(solution_1.row_dual == solution_2.row_dual);
+}
+
+TEST_CASE("test-hipo-options", "[highs_hipo]") {
+  // test all combinations of options for hipo
+
+  std::string model = "adlittle.mps";
+  const double expected_obj = 2.2549e5;
+  Highs highs;
+
+  std::vector<std::string> orders = {kHighsChooseString, kHipoMetisString,
+                                     kHipoAmdString, kHipoRcmString};
+  std::vector<std::string> systems = {kHighsChooseString, kHipoNormalEqString,
+                                      kHipoAugmentedString};
+  std::vector<std::string> parallels = {kHighsOnString, kHighsOffString,
+                                        kHighsChooseString};
+  std::vector<std::string> partypes = {kHipoTreeString, kHipoNodeString,
+                                       kHipoBothString};
+
+  for (auto& order : orders) {
+    highs.setOptionValue(kHipoOrderingString, order);
+    for (auto& system : systems) {
+      highs.setOptionValue(kHipoSystemString, system);
+      for (auto& parallel : parallels) {
+        highs.setOptionValue(kParallelString, parallel);
+        for (auto& partype : partypes) {
+          highs.setOptionValue(kHipoParallelString, partype);
+          runHipoTest(highs, model, expected_obj);
+        }
+      }
+    }
+  }
+
+  highs.resetGlobalScheduler(true);
+}
+
+TEST_CASE("test-hipo-qp", "[highs_hipo]") {
+  Highs highs;
+  runHipoTest(highs, "qptestnw.lp", -6.4500);
+  runHipoTest(highs, "qjh.lp", -5.2500);
+  runHipoTest(highs, "primal1.mps", -3.501296e-2);
+  highs.resetGlobalScheduler(true);
+}
+
+TEST_CASE("test-hipo-infeas", "[highs)hipo]") {
+  const HighsModelStatus expected_status = HighsModelStatus::kInfeasible;
+  Highs highs;
+  runHipoTest(highs, "bgetam.mps", 0, expected_status, "off");
+  runHipoTest(highs, "forest6.mps", 0, expected_status, "off");
+  runHipoTest(highs, "klein1.mps", 0, expected_status, "off");
+  highs.resetGlobalScheduler(true);
+}